/**
 * Thin in-process shim for `@opentelemetry/api`.
 *
 * Core files that previously imported directly from `@opentelemetry/api` now
 * import from this module.  When the `ext-observability-opentelemetry` extension is present
 * the real SDK provider is wired in via `setGlobalTracerProvider`; otherwise
 * every call falls back to a no-op implementation so the core boots without the
 * extension installed.
 *
 * **Tracing types and constants** (exported for call-site use):
 *   `Span`, `Tracer`, `TracerProvider`, `Context`, `TextMapPropagator`
 *   `SpanKind`, `SpanStatusCode`
 *
 * **Metrics types** (re-exported structural shapes for the metrics subsystem;
 * not backed by a live SDK — the metrics subsystem is wired separately):
 *   `Meter`, `Counter`, `Histogram`, `ObservableGauge`, `UpDownCounter`,
 *   `ObservableResult`
 *
 * @module observability/tracing/api-shim
 */
export type AttributePrimitive = string | number | boolean;
export type AttributeValue = AttributePrimitive | readonly AttributePrimitive[] | undefined;
export interface Span {
    setAttribute(key: string, value: AttributeValue): Span;
    setAttributes(attrs: Record<string, AttributeValue>): Span;
    setStatus(status: {
        code: number;
        message?: string;
    }): Span;
    recordException(err: unknown): void;
    addEvent(name: string, attrs?: Record<string, AttributeValue>): Span;
    end(endTime?: number): void;
    spanContext(): SpanContext;
    updateName(name: string): void;
}
export interface SpanContext {
    traceId: string;
    spanId: string;
    traceFlags: number;
}
/**
 * A causal relationship to a span that is not this span's parent.
 *
 * Used for work whose cause is real but whose lifetime is independent: a
 * durable run linking back to the request that started it, or to its own
 * previous execution across a suspend.
 */
export interface Link {
    context: SpanContext;
    attributes?: Record<string, AttributeValue>;
}
export interface SpanStartOptions {
    kind?: number;
    attributes?: Record<string, AttributeValue>;
    links?: Link[];
    /** Start a new trace, ignoring any active span as parent. */
    root?: boolean;
}
export interface Tracer {
    startSpan(name: string, options?: SpanStartOptions, context?: Context): Span;
    startActiveSpan<T>(name: string, fn: (span: Span) => T): T;
    startActiveSpan<T>(name: string, options: {
        kind?: number;
        attributes?: Record<string, AttributeValue>;
    }, fn: (span: Span) => T): T;
    startActiveSpan<T>(name: string, options: {
        kind?: number;
        attributes?: Record<string, AttributeValue>;
    }, context: Context, fn: (span: Span) => T): T;
}
export interface TracerProvider {
    getTracer(name: string, version?: string): Tracer;
}
export interface Context {
    getValue(key: symbol): unknown;
    setValue(key: symbol, value: unknown): Context;
    deleteValue(key: symbol): Context;
}
export interface TextMapGetter<C = Record<string, string>> {
    keys(carrier: C): string[];
    get(carrier: C, key: string): string | string[] | undefined;
}
export interface TextMapSetter<C = Record<string, string>> {
    set(carrier: C, key: string, value: string): void;
}
export interface TextMapPropagator {
    inject(context: Context, carrier: unknown, setter?: TextMapSetter<unknown>): void;
    extract(context: Context, carrier: unknown, getter?: TextMapGetter<unknown>): Context;
    fields(): string[];
}
export interface ContextAccessor {
    active(): Context;
    with<T>(ctx: Context, fn: () => T): T;
}
export interface ActiveSpanAccessor {
    getActiveSpan(): Span | undefined;
    getSpan(ctx: Context): Span | undefined;
    setSpan?(ctx: Context, span: Span): Context;
}
export declare const SpanKind: {
    readonly INTERNAL: 0;
    readonly SERVER: 1;
    readonly CLIENT: 2;
    readonly PRODUCER: 3;
    readonly CONSUMER: 4;
};
export type SpanKind = typeof SpanKind[keyof typeof SpanKind];
export declare const SpanStatusCode: {
    readonly UNSET: 0;
    readonly OK: 1;
    readonly ERROR: 2;
};
export type SpanStatusCode = typeof SpanStatusCode[keyof typeof SpanStatusCode];
export interface ObservableResult {
    observe(value: number, attributes?: Record<string, AttributeValue>): void;
}
export interface Counter {
    add(value: number, attributes?: Record<string, AttributeValue>): void;
}
export interface UpDownCounter {
    add(value: number, attributes?: Record<string, AttributeValue>): void;
}
export interface Histogram {
    record(value: number, attributes?: Record<string, AttributeValue>): void;
}
export interface ObservableGauge {
    addCallback(callback: (result: ObservableResult) => void): void;
    removeCallback?(callback: (result: ObservableResult) => void): void;
}
export interface Meter {
    createCounter(name: string, options?: {
        description?: string;
        unit?: string;
    }): Counter;
    createUpDownCounter(name: string, options?: {
        description?: string;
        unit?: string;
    }): UpDownCounter;
    createHistogram(name: string, options?: {
        description?: string;
        unit?: string;
        advice?: {
            explicitBucketBoundaries?: number[];
        };
    }): Histogram;
    createObservableGauge(name: string, options?: {
        description?: string;
        unit?: string;
    }): ObservableGauge;
    getMeter?: never;
}
export interface MetricsAPI {
    getMeter(name: string | undefined, version?: string): Meter;
}
/** Complete provider facade installed into the process-wide telemetry shim. */
export interface GlobalTelemetryAPIConfig {
    tracerProvider?: TracerProvider | null;
    metricsApi?: MetricsAPI | null;
    contextAccessor?: ContextAccessor | null;
    activeSpanAccessor?: ActiveSpanAccessor | null;
    propagator?: TextMapPropagator | null;
}
/** Opaque ownership identity for one installed telemetry generation. */
export interface GlobalTelemetryAPIOwner {
    readonly generation: number;
    readonly token: symbol;
}
/** Handle returned by an atomic telemetry API installation. */
export interface GlobalTelemetryAPIInstallation extends GlobalTelemetryAPIOwner {
    /** Clear this generation if it is still current. Stale handles return false. */
    dispose(): boolean;
}
/** Immutable point-in-time view of the currently installed telemetry facade. */
export interface GlobalTelemetryAPISnapshot {
    readonly generation: number;
    readonly tracerProviderRevision: number;
    readonly metricsApiRevision: number;
    readonly tracerProviderInstalled: boolean;
    readonly tracerProvider: TracerProvider;
    readonly metricsApi: MetricsAPI | null;
    readonly contextAccessor: ContextAccessor | null;
    readonly activeSpanAccessor: ActiveSpanAccessor | null;
    readonly propagator: TextMapPropagator | null;
}
/** Atomically install one complete telemetry facade and return its owner handle. */
export declare function installGlobalTelemetryAPI(config: GlobalTelemetryAPIConfig): GlobalTelemetryAPIInstallation;
/** Clear the current generation without allowing stale owners to clobber it. */
export declare function clearGlobalTelemetryAPI(owner: GlobalTelemetryAPIOwner): boolean;
/** Read one internally consistent telemetry facade snapshot. */
export declare function getGlobalTelemetryAPISnapshot(): GlobalTelemetryAPISnapshot;
/**
 * Register the real OTel trace API's span accessors. Called by the
 * ext-observability-opentelemetry extension after it wires the SDK so that the shim's
 * `trace.getActiveSpan()` / `trace.getSpan()` can return real spans.
 */
