import { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, EmbeddingModelV3, EmbeddingModelV3CallOptions, EmbeddingModelV3Result, ProviderV3 } from '@ai-sdk/provider';
import { TextEmbedder } from '@mediapipe/tasks-text';
import { UIMessage } from 'ai';

/**
 * Callback type for receiving model download/initialization progress updates.
 * @param progress - A value between 0 and 1 indicating completion.
 */
type DownloadProgressCallback = (progress: number) => void;

type BrowserAIChatModelId = "text";
interface BrowserAIChatSettings extends Omit<LanguageModelCreateOptions, "initialPrompts"> {
    /**
     * Expected input types for the session, for multimodal inputs.
     */
    expectedInputs?: Array<{
        type: "text" | "image" | "audio";
        languages?: string[];
    }>;
    /**
     * Callback invoked when the model context window is exceeded.
     * Replaces the deprecated `onQuotaOverflow`.
     * @see [Prompt API Context Overflow](https://github.com/webmachinelearning/prompt-api?tab=readme-ov-file#tokenization-context-window-length-limits-and-overflow)
     */
    onContextOverflow?: (event: Event) => void;
    /**
     * @deprecated Use `onContextOverflow` instead.
     * @see [Prompt API Quota Overflow](https://github.com/webmachinelearning/prompt-api?tab=readme-ov-file#tokenization-context-window-length-limits-and-overflow)
     * @param event
     */
    onQuotaOverflow?: (event: Event) => void;
}
/**
 * Check if the browser supports the browser AI API
 * @returns true if the browser supports the browser AI API, false otherwise
 */
declare function doesBrowserSupportBrowserAI(): boolean;
declare class BrowserAIChatLanguageModel implements LanguageModelV3 {
    readonly specificationVersion = "v3";
    readonly modelId: BrowserAIChatModelId;
    readonly provider = "browser-ai";
    private readonly config;
    private readonly sessionManager;
    constructor(modelId: BrowserAIChatModelId, options?: BrowserAIChatSettings);
    readonly supportedUrls: Record<string, RegExp[]>;
    /**
     * Gets a session with the specified options
     * Delegates to SessionManager for all session lifecycle management
     * @private
     */
    private getSession;
    private getArgs;
    /**
     * Generates a complete text response using the browser's built-in Prompt API
     * @param options
     * @returns Promise resolving to the generated content with finish reason, usage stats, and any warnings
     * @throws {LoadSettingError} When the Prompt API is not available or model needs to be downloaded
     * @throws {UnsupportedFunctionalityError} When unsupported features like file input are used
     */
    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
    /**
     * Gets the current context usage (tokens consumed) for the current session, if available
     * @returns The context usage or undefined if not available
     */
    getContextUsage(): number | undefined;
    /**
     * Gets the context window size (token limit) for the current session, if available
     * @returns The context window size or undefined if not available
     */
    getContextWindow(): number | undefined;
    /**
     * @deprecated Use {@link getContextUsage} instead.
     */
    getInputUsage(): number | undefined;
    /**
     * @deprecated Use {@link getContextWindow} instead.
     */
    getInputQuota(): number | undefined;
    /**
     * Check the availability of the browser AI model
     * @returns Promise resolving to "unavailable", "available", or "available-after-download"
     */
    availability(): Promise<Availability>;
    /**
     * Creates a session with download progress monitoring.
     *
     * @example
     * ```typescript
     * const session = await model.createSessionWithProgress(
     *   (progress) => {
     *     console.log(`Download progress: ${Math.round(progress * 100)}%`);
     *   }
     * );
     * ```
     *
     * @param onDownloadProgress Optional callback receiving progress values from 0 to 1
     * @returns Promise resolving to the model instance
     * @throws {LoadSettingError} When the Prompt API is not available or model is unavailable
     */
    createSessionWithProgress(onDownloadProgress?: DownloadProgressCallback): Promise<BrowserAIChatLanguageModel>;
    /**
     * Generates a streaming text response using the browser's built-in Prompt API
     * @param options
     * @returns Promise resolving to a readable stream of text chunks and request metadata
     * @throws {LoadSettingError} When the Prompt API is not available or model needs to be downloaded
     * @throws {UnsupportedFunctionalityError} When unsupported features like file input are used
     */
    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
}

