export type TelemetryPrimitive = string | number | boolean | null | undefined;
export type TelemetryValue = TelemetryPrimitive | TelemetryObject | TelemetryArray;
export type TelemetryObject = {
    [key: string]: TelemetryValue;
};
export type TelemetryArray = Array<TelemetryValue>;
export type TelemetryProperties = TelemetryObject;
export type SdkTelemetryErrorComponent = "shared" | "llms" | "agents" | "core" | "cli" | "vscode" | "desktop" | (string & {});
export type SdkTelemetryErrorSeverity = "debug" | "info" | "warn" | "error" | "fatal";
export interface CaptureSdkErrorInput {
    component: SdkTelemetryErrorComponent;
    operation: string;
    error: unknown;
    /**
     * A useful message derived while the caller still has domain-specific error
     * context. The raw error remains the source of type, code, and status.
     */
    errorMessage?: string;
    severity?: SdkTelemetryErrorSeverity;
    handled?: boolean;
    context?: TelemetryProperties;
    event?: string;
    messageLimit?: number;
}
export declare const AGENT_UNEXPECTED_REASONING_TOKENS_EVENT = "agent.reasoning.unexpected_tokens";
export interface CaptureAgentUnexpectedReasoningTokensInput {
    sessionId?: string;
    agentId: string;
    runId?: string;
    iteration: number;
    providerId?: string;
    modelId?: string;
    requestedThinking: false;
    reasoningTokenCount: number;
}
export declare const TASK_PROVIDER_REQUEST_STARTED_EVENT = "task.provider_request_started";
export declare const TASK_PROVIDER_STREAM_STARTED_EVENT = "task.provider_stream_started";
export declare const TASK_FIRST_CHUNK_RECEIVED_EVENT = "task.first_chunk_received";
export declare const TASK_PROVIDER_STREAM_FAILED_EVENT = "task.provider_stream_failed";
export declare const TASK_CANCELLED_EVENT = "task.cancelled";
export interface CaptureTaskLifecycleEventInput {
    event: string;
    sessionId?: string;
    ulid?: string;
    agentId?: string;
    conversationId?: string;
    runId?: string;
    iteration?: number;
    providerId?: string;
    modelId?: string;
    phase?: string;
    durationMs?: number;
    eventType?: string;
    error?: unknown;
    /**
     * Classification of `error` (e.g. context_window_exceeded), emitted as
     * `error_class` alongside the normalized error fields.
     */
    errorClass?: string;
    messageLimit?: number;
}
export interface TelemetryMetadata {
    extension_version: string;
    /**
     * The version of the host-side Cline distribution package: the JetBrains plugin version
     * (e.g. 1.1.61) on JetBrains, the extension version on VSCode (where it matches
     * `extension_version`). Absent when the host does not report one.
     */
    host_plugin_version?: string;
    cline_type: string;
    platform: string;
    platform_version: string;
    os_type: string;
    os_version: string;
    is_dev?: string;
    is_remote_workspace?: boolean;
}
export interface ITelemetryService {
    setDistinctId(distinctId?: string): void;
    setMetadata(metadata: Partial<TelemetryMetadata>): void;
    updateMetadata(metadata: Partial<TelemetryMetadata>): void;
    setCommonProperties(properties: TelemetryProperties): void;
    updateCommonProperties(properties: TelemetryProperties): void;
    isEnabled(): boolean;
    capture(input: {
        event: string;
        properties?: TelemetryProperties;
    }): void;
    captureRequired(event: string, properties?: TelemetryProperties): void;
    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
    flush(): Promise<void>;
    dispose(): Promise<void>;
}
export declare const SDK_ERROR_TELEMETRY_EVENT = "sdk.error";
/** Identical `sdk.error` emissions allowed per key per window. */
export declare const SDK_ERROR_RATE_LIMIT_MAX_PER_WINDOW = 5;
/** Suppression window for identical `sdk.error` emissions. */
export declare const SDK_ERROR_RATE_LIMIT_WINDOW_MS: number;
/**
 * Clear per-process `sdk.error` rate-limit state (test isolation).
 *
 * @internal Exported only so package test suites can isolate the
 * process-wide suppression state between tests; not a supported runtime API.
 */
