import { type SpanContext } from "@opentelemetry/api";
import type { ObservabilityConfig } from "./observability-config.js";
import { type DiscordResponseObservation, type InvalidRequestPressureSnapshot } from "./invalid-request-pressure.js";
import { startOtlpRuntime, type OtlpHealthSink, type OtlpRuntimeState, type OtlpSignal } from "./otel-runtime.js";
export declare const OPERATIONAL_ERROR_CATEGORIES: readonly ["audit-error", "cancelled", "configuration-error", "coordination-conflict", "coordination-quarantined", "coordination-state-error", "discord-client-error", "discord-rate-limited", "discord-server-error", "evidence-error", "execution-error", "idempotency-conflict", "identity-error", "local-rate-limited", "network-error", "plan-changed", "policy-error", "timeout", "unknown", "validation-error"];
export type OperationalErrorCategory = typeof OPERATIONAL_ERROR_CATEGORIES[number];
export type OperationalOutcome = "error" | "ok" | "tool-error";
export type OperationalKind = "discord-rest" | "mcp-tool";
export type HttpStatusClass = "1xx" | "2xx" | "3xx" | "4xx" | "5xx" | "none";
export interface OperationCompletion {
    errorCategory?: OperationalErrorCategory;
    outcome: OperationalOutcome;
    statusCode?: number;
}
export interface OperationObservation {
    end(completion: OperationCompletion): void;
    response(response: DiscordResponseObservation): void;
    retry(): void;
    run<T>(callback: () => Promise<T>): Promise<T>;
}
export interface OperationalObserver {
    getObservabilityStatus(): ObservabilitySnapshot;
    startDiscordRequest(operation: string): OperationObservation;
    startTool(name: string, remoteParent?: SpanContext): OperationObservation;
}
export interface ObservabilityRuntime extends OperationalObserver {
    start(): void;
    stop(): Promise<void>;
}
export interface DurationSnapshot {
    buckets: Array<{
        count: number;
        leMs: number;
    }>;
    count: number;
    maxMs: number;
    sumMs: number;
}
export interface OperationSnapshot {
    active: number;
    calls: number;
    duration: DurationSnapshot;
    errors: number;
    operation: string;
    outcomes: Record<OperationalOutcome, number>;
    retries: number;
}
export interface ObservabilitySnapshot {
    exporter: {
        attempts: number;
        enabled: boolean;
        endpointConfigured: boolean;
        failures: number;
        headersConfigured: boolean;
        lastFailureAt: string | null;
        lastSuccessAt: string | null;
        state: "disabled" | "failed" | "not-started" | "running" | "stopped";
        successes: number;
    };
    logging: {
        enabled: boolean;
        failures: number;
    };
    invalidRequests: InvalidRequestPressureSnapshot;
    operations: {
        discordRest: OperationSnapshot[];
        mcpTools: OperationSnapshot[];
        totals: OperationSnapshot;
    };
    privacy: {
        argumentsStored: false;
        contentStored: false;
        discordIdentifiersStored: false;
        errorDetailsStored: false;
        persistent: false;
        rawRoutesStored: false;
    };
    schemaVersion: number;
    startedAt: string;
    status: "ok";
}
export interface OperationalTelemetryOptions {
    clock?: () => number;
    config: ObservabilityConfig;
    monotonicClock?: () => number;
    otlpFactory?: typeof startOtlpRuntime;
    shutdownTimeoutMs?: number;
    stderr?: Pick<NodeJS.WriteStream, "write">;
}
export declare function classifyOperationalError(error: unknown): OperationalErrorCategory;
export declare class OperationalTelemetry implements ObservabilityRuntime, OtlpHealthSink {
    #private;
    constructor(options: OperationalTelemetryOptions);
    start(): void;
    stop(): Promise<void>;
    transitionExporter(state: OtlpRuntimeState): void;
    recordExport(signal: OtlpSignal, success: boolean): void;
    startTool(name: string, remoteParent?: SpanContext): OperationObservation;
    startDiscordRequest(operationName: string): OperationObservation;
    getObservabilityStatus(): ObservabilitySnapshot;
}
//# sourceMappingURL=observability.d.ts.map