interface BrowserAIEmbeddingModelSettings {
    /**
     * An optional base path to specify the directory the Wasm files should be loaded from.
     * @default 'https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/text_wasm_internal.js'
     */
    wasmLoaderPath?: string;
    /**
     * It's about 6mb before gzip.
     * @default 'https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/text_wasm_internal.wasm'
     */
    wasmBinaryPath?: string;
    /**
     * The model path to the model asset file.
     * It's about 6.1mb before gzip.
     * @default 'https://pub-ddcfe353995744e89b8002f16bf98575.r2.dev/universal_sentence_encoder.tflite'
     */
    modelAssetPath?: string;
    /**
     * Whether to normalize the returned feature vector with L2 norm. Use this
     * option only if the model does not already contain a native L2_NORMALIZATION
     * TF Lite Op. In most cases, this is already the case and L2 norm is thus
     * achieved through TF Lite inference.
     * @default false
     */
    l2Normalize?: boolean;
    /**
     * Whether the returned embedding should be quantized to bytes via scalar
     * quantization. Embeddings are implicitly assumed to be unit-norm and
     * therefore any dimension is guaranteed to have a value in [-1.0, 1.0]. Use
     * the l2_normalize option if this is not the case.
     * @default false
     */
    quantize?: boolean;
    /**
     * Overrides the default backend to use for the provided model.
     */
    delegate?: "CPU" | "GPU";
}
declare class BrowserAIEmbeddingModel implements EmbeddingModelV3 {
    readonly specificationVersion = "v3";
    readonly provider = "google-mediapipe";
    readonly modelId: string;
    readonly supportsParallelCalls = true;
    readonly maxEmbeddingsPerCall: undefined;
    private settings;
    private modelAssetBuffer;
    private textEmbedder;
    constructor(settings?: BrowserAIEmbeddingModelSettings);
    protected getTextEmbedder: () => Promise<TextEmbedder>;
    doEmbed: (options: EmbeddingModelV3CallOptions) => Promise<EmbeddingModelV3Result>;
}

interface BrowserAIProvider extends ProviderV3 {
    (modelId?: BrowserAIChatModelId, settings?: BrowserAIChatSettings): BrowserAIChatLanguageModel;
    /**
     * Creates a model for text generation.
     */
    languageModel(modelId: BrowserAIChatModelId, settings?: BrowserAIChatSettings): BrowserAIChatLanguageModel;
    /**
     * Creates a model for text generation.
     */
    chat(modelId: BrowserAIChatModelId, settings?: BrowserAIChatSettings): BrowserAIChatLanguageModel;
    embedding(modelId: "embedding", settings?: BrowserAIEmbeddingModelSettings): EmbeddingModelV3;
    embeddingModel: (modelId: "embedding", settings?: BrowserAIEmbeddingModelSettings) => EmbeddingModelV3;
    imageModel(modelId: string): never;
    speechModel(modelId: string): never;
    transcriptionModel(modelId: string): never;
}
interface BrowserAIProviderSettings {
}
/**
 * Create a BrowserAI provider instance.
 */
declare function createBrowserAI(options?: BrowserAIProviderSettings): BrowserAIProvider;
/**
 * Default BrowserAI provider instance.
 */
declare const browserAI: BrowserAIProvider;

/**
 * UI message type for browser AI features with custom data parts.
 *
 * Extends base UIMessage to include specific data part schemas
 * for browser AI functionality such as model download progress tracking
 *
 * @example
 * // Import and use with useChat hook from @ai-sdk/react
 * ```typescript
 * import { useChat } from "@ai-sdk/react";
 * import { BrowserAIUIMessage } from "@browser-ai/core";
 *
 * const { messages, sendMessage } = useChat<BrowserAIUIMessage>({
 *   onData: (dataPart) => {
 *     if (dataPart.type === 'data-modelDownloadProgress') {
 *       console.log(`Download: ${dataPart.data.progress}%`);
 *     }
 *     if (dataPart.type === 'data-notification') {
 *       console.log(`${dataPart.data.level}: ${dataPart.data.message}`);
 *     }
 *   }
 * });
 * ```
 *
 * @see {@link https://v5.ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat | useChat hook documentation}
 */
type BrowserAIUIMessage = UIMessage<
  never, // No custom metadata type
  {
    /**
     * Model download progress data part for tracking browser AI model download status.
     * Used to display download progress bars and status messages to users.
     */
    modelDownloadProgress: {
      /** Current download/initialization status */
      status: "downloading" | "complete" | "error";
      /** Download progress percentage (0-100), undefined for non-downloading states */
      progress?: number;
      /** Human-readable status message to display to users */
      message: string;
    };
    /**
     * User notification data part for displaying temporary messages and alerts.
     * These are typically transient and not persisted in message history.
     */
    notification: {
      /** The notification message text */
      message: string;
      /** Notification severity level for styling and priority */
      level: "info" | "warning" | "error";
    };
  }
>;

export { BrowserAIChatLanguageModel, type BrowserAIChatSettings, BrowserAIEmbeddingModel, type BrowserAIEmbeddingModelSettings, type BrowserAIProvider, type BrowserAIProviderSettings, type BrowserAIUIMessage, browserAI, createBrowserAI, doesBrowserSupportBrowserAI };