@burdenoff/be-sdk 2026.510.79

package/dist/index-DoK0bjhH.d.ts

@@ -0,0 +1,607 @@
+import { L as Logger, l as logger } from './index-CrQgidpx.js';
+
+interface InstrumentationFeatureFlags {
+    tracing: boolean;
+    metrics: boolean;
+    logging: boolean;
+    graphql: boolean;
+    database: boolean;
+    http: boolean;
+    cache: boolean;
+    eventQueue: boolean;
+}
+interface TracingConfig {
+    enabled: boolean;
+    serviceName: string;
+    serviceVersion?: string;
+    environment?: string;
+    exporterEndpoint?: string;
+    exporterType?: 'otlp' | 'console' | 'none';
+    samplingRate?: number;
+    propagationFormat?: 'w3c' | 'b3' | 'jaeger';
+    resourceAttributes?: Record<string, string>;
+    ignoredRoutes?: string[];
+    ignoredOperations?: string[];
+}
+interface MetricsConfig {
+    enabled: boolean;
+    serviceName: string;
+    exporterEndpoint?: string;
+    exporterType?: 'otlp' | 'prometheus' | 'console' | 'none';
+    prometheusEndpoint?: string;
+    prometheusPort?: number;
+    collectInterval?: number;
+    defaultMetrics?: boolean;
+    metricPrefix?: string;
+}
+interface LoggingConfig {
+    enabled: boolean;
+    includeTraceId?: boolean;
+    includeSpanId?: boolean;
+    includeTraceFlags?: boolean;
+    level?: 'debug' | 'info' | 'warn' | 'error';
+}
+interface GraphQLInstrumentationConfig {
+    enabled: boolean;
+    includeDocument?: boolean;
+    includeVariables?: boolean;
+    includeResult?: boolean;
+    documentDepth?: number;
+    ignoredOperations?: string[];
+    includeResolvers?: boolean;
+    resolverSpanDepth?: number;
+}
+interface DatabaseInstrumentationConfig {
+    enabled: boolean;
+    includeStatement?: boolean;
+    includeParameters?: boolean;
+    includeRowCount?: boolean;
+    slowQueryThreshold?: number;
+    ignoredOperations?: string[];
+}
+interface HTTPInstrumentationConfig {
+    enabled: boolean;
+    includeRequestHeaders?: boolean;
+    includeResponseHeaders?: boolean;
+    includeRequestBody?: boolean;
+    includeResponseBody?: boolean;
+    redactedHeaders?: string[];
+    ignoredRoutes?: string[];
+    maxBodySize?: number;
+}
+interface CacheInstrumentationConfig {
+    enabled: boolean;
+    includeKey?: boolean;
+    includeValueSize?: boolean;
+    includeTTL?: boolean;
+}
+interface EventQueueInstrumentationConfig {
+    enabled: boolean;
+    includePayload?: boolean;
+    includeHeaders?: boolean;
+    maxPayloadSize?: number;
+}
+interface InstrumentationConfig {
+    enabled: boolean;
+    features: InstrumentationFeatureFlags;
+    tracing: TracingConfig;
+    metrics: MetricsConfig;
+    logging: LoggingConfig;
+    graphql: GraphQLInstrumentationConfig;
+    database: DatabaseInstrumentationConfig;
+    http: HTTPInstrumentationConfig;
+    cache: CacheInstrumentationConfig;
+    eventQueue: EventQueueInstrumentationConfig;
+}
+interface SpanAttributes$1 {
+    'service.name'?: string;
+    'service.version'?: string;
+    'deployment.environment'?: string;
+    'operation.name'?: string;
+    'operation.type'?: string;
+    'user.id'?: string;
+    'tenant.id'?: string;
+    'workspace.id'?: string;
+    'request.id'?: string;
+    error?: boolean;
+    'error.message'?: string;
+    'error.type'?: string;
+    [key: string]: string | number | boolean | undefined;
+}
+type MetricType = 'counter' | 'histogram' | 'gauge' | 'upDownCounter';
+interface MetricDefinition {
+    name: string;
+    description: string;
+    type: MetricType;
+    unit?: string;
+    labelKeys?: string[];
+    boundaries?: number[];
+}
+declare const STANDARD_METRICS: Record<string, MetricDefinition>;
+interface SpanContext {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    isRemote?: boolean;
+}
+interface TraceContext {
+    traceId?: string;
+    spanId?: string;
+    traceFlags?: number;
+    parentSpanId?: string;
+}
+interface OperationContext {
+    operationName: string;
+    operationType: string;
+    actorId?: string;
+    tenantId?: string;
+    workspaceId?: string;
+    requestId?: string;
+    attributes?: Record<string, string | number | boolean>;
+}
+
+type MetricLabels = Record<string, string>;
+interface Counter {
+    add(value: number, labels?: MetricLabels): void;
+    inc(labels?: MetricLabels): void;
+    getValue(labels?: MetricLabels): number;
+}
+interface Histogram {
+    record(value: number, labels?: MetricLabels): void;
+    getData(labels?: MetricLabels): HistogramData;
+}
+interface HistogramData {
+    count: number;
+    sum: number;
+    min: number;
+    max: number;
+    avg: number;
+    buckets: Map<number, number>;
+    percentiles: {
+        p50: number;
+        p75: number;
+        p90: number;
+        p95: number;
+        p99: number;
+    };
+}
+interface Gauge {
+    set(value: number, labels?: MetricLabels): void;
+    add(value: number, labels?: MetricLabels): void;
+    sub(value: number, labels?: MetricLabels): void;
+    getValue(labels?: MetricLabels): number;
+}
+interface UpDownCounter {
+    add(value: number, labels?: MetricLabels): void;
+    getValue(labels?: MetricLabels): number;
+}
+declare class MetricsRegistry {
+    private counters;
+    private histograms;
+    private gauges;
+    private upDownCounters;
+    private serviceName;
+    private metricPrefix;
+    constructor(serviceName: string, metricPrefix?: string);
+    getServiceName(): string;
+    private isEnabled;
+    private getPrefixedName;
+    createCounter(name: string, description: string): Counter;
+    createHistogram(name: string, description: string, boundaries?: number[]): Histogram;
+    createGauge(name: string, description: string): Gauge;
+    createUpDownCounter(name: string, description: string): UpDownCounter;
+    createFromDefinition(definition: MetricDefinition): Counter | Histogram | Gauge | UpDownCounter;
+    getAllMetrics(): {
+        counters: Array<{
+            name: string;
+            description: string;
+            values: Map<string, number>;
+        }>;
+        histograms: Array<{
+            name: string;
+            description: string;
+            data: Map<string, HistogramData>;
+        }>;
+        gauges: Array<{
+            name: string;
+            description: string;
+            values: Map<string, number>;
+        }>;
+        upDownCounters: Array<{
+            name: string;
+            description: string;
+            values: Map<string, number>;
+        }>;
+    };
+    private exportCountersToPrometheus;
+    private exportHistogramsToPrometheus;
+    private exportGaugesToPrometheus;
+    private exportUpDownCountersToPrometheus;
+    toPrometheusFormat(): string;
+    reset(): void;
+    clear(): void;
+}
+declare function initializeMetricsRegistry(serviceName: string, metricPrefix?: string): MetricsRegistry;
+declare function getMetricsRegistry(): MetricsRegistry;
+declare function isMetricsRegistryInitialized(): boolean;
+declare function resetMetricsRegistry(): void;
+declare function createCounter(name: string, description: string): Counter;
+declare function createHistogram(name: string, description: string, boundaries?: number[]): Histogram;
+declare function createGauge(name: string, description: string): Gauge;
+declare function createUpDownCounter(name: string, description: string): UpDownCounter;
+
+declare enum SpanStatus {
+    UNSET = 0,
+    OK = 1,
+    ERROR = 2
+}
+declare enum SpanKind {
+    INTERNAL = 0,
+    SERVER = 1,
+    CLIENT = 2,
+    PRODUCER = 3,
+    CONSUMER = 4
+}
+interface Span {
+    name: string;
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    kind: SpanKind;
+    startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    attributes: SpanAttributes$1;
+    events: SpanEvent[];
+    isRecording: boolean;
+    setAttribute(key: string, value: string | number | boolean): Span;
+    setAttributes(attributes: SpanAttributes$1): Span;
+    setStatus(status: SpanStatus, message?: string): Span;
+    recordException(error: Error): Span;
+    addEvent(name: string, attributes?: SpanAttributes$1): Span;
+    end(): void;
+    getSpanContext(): SpanContext;
+}
+interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: SpanAttributes$1;
+}
+declare class Tracer {
+    private serviceName;
+    private activeSpans;
+    private currentSpan;
+    private spanListeners;
+    constructor(serviceName: string);
+    isEnabled(): boolean;
+    startSpan(name: string, kind?: SpanKind, parentContext?: SpanContext): Span;
+    startSpanFromContext(context: OperationContext, kind?: SpanKind): Span;
+    getCurrentSpan(): Span | null;
+    getTraceContext(): TraceContext;
+    setCurrentSpan(span: Span): void;
+    withSpan<T>(name: string, fn: (span: Span) => Promise<T>, kind?: SpanKind, parentContext?: SpanContext): Promise<T>;
+    withSpanSync<T>(name: string, fn: (span: Span) => T, kind?: SpanKind, parentContext?: SpanContext): T;
+    addSpanListener(listener: (span: Span) => void): void;
+    removeSpanListener(listener: (span: Span) => void): void;
+    private onSpanEnd;
+    private logSpan;
+    getActiveSpanCount(): number;
+    clearActiveSpans(): void;
+}
+declare function initializeTracer(serviceName: string): Tracer;
+declare function getTracer(): Tracer;
+declare function isTracerInitialized(): boolean;
+declare function startSpan(name: string, kind?: SpanKind, parentContext?: SpanContext): Span;
+declare function withSpan<T>(name: string, fn: (span: Span) => Promise<T>, kind?: SpanKind): Promise<T>;
+declare function getTraceContext(): TraceContext;
+declare function extractTraceContext(headers: Record<string, string | string[] | undefined>): SpanContext | undefined;
+declare function injectTraceContext(headers: Record<string, string>, spanContext?: SpanContext): void;
+
+interface PrometheusPluginOptions {
+    endpoint?: string | false;
+    skipIntrospection?: boolean;
+    httpDuration?: boolean;
+    requestDuration?: boolean;
+    requestCount?: boolean;
+    errorCount?: boolean;
+    resolverMetrics?: boolean;
+    instrumentResolvers?: string[];
+    deprecatedFields?: boolean;
+    parsePhase?: boolean;
+    validatePhase?: boolean;
+    contextPhase?: boolean;
+    executePhase?: boolean;
+}
+declare function createPrometheusPlugin(options?: PrometheusPluginOptions): unknown | null;
+declare function isPrometheusAvailable(): boolean;
+interface ApolloInlineTraceOptions {
+    includeFieldTraces?: boolean;
+    includeVariables?: boolean;
+    excludeOperations?: string[];
+}
+declare function createApolloInlineTracePlugin(_options?: ApolloInlineTraceOptions): unknown | null;
+declare function isApolloInlineTraceAvailable(): boolean;
+type GraphQLOperationType = 'query' | 'mutation' | 'subscription';
+interface GraphQLOperationInfo {
+    operationType: GraphQLOperationType;
+    operationName: string | null;
+    document?: string;
+    variables?: Record<string, unknown>;
+}
+interface InstrumentationContextExtension {
+    _instrumentation?: {
+        span?: Span;
+        startTime?: number;
+        operationInfo?: GraphQLOperationInfo;
+    };
+}
+declare function extractOperationInfo(args: {
+    document?: {
+        loc?: {
+            source?: {
+                body?: string;
+            };
+        };
+        definitions?: unknown[];
+    };
+    operationName?: string | null;
+    variableValues?: Record<string, unknown>;
+}): GraphQLOperationInfo;
+declare function createGraphQLInstrumentationPlugin(): {
+    onExecute: (args: {
+        args: {
+            document?: unknown;
+            operationName?: string | null;
+            variableValues?: Record<string, unknown>;
+            contextValue?: unknown;
+        };
+    }) => {
+        onExecuteDone: (args: {
+            result: unknown;
+            setResult?: (result: unknown) => void;
+        }) => void;
+    } | undefined;
+    onSubscribe?: (args: {
+        args: unknown;
+    }) => void;
+};
+declare function instrumentResolver<TArgs extends unknown[], TResult>(name: string, resolver: (...args: TArgs) => Promise<TResult>, options?: {
+    includeArgs?: boolean;
+    includeResult?: boolean;
+    attributes?: Record<string, string | number | boolean>;
+}): (...args: TArgs) => Promise<TResult>;
+declare function instrumentResolverMap<T extends Record<string, Record<string, (...args: unknown[]) => Promise<unknown>>>>(resolverMap: T, options?: {
+    includeTypes?: string[];
+    excludeTypes?: string[];
+    excludeFields?: string[];
+}): T;
+declare function getGraphQLOperationFromContext(context: unknown): GraphQLOperationInfo | undefined;
+declare function getGraphQLSpanFromContext(context: unknown): Span | undefined;
+
+declare const ENV_VARS: {
+    readonly INSTRUMENTATION_ENABLED: "INSTRUMENTATION_ENABLED";
+    readonly INSTRUMENTATION_TRACING: "INSTRUMENTATION_TRACING";
+    readonly INSTRUMENTATION_METRICS: "INSTRUMENTATION_METRICS";
+    readonly INSTRUMENTATION_LOGGING: "INSTRUMENTATION_LOGGING";
+    readonly INSTRUMENTATION_GRAPHQL: "INSTRUMENTATION_GRAPHQL";
+    readonly INSTRUMENTATION_DATABASE: "INSTRUMENTATION_DATABASE";
+    readonly INSTRUMENTATION_HTTP: "INSTRUMENTATION_HTTP";
+    readonly INSTRUMENTATION_CACHE: "INSTRUMENTATION_CACHE";
+    readonly INSTRUMENTATION_EVENT_QUEUE: "INSTRUMENTATION_EVENT_QUEUE";
+    readonly OTEL_SERVICE_NAME: "OTEL_SERVICE_NAME";
+    readonly OTEL_SERVICE_VERSION: "OTEL_SERVICE_VERSION";
+    readonly OTEL_ENVIRONMENT: "OTEL_ENVIRONMENT";
+    readonly OTEL_EXPORTER_OTLP_ENDPOINT: "OTEL_EXPORTER_OTLP_ENDPOINT";
+    readonly OTEL_EXPORTER_TYPE: "OTEL_EXPORTER_TYPE";
+    readonly OTEL_SAMPLING_RATE: "OTEL_SAMPLING_RATE";
+    readonly OTEL_PROPAGATION_FORMAT: "OTEL_PROPAGATION_FORMAT";
+    readonly METRICS_EXPORTER_TYPE: "METRICS_EXPORTER_TYPE";
+    readonly METRICS_PROMETHEUS_ENDPOINT: "METRICS_PROMETHEUS_ENDPOINT";
+    readonly METRICS_PROMETHEUS_PORT: "METRICS_PROMETHEUS_PORT";
+    readonly METRICS_COLLECT_INTERVAL: "METRICS_COLLECT_INTERVAL";
+    readonly METRICS_DEFAULT_ENABLED: "METRICS_DEFAULT_ENABLED";
+    readonly METRICS_PREFIX: "METRICS_PREFIX";
+    readonly DB_INSTRUMENTATION_INCLUDE_STATEMENT: "DB_INSTRUMENTATION_INCLUDE_STATEMENT";
+    readonly DB_INSTRUMENTATION_SLOW_QUERY_THRESHOLD: "DB_INSTRUMENTATION_SLOW_QUERY_THRESHOLD";
+    readonly GRAPHQL_INSTRUMENTATION_INCLUDE_DOCUMENT: "GRAPHQL_INSTRUMENTATION_INCLUDE_DOCUMENT";
+    readonly GRAPHQL_INSTRUMENTATION_INCLUDE_VARIABLES: "GRAPHQL_INSTRUMENTATION_INCLUDE_VARIABLES";
+    readonly GRAPHQL_INSTRUMENTATION_INCLUDE_RESOLVERS: "GRAPHQL_INSTRUMENTATION_INCLUDE_RESOLVERS";
+};
+declare const DEFAULT_FEATURE_FLAGS: InstrumentationFeatureFlags;
+declare const DEFAULT_TRACING_CONFIG: TracingConfig;
+declare const DEFAULT_METRICS_CONFIG: MetricsConfig;
+declare const DEFAULT_LOGGING_CONFIG: LoggingConfig;
+declare const DEFAULT_GRAPHQL_CONFIG: GraphQLInstrumentationConfig;
+declare const DEFAULT_DATABASE_CONFIG: DatabaseInstrumentationConfig;
+declare const DEFAULT_HTTP_CONFIG: HTTPInstrumentationConfig;
+declare const DEFAULT_CACHE_CONFIG: CacheInstrumentationConfig;
+declare const DEFAULT_EVENT_QUEUE_CONFIG: EventQueueInstrumentationConfig;
+declare function buildFeatureFlags(overrides?: Partial<InstrumentationFeatureFlags>): InstrumentationFeatureFlags;
+declare function buildTracingConfig(serviceName: string, overrides?: Partial<TracingConfig>): TracingConfig;
+declare function buildMetricsConfig(serviceName: string, overrides?: Partial<MetricsConfig>): MetricsConfig;
+declare function buildDatabaseConfig(overrides?: Partial<DatabaseInstrumentationConfig>): DatabaseInstrumentationConfig;
+declare function buildGraphQLConfig(overrides?: Partial<GraphQLInstrumentationConfig>): GraphQLInstrumentationConfig;
+declare function buildInstrumentationConfig(serviceName: string, overrides?: Partial<InstrumentationConfig>): InstrumentationConfig;
+declare function initializeInstrumentationConfig(serviceName: string, overrides?: Partial<InstrumentationConfig>): InstrumentationConfig;
+declare function getInstrumentationConfig(): InstrumentationConfig;
+declare function isInstrumentationConfigInitialized(): boolean;
+declare function isFeatureEnabled(feature: keyof InstrumentationFeatureFlags): boolean;
+declare function updateInstrumentationConfig(updates: Partial<InstrumentationConfig>): InstrumentationConfig;
+declare function resetInstrumentationConfig(): void;
+
+type SpanAttributes = Record<string, string | number | boolean>;
+interface TraceOptions {
+    name?: string;
+    kind?: SpanKind;
+    attributes?: SpanAttributes;
+    includeArgs?: boolean;
+    includeResult?: boolean;
+    extractAttributes?: (args: unknown[]) => SpanAttributes;
+    skip?: boolean | ((args: unknown[]) => boolean);
+}
+interface MetricOptions {
+    name?: string;
+    labels?: MetricLabels | ((args: unknown[], result?: unknown) => MetricLabels);
+    recordCount?: boolean;
+    recordDuration?: boolean;
+    boundaries?: number[];
+}
+interface LogOptions {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    includeArgs?: boolean;
+    includeResult?: boolean;
+    logEntry?: boolean;
+    logExit?: boolean;
+    logError?: boolean;
+    message?: string;
+}
+interface InstrumentOptions {
+    operationName?: string;
+    operationType?: string;
+    trace?: TraceOptions | boolean;
+    metrics?: MetricOptions | boolean;
+    log?: LogOptions | boolean;
+    skip?: boolean | ((args: unknown[]) => boolean);
+}
+declare function Trace(options?: TraceOptions): MethodDecorator;
+declare function Metric(options?: MetricOptions): MethodDecorator;
+declare function Log(options?: LogOptions): MethodDecorator;
+declare function Instrument(options?: InstrumentOptions): MethodDecorator;
+declare function traced<T extends (...args: unknown[]) => Promise<unknown>>(name: string, fn: T, options?: TraceOptions): T;
+declare function instrumented<T extends (...args: unknown[]) => Promise<unknown>>(name: string, fn: T, options?: InstrumentOptions): T;
+
+declare function getLogger(): Logger;
+interface InitializeInstrumentationOptions {
+    features?: Partial<InstrumentationFeatureFlags>;
+    tracing?: Partial<TracingConfig>;
+    metrics?: Partial<MetricsConfig>;
+    logging?: Partial<LoggingConfig>;
+    graphql?: Partial<GraphQLInstrumentationConfig>;
+    database?: Partial<DatabaseInstrumentationConfig>;
+    http?: Partial<HTTPInstrumentationConfig>;
+    cache?: Partial<CacheInstrumentationConfig>;
+    eventQueue?: Partial<EventQueueInstrumentationConfig>;
+}
+declare function initializeInstrumentation(serviceName: string, options?: InitializeInstrumentationOptions): {
+    tracer: Tracer;
+    metrics: MetricsRegistry;
+    config: InstrumentationConfig;
+};
+declare function isInstrumentationInitialized(): boolean;
+declare function resetInstrumentation(): void;
+interface SetupInstrumentationOptions extends InitializeInstrumentationOptions {
+    useApolloInlineTrace?: boolean;
+    usePrometheus?: boolean;
+    prometheus?: PrometheusPluginOptions;
+}
+interface InstrumentationSetupResult {
+    tracer: Tracer;
+    metrics: MetricsRegistry;
+    config: InstrumentationConfig;
+    plugins: unknown[];
+}
+declare function setupInstrumentation(serviceName: string, options?: SetupInstrumentationOptions): InstrumentationSetupResult;
+
+type index_ApolloInlineTraceOptions = ApolloInlineTraceOptions;
+type index_CacheInstrumentationConfig = CacheInstrumentationConfig;
+type index_Counter = Counter;
+declare const index_DEFAULT_CACHE_CONFIG: typeof DEFAULT_CACHE_CONFIG;
+declare const index_DEFAULT_DATABASE_CONFIG: typeof DEFAULT_DATABASE_CONFIG;
+declare const index_DEFAULT_EVENT_QUEUE_CONFIG: typeof DEFAULT_EVENT_QUEUE_CONFIG;
+declare const index_DEFAULT_FEATURE_FLAGS: typeof DEFAULT_FEATURE_FLAGS;
+declare const index_DEFAULT_GRAPHQL_CONFIG: typeof DEFAULT_GRAPHQL_CONFIG;
+declare const index_DEFAULT_HTTP_CONFIG: typeof DEFAULT_HTTP_CONFIG;
+declare const index_DEFAULT_LOGGING_CONFIG: typeof DEFAULT_LOGGING_CONFIG;
+declare const index_DEFAULT_METRICS_CONFIG: typeof DEFAULT_METRICS_CONFIG;
+declare const index_DEFAULT_TRACING_CONFIG: typeof DEFAULT_TRACING_CONFIG;
+type index_DatabaseInstrumentationConfig = DatabaseInstrumentationConfig;
+declare const index_ENV_VARS: typeof ENV_VARS;
+type index_EventQueueInstrumentationConfig = EventQueueInstrumentationConfig;
+type index_Gauge = Gauge;
+type index_GraphQLInstrumentationConfig = GraphQLInstrumentationConfig;
+type index_GraphQLOperationInfo = GraphQLOperationInfo;
+type index_GraphQLOperationType = GraphQLOperationType;
+type index_HTTPInstrumentationConfig = HTTPInstrumentationConfig;
+type index_Histogram = Histogram;
+type index_InitializeInstrumentationOptions = InitializeInstrumentationOptions;
+declare const index_Instrument: typeof Instrument;
+type index_InstrumentationConfig = InstrumentationConfig;
+type index_InstrumentationContextExtension = InstrumentationContextExtension;
+type index_InstrumentationFeatureFlags = InstrumentationFeatureFlags;
+type index_InstrumentationSetupResult = InstrumentationSetupResult;
+declare const index_Log: typeof Log;
+type index_LoggingConfig = LoggingConfig;
+declare const index_Metric: typeof Metric;
+type index_MetricDefinition = MetricDefinition;
+type index_MetricLabels = MetricLabels;
+type index_MetricsConfig = MetricsConfig;
+type index_MetricsRegistry = MetricsRegistry;
+declare const index_MetricsRegistry: typeof MetricsRegistry;
+type index_OperationContext = OperationContext;
+type index_PrometheusPluginOptions = PrometheusPluginOptions;
+declare const index_STANDARD_METRICS: typeof STANDARD_METRICS;
+type index_SetupInstrumentationOptions = SetupInstrumentationOptions;
+type index_Span = Span;
+type index_SpanContext = SpanContext;
+type index_SpanEvent = SpanEvent;
+type index_SpanKind = SpanKind;
+declare const index_SpanKind: typeof SpanKind;
+type index_SpanStatus = SpanStatus;
+declare const index_SpanStatus: typeof SpanStatus;
+declare const index_Trace: typeof Trace;
+type index_TraceContext = TraceContext;
+type index_Tracer = Tracer;
+declare const index_Tracer: typeof Tracer;
+type index_TracingConfig = TracingConfig;
+type index_UpDownCounter = UpDownCounter;
+declare const index_buildDatabaseConfig: typeof buildDatabaseConfig;
+declare const index_buildFeatureFlags: typeof buildFeatureFlags;
+declare const index_buildGraphQLConfig: typeof buildGraphQLConfig;
+declare const index_buildInstrumentationConfig: typeof buildInstrumentationConfig;
+declare const index_buildMetricsConfig: typeof buildMetricsConfig;
+declare const index_buildTracingConfig: typeof buildTracingConfig;
+declare const index_createApolloInlineTracePlugin: typeof createApolloInlineTracePlugin;
+declare const index_createCounter: typeof createCounter;
+declare const index_createGauge: typeof createGauge;
+declare const index_createGraphQLInstrumentationPlugin: typeof createGraphQLInstrumentationPlugin;
+declare const index_createHistogram: typeof createHistogram;
+declare const index_createPrometheusPlugin: typeof createPrometheusPlugin;
+declare const index_createUpDownCounter: typeof createUpDownCounter;
+declare const index_extractOperationInfo: typeof extractOperationInfo;
+declare const index_extractTraceContext: typeof extractTraceContext;
+declare const index_getGraphQLOperationFromContext: typeof getGraphQLOperationFromContext;
+declare const index_getGraphQLSpanFromContext: typeof getGraphQLSpanFromContext;
+declare const index_getInstrumentationConfig: typeof getInstrumentationConfig;
+declare const index_getLogger: typeof getLogger;
+declare const index_getMetricsRegistry: typeof getMetricsRegistry;
+declare const index_getTraceContext: typeof getTraceContext;
+declare const index_getTracer: typeof getTracer;
+declare const index_initializeInstrumentation: typeof initializeInstrumentation;
+declare const index_initializeInstrumentationConfig: typeof initializeInstrumentationConfig;
+declare const index_initializeMetricsRegistry: typeof initializeMetricsRegistry;
+declare const index_initializeTracer: typeof initializeTracer;
+declare const index_injectTraceContext: typeof injectTraceContext;
+declare const index_instrumentResolver: typeof instrumentResolver;
+declare const index_instrumentResolverMap: typeof instrumentResolverMap;
+declare const index_instrumented: typeof instrumented;
+declare const index_isApolloInlineTraceAvailable: typeof isApolloInlineTraceAvailable;
+declare const index_isFeatureEnabled: typeof isFeatureEnabled;
+declare const index_isInstrumentationConfigInitialized: typeof isInstrumentationConfigInitialized;
+declare const index_isInstrumentationInitialized: typeof isInstrumentationInitialized;
+declare const index_isMetricsRegistryInitialized: typeof isMetricsRegistryInitialized;
+declare const index_isPrometheusAvailable: typeof isPrometheusAvailable;
+declare const index_isTracerInitialized: typeof isTracerInitialized;
+declare const index_logger: typeof logger;
+declare const index_resetInstrumentation: typeof resetInstrumentation;
+declare const index_resetInstrumentationConfig: typeof resetInstrumentationConfig;
+declare const index_resetMetricsRegistry: typeof resetMetricsRegistry;
+declare const index_setupInstrumentation: typeof setupInstrumentation;
+declare const index_startSpan: typeof startSpan;
+declare const index_traced: typeof traced;
+declare const index_updateInstrumentationConfig: typeof updateInstrumentationConfig;
+declare const index_withSpan: typeof withSpan;
+declare namespace index {
+  export { type index_ApolloInlineTraceOptions as ApolloInlineTraceOptions, type index_CacheInstrumentationConfig as CacheInstrumentationConfig, type index_Counter as Counter, index_DEFAULT_CACHE_CONFIG as DEFAULT_CACHE_CONFIG, index_DEFAULT_DATABASE_CONFIG as DEFAULT_DATABASE_CONFIG, index_DEFAULT_EVENT_QUEUE_CONFIG as DEFAULT_EVENT_QUEUE_CONFIG, index_DEFAULT_FEATURE_FLAGS as DEFAULT_FEATURE_FLAGS, index_DEFAULT_GRAPHQL_CONFIG as DEFAULT_GRAPHQL_CONFIG, index_DEFAULT_HTTP_CONFIG as DEFAULT_HTTP_CONFIG, index_DEFAULT_LOGGING_CONFIG as DEFAULT_LOGGING_CONFIG, index_DEFAULT_METRICS_CONFIG as DEFAULT_METRICS_CONFIG, index_DEFAULT_TRACING_CONFIG as DEFAULT_TRACING_CONFIG, type index_DatabaseInstrumentationConfig as DatabaseInstrumentationConfig, index_ENV_VARS as ENV_VARS, type index_EventQueueInstrumentationConfig as EventQueueInstrumentationConfig, type index_Gauge as Gauge, type index_GraphQLInstrumentationConfig as GraphQLInstrumentationConfig, type index_GraphQLOperationInfo as GraphQLOperationInfo, type index_GraphQLOperationType as GraphQLOperationType, type index_HTTPInstrumentationConfig as HTTPInstrumentationConfig, type index_Histogram as Histogram, type index_InitializeInstrumentationOptions as InitializeInstrumentationOptions, index_Instrument as Instrument, type index_InstrumentationConfig as InstrumentationConfig, type index_InstrumentationContextExtension as InstrumentationContextExtension, type index_InstrumentationFeatureFlags as InstrumentationFeatureFlags, type index_InstrumentationSetupResult as InstrumentationSetupResult, index_Log as Log, type index_LoggingConfig as LoggingConfig, index_Metric as Metric, type index_MetricDefinition as MetricDefinition, type index_MetricLabels as MetricLabels, type index_MetricsConfig as MetricsConfig, index_MetricsRegistry as MetricsRegistry, type index_OperationContext as OperationContext, type index_PrometheusPluginOptions as PrometheusPluginOptions, index_STANDARD_METRICS as STANDARD_METRICS, type index_SetupInstrumentationOptions as SetupInstrumentationOptions, type index_Span as Span, type SpanAttributes$1 as SpanAttributes, type index_SpanContext as SpanContext, type index_SpanEvent as SpanEvent, index_SpanKind as SpanKind, index_SpanStatus as SpanStatus, index_Trace as Trace, type index_TraceContext as TraceContext, index_Tracer as Tracer, type index_TracingConfig as TracingConfig, type index_UpDownCounter as UpDownCounter, index_buildDatabaseConfig as buildDatabaseConfig, index_buildFeatureFlags as buildFeatureFlags, index_buildGraphQLConfig as buildGraphQLConfig, index_buildInstrumentationConfig as buildInstrumentationConfig, index_buildMetricsConfig as buildMetricsConfig, index_buildTracingConfig as buildTracingConfig, index_createApolloInlineTracePlugin as createApolloInlineTracePlugin, index_createCounter as createCounter, index_createGauge as createGauge, index_createGraphQLInstrumentationPlugin as createGraphQLInstrumentationPlugin, index_createHistogram as createHistogram, index_createPrometheusPlugin as createPrometheusPlugin, index_createUpDownCounter as createUpDownCounter, index_extractOperationInfo as extractOperationInfo, index_extractTraceContext as extractTraceContext, index_getGraphQLOperationFromContext as getGraphQLOperationFromContext, index_getGraphQLSpanFromContext as getGraphQLSpanFromContext, index_getInstrumentationConfig as getInstrumentationConfig, index_getLogger as getLogger, index_getMetricsRegistry as getMetricsRegistry, index_getTraceContext as getTraceContext, index_getTracer as getTracer, index_initializeInstrumentation as initializeInstrumentation, index_initializeInstrumentationConfig as initializeInstrumentationConfig, index_initializeMetricsRegistry as initializeMetricsRegistry, index_initializeTracer as initializeTracer, index_injectTraceContext as injectTraceContext, index_instrumentResolver as instrumentResolver, index_instrumentResolverMap as instrumentResolverMap, index_instrumented as instrumented, index_isApolloInlineTraceAvailable as isApolloInlineTraceAvailable, index_isFeatureEnabled as isFeatureEnabled, index_isInstrumentationConfigInitialized as isInstrumentationConfigInitialized, index_isInstrumentationInitialized as isInstrumentationInitialized, index_isMetricsRegistryInitialized as isMetricsRegistryInitialized, index_isPrometheusAvailable as isPrometheusAvailable, index_isTracerInitialized as isTracerInitialized, index_logger as logger, index_resetInstrumentation as resetInstrumentation, index_resetInstrumentationConfig as resetInstrumentationConfig, index_resetMetricsRegistry as resetMetricsRegistry, index_setupInstrumentation as setupInstrumentation, index_startSpan as startSpan, index_traced as traced, index_updateInstrumentationConfig as updateInstrumentationConfig, index_withSpan as withSpan };
+}
+
+export { buildFeatureFlags as $, type ApolloInlineTraceOptions as A, type MetricsConfig as B, type CacheInstrumentationConfig as C, DEFAULT_CACHE_CONFIG as D, ENV_VARS as E, MetricsRegistry as F, type Gauge as G, type HTTPInstrumentationConfig as H, type InstrumentationSetupResult as I, STANDARD_METRICS as J, type Span as K, Log as L, Metric as M, type SpanAttributes$1 as N, type OperationContext as O, type PrometheusPluginOptions as P, type SpanContext as Q, type SpanEvent as R, type SetupInstrumentationOptions as S, SpanKind as T, SpanStatus as U, Trace as V, type TraceContext as W, Tracer as X, type TracingConfig as Y, type UpDownCounter as Z, buildDatabaseConfig as _, index as a, buildGraphQLConfig as a0, buildInstrumentationConfig as a1, buildMetricsConfig as a2, buildTracingConfig as a3, createApolloInlineTracePlugin as a4, createCounter as a5, createGauge as a6, createGraphQLInstrumentationPlugin as a7, createHistogram as a8, createPrometheusPlugin as a9, resetMetricsRegistry as aA, startSpan as aB, traced as aC, updateInstrumentationConfig as aD, withSpan as aE, createUpDownCounter as aa, extractOperationInfo as ab, extractTraceContext as ac, getGraphQLOperationFromContext as ad, getGraphQLSpanFromContext as ae, getInstrumentationConfig as af, getLogger as ag, getMetricsRegistry as ah, getTraceContext as ai, getTracer as aj, initializeInstrumentationConfig as ak, initializeMetricsRegistry as al, initializeTracer as am, injectTraceContext as an, instrumentResolver as ao, instrumentResolverMap as ap, instrumented as aq, isApolloInlineTraceAvailable as ar, isFeatureEnabled as as, isInstrumentationConfigInitialized as at, isInstrumentationInitialized as au, isMetricsRegistryInitialized as av, isPrometheusAvailable as aw, isTracerInitialized as ax, resetInstrumentation as ay, resetInstrumentationConfig as az, type Counter as b, DEFAULT_DATABASE_CONFIG as c, DEFAULT_EVENT_QUEUE_CONFIG as d, DEFAULT_FEATURE_FLAGS as e, DEFAULT_GRAPHQL_CONFIG as f, DEFAULT_HTTP_CONFIG as g, DEFAULT_LOGGING_CONFIG as h, initializeInstrumentation as i, DEFAULT_METRICS_CONFIG as j, DEFAULT_TRACING_CONFIG as k, type DatabaseInstrumentationConfig as l, type EventQueueInstrumentationConfig as m, type GraphQLInstrumentationConfig as n, type GraphQLOperationInfo as o, type GraphQLOperationType as p, type Histogram as q, type InitializeInstrumentationOptions as r, setupInstrumentation as s, Instrument as t, type InstrumentationConfig as u, type InstrumentationContextExtension as v, type InstrumentationFeatureFlags as w, type LoggingConfig as x, type MetricDefinition as y, type MetricLabels as z };