export declare function resetSdkErrorRateLimiterForTests(): void;
export declare function captureAgentUnexpectedReasoningTokens(telemetry: ITelemetryService | undefined, input: CaptureAgentUnexpectedReasoningTokensInput): void;
export declare function captureTaskLifecycleEvent(telemetry: ITelemetryService | undefined, input: CaptureTaskLifecycleEventInput): void;
/**
 * Report an SDK error, subject to the per-process volume cap on identical
 * failures described above.
 *
 * Returns `true` when the failure is recorded — emitted, or counted toward
 * `suppressed_count` by the volume cap — and `false` when telemetry is
 * unavailable. Reporters that sit on a layer boundary forward the return
 * value (see `errorReported` on the model stream's `finish` event) so outer
 * layers know the failure is already accounted for and one underlying
 * failure produces one event, not one per layer it propagates through.
 */
export declare function captureSdkError(telemetry: ITelemetryService | undefined, input: CaptureSdkErrorInput): boolean;
export declare function buildSdkErrorProperties(input: CaptureSdkErrorInput): TelemetryProperties;
export declare function normalizeSdkError(error: unknown, messageLimit?: number, errorMessage?: string): TelemetryProperties;
export interface OpenTelemetryClientConfig {
    /**
     * Whether telemetry is enabled via OTEL_TELEMETRY_ENABLED
     */
    enabled: boolean;
    /**
     * Metrics exporter type(s) - can be comma-separated for multiple exporters
     * Examples: "console", "otlp", "console,otlp"
     */
    metricsExporter?: string;
    /**
     * Logs/events exporter type(s) - can be comma-separated for multiple exporters
     * Examples: "console", "otlp"
     */
    logsExporter?: string;
    /**
     * Distributed tracing exporter type(s) - comma-separated for multiple exporters.
     * Examples: "console", "otlp". When unset, no `TracerProvider` is registered.
     */
    tracesExporter?: string;
    /**
     * Protocol for OTLP exporters. SDK support is currently limited to "http/json".
     */
    otlpProtocol?: string;
    /**
     * General OTLP endpoint (used if specific endpoints not set)
     */
    otlpEndpoint?: string;
    /**
     * General OTLP headers
     */
    otlpHeaders?: Record<string, string>;
    /**
     * Metrics-specific OTLP protocol
     */
    otlpMetricsProtocol?: string;
    /**
     * Metrics-specific OTLP endpoint
     */
    otlpMetricsEndpoint?: string;
    otlpMetricsHeaders?: Record<string, string>;
    /**
     * Logs-specific OTLP protocol
     */
    otlpLogsProtocol?: string;
    /**
     * Logs-specific OTLP endpoint
     */
    otlpLogsEndpoint?: string;
    otlpLogsHeaders?: Record<string, string>;
    /**
     * Traces-specific OTLP protocol (SDK support is currently limited to "http/json")
     */
    otlpTracesProtocol?: string;
    /**
     * Traces-specific OTLP endpoint (defaults to {@link otlpEndpoint} when exporting OTLP traces)
     */
    otlpTracesEndpoint?: string;
    otlpTracesHeaders?: Record<string, string>;
    /**
     * Metric export interval in milliseconds (for console exporter)
     */
    metricExportInterval?: number;
    /**
     * Whether to use insecure (non-TLS) connections for gRPC OTLP exporters
     * Set to "true" for local development without TLS
     * Default: false (uses TLS)
     */
    otlpInsecure?: boolean;
    /**
     * Maximum batch size for log records (default: 512)
     */
    logBatchSize?: number;
    /**
     * Maximum time to wait before exporting logs in milliseconds (default: 5000)
     */
    logBatchTimeout?: number;
    /**
     * Maximum queue size for log records (default: 2048)
     */
    logMaxQueueSize?: number;
}