export declare function setGlobalActiveSpanAccessor(accessor: ActiveSpanAccessor): void;
/**
 * Register the real OTel context API. This lets the shim preserve active span
 * context across async boundaries once the extension has installed the SDK's
 * AsyncLocalStorageContextManager.
 */
export declare function setGlobalContextAccessor(accessor: ContextAccessor): void;
/**
 * Wire in the real SDK TracerProvider.
 * Called from `src/server/bootstrap.ts` after `orchestrateExtensions()` runs.
 */
export declare function setGlobalTracerProvider(p: TracerProvider): void;
export declare function getGlobalTracerProvider(): TracerProvider;
export declare function getTracerProviderRevision(): number;
/**
 * Get a tracer from the active provider.
 * Returns the no-op tracer when ext-observability-opentelemetry is not installed.
 */
export declare function getTracer(name: string, version?: string): Tracer;
export declare const context: {
    active(): Context;
    with<T>(ctx: Context, fn: () => T): T;
    setGlobalContextManager(_mgr: unknown): void;
};
export declare const trace: {
    getTracer(name: string, version?: string): Tracer;
    setGlobalTracerProvider(p: TracerProvider): void;
    getGlobalTracerProvider(): TracerProvider;
    setSpan(ctx: Context, _span: Span): Context;
    getSpan(ctx: Context): Span | undefined;
    getActiveSpan(): Span | undefined;
};
export declare const propagation: {
    setGlobalPropagator(p: TextMapPropagator): void;
    extract<C>(ctx: Context, carrier: C, getter?: TextMapGetter<C>): Context;
    inject<C>(ctx: Context, carrier: C, setter?: TextMapSetter<C>): void;
};
export declare const defaultTextMapGetter: TextMapGetter<Record<string, string>>;
export declare const defaultTextMapSetter: TextMapSetter<Record<string, string>>;
/**
 * Register the OTel Metrics API (from the SDK).
 * Called by ext-observability-opentelemetry in its setup hook so the metrics subsystem
 * can use `getMeter()` when available.
 */
export declare function setGlobalMetricsAPI(api: MetricsAPI): void;
export declare function getGlobalMetricsAPI(): MetricsAPI | null;
/** Monotonic revision used by lazy instruments to detect provider changes. */
export declare function getMetricsApiRevision(): number;
export declare function _resetShimForTests(): void;
//# sourceMappingURL=api-shim.d.ts.map