import { LanguageModelV3FunctionTool, JSONSchema7, LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamResult, EmbeddingModelV3, EmbeddingModelV3CallOptions, EmbeddingModelV3Result, TranscriptionModelV3, TranscriptionModelV3CallOptions, ProviderV3 } from '@ai-sdk/provider';
import { PretrainedModelOptions, ProgressInfo } from '@huggingface/transformers';
import { UIMessage } from 'ai';

/**
 * Tool definition in AI SDK format (function tools only)
 */
type ToolDefinition = Pick<LanguageModelV3FunctionTool, "name" | "description"> & {
    parameters: JSONSchema7;
};

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

declare global {
    interface Navigator {
        gpu?: unknown;
    }
}
type TransformersJSModelId = string;
interface TransformersJSModelSettings extends Pick<PretrainedModelOptions, "device" | "dtype"> {
    /**
     * Optional ONNX external data format toggle.
     * Keep undefined to use Transformers.js defaults.
     */
    use_external_data_format?: boolean;
    /**
     * Progress callback for model initialization
     */
    initProgressCallback?: DownloadProgressCallback;
    /**
     * Raw progress callback from Transformers.js
     */
    rawInitProgressCallback?: (progress: ProgressInfo) => void;
    /**
     * Whether this is a vision model
     * @default false
     */
    isVisionModel?: boolean;
    /**
     * Optional Web Worker to run the model off the main thread
     */
    worker?: Worker;
    /**
     * Optional path to load local models from.
     * Overrides the transformers.js env.localModelPath setting.
     * @see https://huggingface.co/docs/transformers.js/api/env
     * @example '~/models' or '/path/to/models'
     */
    localModelPath?: string;
    /**
     * Optional directory to use for caching files.
     * Overrides the transformers.js env.cacheDir setting.
     * @see https://huggingface.co/docs/transformers.js/api/env
     * @example '~/model-cache' or '/path/to/cache'
     */
    cacheDir?: string;
}
/**
 * Check if we're running in a browser environment
 */
declare function isBrowserEnvironment(): boolean;
/**
 * Check if we're running in a server environment (Node.js)
 */
declare function isServerEnvironment(): boolean;
/**
 * Check if the browser supports TransformersJS with optimal performance
 * Returns true if the browser has WebGPU or WebAssembly support
 * @returns true if the browser supports TransformersJS, false otherwise
 */
declare function doesBrowserSupportTransformersJS(): boolean;
declare class TransformersJSLanguageModel implements LanguageModelV3 {
    readonly specificationVersion = "v3";
    readonly modelId: TransformersJSModelId;
    readonly provider = "transformers-js";
    private readonly config;
    private modelInstance?;
    private isInitialized;
    private initializationPromise?;
    private stoppingCriteria;
    private workerReady;
    constructor(modelId: TransformersJSModelId, options?: TransformersJSModelSettings);
    readonly supportedUrls: Record<string, RegExp[]>;
    private getSession;
    private _initializeModel;
    private resolveDevice;
    private resolveDtype;
    private createProgressTracker;
    private getArgs;
    /**
     * Check the availability of the TransformersJS model
     */
    availability(): Promise<"unavailable" | "downloadable" | "available">;
    /**
     * Creates a session with download progress monitoring
     */
    createSessionWithProgress(onDownloadProgress?: DownloadProgressCallback): Promise<TransformersJSLanguageModel>;
    /**
     * Generates a complete text response using TransformersJS
     */
    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
    private initializeWorker;
    /**
     * Generates a streaming text response using TransformersJS
     */
    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
}

