import { type AttributeValue, type Context, SpanKind } from '@opentelemetry/api';
import { IncomingHttpHeaders } from 'http';
import { NodeKit } from '../nodekit';
import { AppConfig, AppContextParams, AppDynamicConfig, Dict } from '../types';
import { api, type tracing } from '@opentelemetry/sdk-node';
import { AppError } from './app-error';
import { NodeKitLogger } from './logging';
type ContextParams = ContextInitialParams | ContextParentParams;
interface ContextInitialParams {
    contextId?: string;
    config: AppConfig;
    logger: NodeKitLogger;
    stats: AppTelemetrySendStats;
    parentSpanContext?: Context;
    spanKind?: SpanKind;
    utils: NodeKit['utils'];
    dynamicConfig?: AppDynamicConfig;
    loggerPostfix?: string;
    loggerExtra?: Dict;
    tags?: Dict;
    spanExporter?: tracing.SpanExporter;
}
interface ContextProperties {
    inheritable?: boolean;
}
export interface AppTelemetrySendStats {
    (table: string, data: {
        [name: string]: string | number;
    }): void;
    (data: {
        [name: string]: string | number;
    }): void;
}
interface ContextParentParams extends Pick<ContextInitialParams, 'parentSpanContext' | 'loggerPostfix' | 'loggerExtra' | 'tags' | 'spanKind' | 'spanExporter'> {
    parentContext: AppContext;
}
type ContextCallbackFunction<T> = (ctx: AppContext) => T;
export declare class AppContext {
    name: string;
    config: AppConfig;
    parentContext?: AppContext;
    utils: NodeKit['utils'];
    stats: AppTelemetrySendStats;
    dynamicConfig: AppDynamicConfig;
    spanExporter?: tracing.SpanExporter;
    get abortSignal(): AbortSignal;
    protected appParams: AppContextParams;
    private logger;
    private span?;
    private startTime;
    private endTime?;
    private loggerPrefix;
    private loggerPostfix;
    private loggerExtra?;
    private abortController;
    private parentAbortListener?;
    private nonInheritableParamNames;
    constructor(name: string, params: ContextParams);
    log(message: string, extra?: Dict): void;
    logError(message: string, error?: AppError | Error | unknown, extra?: Dict): void;
    logWarn(message: string, error?: AppError | Error | unknown, extra?: Dict): void;
    create(name: string, params?: Omit<ContextParentParams, 'parentContext'>): AppContext;
    call<T>(name: string, fn: ContextCallbackFunction<T>, params?: Omit<ContextParentParams, 'parentContext'>): T;
    call<T>(name: string, fn: ContextCallbackFunction<Promise<T>>, params?: Omit<ContextParentParams, 'parentContext'>): Promise<T>;
    set<K extends keyof AppContextParams>(key: K, value: AppContextParams[K], properties?: ContextProperties): void;
    get<K extends keyof AppContextParams>(key: K): AppContextParams[K];
    setTag(key: string, value: AttributeValue): void;
    isEnded(): boolean;
    end(): void;
    fail(error?: AppError | Error | unknown): void;
    getTime(): number;
    extractSpanContext(headers: IncomingHttpHeaders): Context;
    getMetadata(): Record<string, string>;
    getTraceId(): string | undefined;
    getSpanId(): string | undefined;
    addLoggerExtra(key: string, value: unknown): void;
    getLoggerExtra(key: string): unknown;
    clearLoggerExtra(): void;
    get tracer(): api.Tracer | undefined;
    private isTracingEnabled;
    private prepareLogMessage;
    private prepareExtra;
    private mergeExtra;
    private getLogObject;
    private createAttributes;
    private removeParentAbortListener;
}
export {};