import { Telemetry, GenerateTextStartEvent, GenerateObjectStartEvent, EmbedStartEvent, RerankStartEvent, GenerateTextStepStartEvent, LanguageModelCallStartEvent, LanguageModelCallEndEvent, ToolSet, ToolExecutionStartEvent, ToolExecutionEndEvent, GenerateTextStepEndEvent, GenerateObjectStepStartEvent, GenerateObjectStepEndEvent, EmbeddingModelCallStartEvent, EmbeddingModelCallEndEvent, RerankingModelCallStartEvent, RerankingModelCallEndEvent, GenerateTextEndEvent, GenerateObjectEndEvent, EmbedEndEvent, RerankEndEvent, GenerateTextAbortEvent } from 'ai';
import { Tracer } from '@opentelemetry/api';

type LangfusePrompt = {
    name: string;
    version: number;
    isFallback?: boolean;
};
type LangfuseVercelAiSdkIntegrationOptions = {
    tracer?: Tracer;
};

/**
 * Langfuse telemetry integration for Vercel AI SDK v7 (`ai@7`).
 *
 * Register this once at application startup (or pass it per-call via
 * `telemetry.integrations`) and every AI SDK call — `generateText`,
 * `streamText`, `generateObject`, `embed`, tool executions — is traced as
 * Langfuse observations. Requires the `LangfuseSpanProcessor` from
 * `@langfuse/otel` to be registered with your OpenTelemetry setup; this
 * integration only creates spans, the processor exports them to Langfuse.
 *
 * For AI SDK versions ≤6, do not use this class — enable
 * `experimental_telemetry: { isEnabled: true }` on each call instead; the
 * `LangfuseSpanProcessor` picks those spans up without an integration.
 *
 * Trace-level attributes (userId, sessionId, tags, traceName, metadata)
 * should be set with `propagateAttributes` from `@langfuse/tracing` around
 * the AI SDK call. Runtime context keys included via the AI SDK `telemetry`
 * option become Langfuse observation metadata; the special key
 * `langfusePrompt` links a Langfuse prompt version to model-call
 * observations instead.
 *
 * @example
 * ```typescript
 * // instrumentation.ts — run once at startup
 * import { registerTelemetry } from "ai";
 * import { LangfuseSpanProcessor } from "@langfuse/otel";
 * import { LangfuseVercelAiSdkIntegration } from "@langfuse/vercel-ai-sdk";
 * import { NodeSDK } from "@opentelemetry/sdk-node";
 *
 * const sdk = new NodeSDK({ spanProcessors: [new LangfuseSpanProcessor()] });
 * sdk.start();
 * registerTelemetry(new LangfuseVercelAiSdkIntegration());
 *
 * // app code
 * import { generateText } from "ai";
 * import { propagateAttributes } from "@langfuse/tracing";
 *
 * const { text } = await propagateAttributes(
 *   { userId: "user-123", sessionId: "session-456" },
 *   () =>
 *     generateText({
 *       model,
 *       prompt: "Explain RAG in one paragraph",
 *       telemetry: { functionId: "chat-assistant" },
 *     }),
 * );
 * ```
 *
 * @see https://langfuse.com/integrations/frameworks/vercel-ai-sdk for the full guide incl. Next.js setup
 * @see https://langfuse.com/docs/observability/sdk/overview
 *
 * @public
 */
declare class LangfuseVercelAiSdkIntegration implements Telemetry {
    private readonly delegate;
    constructor(options?: LangfuseVercelAiSdkIntegrationOptions);
    executeTool<T>(params: {
        callId: string;
        toolCallId: string;
        execute: () => PromiseLike<T>;
    }): PromiseLike<T>;
    executeLanguageModelCall<T>(params: {
        callId: string;
        execute: () => PromiseLike<T>;
    }): PromiseLike<T>;
    onStart(event: GenerateTextStartEvent | GenerateObjectStartEvent | EmbedStartEvent | RerankStartEvent): void;
    onStepStart(event: GenerateTextStepStartEvent): void;
    onLanguageModelCallStart(event: LanguageModelCallStartEvent): void;
    onLanguageModelCallEnd(event: LanguageModelCallEndEvent<ToolSet>): void;
    onToolExecutionStart(event: ToolExecutionStartEvent<ToolSet>): void;
    onToolExecutionEnd(event: ToolExecutionEndEvent<ToolSet>): void;
    onStepEnd(event: GenerateTextStepEndEvent<ToolSet>): void;
    /** @deprecated AI SDK v7 still emits object generation model spans through this callback. */
    onObjectStepStart(event: GenerateObjectStepStartEvent): void;
    /** @deprecated AI SDK v7 still emits object generation model spans through this callback. */
    onObjectStepEnd(event: GenerateObjectStepEndEvent): void;
    onEmbedStart(event: EmbeddingModelCallStartEvent): void;
    onEmbedEnd(event: EmbeddingModelCallEndEvent): void;
    onRerankStart(event: RerankingModelCallStartEvent): void;
    onRerankEnd(event: RerankingModelCallEndEvent): void;
    onEnd(event: GenerateTextEndEvent<ToolSet> | GenerateObjectEndEvent<unknown> | EmbedEndEvent | RerankEndEvent): void;
    onAbort(event: GenerateTextAbortEvent<ToolSet>): void;
    onError(error: unknown): void;
}

export { type LangfusePrompt, LangfuseVercelAiSdkIntegration, type LangfuseVercelAiSdkIntegrationOptions };