type TransformersJSEmbeddingModelId = string;
interface TransformersJSEmbeddingSettings extends Pick<PretrainedModelOptions, "device" | "dtype"> {
    /**
     * Progress callback for model initialization
     */
    initProgressCallback?: DownloadProgressCallback;
    /**
     * Raw progress callback from Transformers.js
     */
    rawInitProgressCallback?: (progress: ProgressInfo) => void;
    /**
     * Whether to normalize embeddings
     * @default true
     */
    normalize?: boolean;
    /**
     * Pooling strategy for token embeddings
     * @default "mean"
     */
    pooling?: "mean" | "cls" | "max";
    /**
     * Maximum number of tokens per input
     * @default 512
     */
    maxTokens?: number;
}
declare class TransformersJSEmbeddingModel implements EmbeddingModelV3 {
    readonly specificationVersion = "v3";
    readonly provider = "transformers-js";
    readonly modelId: TransformersJSEmbeddingModelId;
    readonly maxEmbeddingsPerCall = 100;
    readonly supportsParallelCalls = false;
    private readonly config;
    private pipeline;
    private tokenizer;
    private isInitialized;
    private initializationPromise?;
    constructor(modelId: TransformersJSEmbeddingModelId, options?: TransformersJSEmbeddingSettings);
    private getSession;
    private _initializeModel;
    private resolveDevice;
    private resolveDtype;
    private createProgressTracker;
    private applyPooling;
    private normalizeVector;
    /**
     * Check the availability of the TransformersJS embedding model
     */
    availability(): Promise<"unavailable" | "downloadable" | "available">;
    /**
     * Creates a session with download progress monitoring
     */
    createSessionWithProgress(onDownloadProgress?: DownloadProgressCallback): Promise<TransformersJSEmbeddingModel>;
    doEmbed(options: EmbeddingModelV3CallOptions): Promise<EmbeddingModelV3Result>;
}

type TransformersJSTranscriptionModelId = string;
interface TransformersJSTranscriptionSettings extends Pick<PretrainedModelOptions, "device" | "dtype"> {
    /**
     * Progress callback for model initialization
     */
    initProgressCallback?: DownloadProgressCallback;
    /**
     * Raw progress callback from Transformers.js
     */
    rawInitProgressCallback?: (progress: ProgressInfo) => void;
    /**
     * Maximum number of new tokens to generate
     * @default 64
     */
    maxNewTokens?: number;
    /**
     * Language hint for better transcription accuracy
     */
    language?: string;
    /**
     * Return timestamps for segments
     * @default false
     */
    returnTimestamps?: boolean;
    /**
     * Optional Web Worker to run the model off the main thread
     */
    worker?: Worker;
}
declare class TransformersJSTranscriptionModel implements TranscriptionModelV3 {
    readonly specificationVersion = "v3";
    readonly provider = "transformers-js";
    readonly modelId: TransformersJSTranscriptionModelId;
    private readonly config;
    private modelInstance?;
    private isInitialized;
    private initializationPromise?;
    private workerReady;
    constructor(modelId: TransformersJSTranscriptionModelId, options?: TransformersJSTranscriptionSettings);
    private getSession;
    private _initializeModel;
    private resolveDevice;
    private resolveDtype;
    private createProgressTracker;
    private convertAudioToFloat32Array;
    private getArgs;
    /**
     * Check the availability of the TransformersJS transcription model
     */
    availability(): Promise<"unavailable" | "downloadable" | "available">;
    /**
     * Creates a session with download progress monitoring
     */
    createSessionWithProgress(onDownloadProgress?: DownloadProgressCallback): Promise<TransformersJSTranscriptionModel>;
    doGenerate(options: TranscriptionModelV3CallOptions): Promise<Awaited<ReturnType<TranscriptionModelV3["doGenerate"]>>>;
    private doGenerateWithWorker;
    private initializeWorker;
}

interface TransformersJSProvider extends ProviderV3 {
    (modelId: TransformersJSModelId, settings?: TransformersJSModelSettings): TransformersJSLanguageModel;
    /**
     * Creates a model for text generation.
     */
    languageModel(modelId: TransformersJSModelId, settings?: TransformersJSModelSettings): TransformersJSLanguageModel;
    /**
     * Creates a model for text generation.
     */
    chat(modelId: TransformersJSModelId, settings?: TransformersJSModelSettings): TransformersJSLanguageModel;
    embedding(modelId: TransformersJSEmbeddingModelId, settings?: TransformersJSEmbeddingSettings): EmbeddingModelV3;
    embeddingModel: (modelId: TransformersJSEmbeddingModelId, settings?: TransformersJSEmbeddingSettings) => EmbeddingModelV3;
    transcription(modelId: TransformersJSTranscriptionModelId, settings?: TransformersJSTranscriptionSettings): TranscriptionModelV3;
    transcriptionModel: (modelId: TransformersJSTranscriptionModelId, settings?: TransformersJSTranscriptionSettings) => TranscriptionModelV3;
}
interface TransformersJSProviderSettings {
}
/**
 * Create a TransformersJS provider instance.
 */
declare function createTransformersJS(options?: TransformersJSProviderSettings): TransformersJSProvider;
/**
 * Default TransformersJS provider instance.
 */
declare const transformersJS: TransformersJSProvider;

/**
 * UI message type for transformers.js with custom data parts.
 *
 * Extends base UIMessage to include specific data part schemas
 * 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 { TransformersUIMessage } from "@browser-ai/transformers-js";
 *
 * const { messages, sendMessage } = useChat<TransformersUIMessage>({
 *   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 TransformersUIMessage = 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";
    };
  }
>;

interface GenerationOptions {
    max_new_tokens?: number;
    temperature?: number;
    top_k?: number;
    top_p?: number;
    do_sample?: boolean;
    repetition_penalty?: number;
    num_beams?: number;
    early_stopping?: boolean;
}

/**
 * Message content for different worker message types
 */
interface WorkerLoadData {
    modelId?: string;
    dtype?: PretrainedModelOptions["dtype"];
    device?: PretrainedModelOptions["device"];
    use_external_data_format?: boolean;
    isVisionModel?: boolean;
}
interface WorkerGenerateData {
    role: string;
    content: string | Array<{
        type: string;
        text?: string;
        image?: string;
    }>;
}
/**
 * Message types for worker communication
 */
type WorkerMessage = {
    type: "load";
    data?: WorkerLoadData;
} | {
    type: "generate";
    data: WorkerGenerateData[];
    generationOptions?: GenerationOptions;
    tools?: ToolDefinition[];
    enableThinking?: boolean;
} | {
    type: "interrupt";
} | {
    type: "reset";
};
/**
 * Configuration options for worker model loading
 */
interface WorkerLoadOptions extends Pick<PretrainedModelOptions, "dtype" | "device"> {
    modelId?: string;
    use_external_data_format?: boolean;
    isVisionModel?: boolean;
}

declare class TransformersJSWorkerHandler {
    private stopping_criteria;
    private isVisionModel;
    private currentModelKey;
    private past_key_values_cache;
    private cachedSequenceTokenIds;
    generate(messages: WorkerGenerateData[], generationOptions?: GenerationOptions, tools?: ToolDefinition[], enableThinking?: boolean): Promise<void>;
    private runGeneration;
    load(options?: WorkerLoadData): Promise<void>;
    interrupt(): void;
    reset(): void;
    private clearGenerationCache;
    private canReuseCache;
    private updateGenerationCache;
    private extractFirstSequenceTokenIds;
    private extractTokenIds;
    private sendMessage;
    private sendUpdate;
    private sendError;
    private createThrottledProgressCallback;
    onmessage(e: MessageEvent<WorkerMessage>): void;
}

interface TranscriptionWorkerMessage {
    type: "load" | "generate" | "interrupt" | "reset";
    data?: any;
}
interface TranscriptionWorkerLoadOptions {
    modelId?: string;
    dtype?: string;
    device?: string;
}
/**
 * Worker handler for TransformersJS transcription models that runs in a Web Worker context.
 *
 * This class manages the lifecycle of transcription models in a worker thread, providing
 * audio transcription capabilities without blocking the main UI thread. It handles model
 * loading, initialization, transcription generation, and communication with the main thread.
 *
 * @example
 * ```typescript
 * // worker.ts
 * import { TransformersJSTranscriptionWorkerHandler } from "@browser-ai/transformers-js";
 *
 * const handler = new TransformersJSTranscriptionWorkerHandler();
 * self.onmessage = (msg: MessageEvent) => {
 * handler.onmessage(msg);
 * };
 * ```
 */
declare class TransformersJSTranscriptionWorkerHandler {
    private processing;
    private currentModelKey;
    generate({ audio, language, maxNewTokens, }: {
        audio: any;
        language?: string;
        maxNewTokens?: number;
    }): Promise<void>;
    load(options?: TranscriptionWorkerLoadOptions): Promise<void>;
    interrupt(): void;
    reset(): void;
    private sendMessage;
    private sendUpdate;
    private sendError;
    private createThrottledProgressCallback;
    onmessage(e: MessageEvent<TranscriptionWorkerMessage>): void;
}

export { type GenerationOptions, TransformersJSEmbeddingModel, type TransformersJSEmbeddingModelId, type TransformersJSEmbeddingSettings, TransformersJSLanguageModel, type TransformersJSModelId, type TransformersJSModelSettings, type TransformersJSProvider, type TransformersJSProviderSettings, TransformersJSTranscriptionModel, type TransformersJSTranscriptionModelId, type TransformersJSTranscriptionSettings, TransformersJSTranscriptionWorkerHandler, TransformersJSWorkerHandler, type TransformersUIMessage, type WorkerLoadOptions, createTransformersJS, doesBrowserSupportTransformersJS, isBrowserEnvironment, isServerEnvironment, transformersJS };