import { RunAnywhere } from '@runanywhere/core';

await RunAnywhere.initialize(options: SDKInitOptions): Promise<void>

interface SDKInitOptions {
  /** API key for authentication (production/staging) */
  apiKey?: string;

  /** Base URL for API requests */
  baseURL?: string;

  /** SDK environment */
  environment?: SDKEnvironment;

  /** Supabase project URL (development mode only) */
  supabaseURL?: string;

  /** Supabase anon key (development mode only) */
  supabaseKey?: string;

  /** Enable debug logging */
  debug?: boolean;
}

enum SDKEnvironment {
  Development = 'development',
  Staging = 'staging',
  Production = 'production',
}

// Development mode (no API key needed)
await RunAnywhere.initialize({
  environment: SDKEnvironment.Development,
});

// Production mode
await RunAnywhere.initialize({
  apiKey: 'your-api-key',
  baseURL: 'https://api.runanywhere.ai',
  environment: SDKEnvironment.Production,
});

await RunAnywhere.isInitialized(): Promise<boolean>

const isReady = await RunAnywhere.isInitialized();
if (!isReady) {
  await RunAnywhere.initialize({ ... });
}

await RunAnywhere.reset(): Promise<void>

await RunAnywhere.reset();
// SDK can now be reinitialized with different options

await RunAnywhere.destroy(): Promise<void>

await RunAnywhere.loadModel(modelPath: string): Promise<boolean>

const modelInfo = await RunAnywhere.getModelInfo('smollm2-360m-q8_0');
if (modelInfo?.localPath) {
  await RunAnywhere.loadModel(modelInfo.localPath);
}

await RunAnywhere.isModelLoaded(): Promise<boolean>

await RunAnywhere.unloadModel(): Promise<void>

// Free memory when done
await RunAnywhere.unloadModel();

await RunAnywhere.chat(prompt: string): Promise<string>

const response = await RunAnywhere.chat('What is the capital of France?');
console.log(response);

await RunAnywhere.generate(
  prompt: string,
  options?: GenerationOptions
): Promise<GenerationResult>

interface GenerationOptions {
  /** Maximum number of tokens to generate (default: 256) */
  maxTokens?: number;

  /** Temperature for sampling (0.0 - 2.0, default: 0.7) */
  temperature?: number;

  /** Top-p sampling parameter (default: 0.95) */
  topP?: number;

  /** Stop sequences - stop generation when encountered */
  stopSequences?: string[];

  /** System prompt to define AI behavior */
  systemPrompt?: string;

  /** Preferred execution target */
  preferredExecutionTarget?: ExecutionTarget;

  /** Preferred framework for generation */
  preferredFramework?: LLMFramework;
}

interface GenerationResult {
  /** Generated text (with thinking content removed if extracted) */
  text: string;

  /** Thinking/reasoning content extracted from the response */
  thinkingContent?: string;

  /** Number of tokens used */
  tokensUsed: number;

  /** Model used for generation */
  modelUsed: string;

  /** Latency in milliseconds */
  latencyMs: number;

  /** Execution target (device/cloud/hybrid) */
  executionTarget: ExecutionTarget;

  /** Framework used for generation */
  framework?: LLMFramework;

  /** Hardware acceleration used */
  hardwareUsed: HardwareAcceleration;

  /** Memory used during generation (bytes) */
  memoryUsed: number;

  /** Detailed performance metrics */
  performanceMetrics: PerformanceMetrics;

  /** Number of tokens in the response content */
  responseTokens: number;
}

interface PerformanceMetrics {
  /** Time to first token in milliseconds */
  timeToFirstTokenMs?: number;

  /** Tokens generated per second */
  tokensPerSecond?: number;

  /** Total inference time in milliseconds */
  inferenceTimeMs: number;
}

const result = await RunAnywhere.generate(
  'Explain quantum computing in simple terms',
  {
    maxTokens: 200,
    temperature: 0.7,
    systemPrompt: 'You are a helpful science teacher.',
  }
);

console.log('Response:', result.text);
console.log('Tokens:', result.tokensUsed);
console.log('Speed:', result.performanceMetrics.tokensPerSecond, 'tok/s');
console.log('TTFT:', result.performanceMetrics.timeToFirstTokenMs, 'ms');

await RunAnywhere.generateStream(
  prompt: string,
  options?: GenerationOptions
): Promise<LLMStreamingResult>

interface LLMStreamingResult {
  /** Async iterator for tokens */
  stream: AsyncIterable<string>;

  /** Promise resolving to final result with metrics */
  result: Promise<GenerationResult>;
}

const streamResult = await RunAnywhere.generateStream(
  'Write a poem about AI',
  { maxTokens: 150 }
);

// Display tokens in real-time
let fullText = '';
for await (const token of streamResult.stream) {
  fullText += token;
  console.log(token);  // Each token as it's generated
}

// Get final metrics
const finalResult = await streamResult.result;
console.log('Speed:', finalResult.performanceMetrics.tokensPerSecond, 'tok/s');

await RunAnywhere.cancelGeneration(): Promise<void>

await RunAnywhere.loadSTTModel(
  modelPath: string,
  modelType?: string
): Promise<boolean>

const sttModel = await RunAnywhere.getModelInfo('sherpa-onnx-whisper-tiny.en');
await RunAnywhere.loadSTTModel(sttModel.localPath, 'whisper');

await RunAnywhere.isSTTModelLoaded(): Promise<boolean>

await RunAnywhere.unloadSTTModel(): Promise<void>

await RunAnywhere.transcribeFile(
  audioPath: string,
  options?: STTOptions
): Promise<STTResult>

interface STTOptions {
  /** Language code (e.g., 'en', 'es') */
  language?: string;

  /** Enable punctuation */
  punctuation?: boolean;

  /** Enable speaker diarization */
  diarization?: boolean;

  /** Enable word timestamps */
  wordTimestamps?: boolean;

  /** Sample rate */
  sampleRate?: number;
}

interface STTResult {
  /** Main transcription text */
  text: string;

  /** Segments with timing */
  segments: STTSegment[];

  /** Detected language */
  language?: string;

  /** Overall confidence (0.0 - 1.0) */
  confidence: number;

  /** Duration in seconds */
  duration: number;

  /** Alternative transcriptions */
  alternatives: STTAlternative[];
}

interface STTSegment {
  text: string;
  startTime: number;
  endTime: number;
  speakerId?: string;
  confidence: number;
}

const result = await RunAnywhere.transcribeFile(audioFilePath, {
  language: 'en',
  wordTimestamps: true,
});

console.log('Text:', result.text);
console.log('Confidence:', result.confidence);
console.log('Duration:', result.duration, 'seconds');

await RunAnywhere.transcribe(
  audioData: string,
  options?: STTOptions
): Promise<STTResult>

await RunAnywhere.transcribeBuffer(
  samples: number[],
  sampleRate: number,
  options?: STTOptions
): Promise<STTResult>

await RunAnywhere.loadTTSModel(
  modelPath: string,
  modelType?: string
): Promise<boolean>

const ttsModel = await RunAnywhere.getModelInfo('vits-piper-en_US-lessac-medium');
await RunAnywhere.loadTTSModel(ttsModel.localPath, 'piper');

await RunAnywhere.loadTTSVoice(voiceId: string): Promise<boolean>

await RunAnywhere.isTTSModelLoaded(): Promise<boolean>

await RunAnywhere.unloadTTSModel(): Promise<void>

await RunAnywhere.synthesize(
  text: string,
  options?: TTSConfiguration
): Promise<TTSResult>

interface TTSConfiguration {
  /** Voice identifier */
  voice?: string;

  /** Speech rate (0.5 - 2.0, default: 1.0) */
  rate?: number;

  /** Pitch (0.5 - 2.0, default: 1.0) */
  pitch?: number;

  /** Volume (0.0 - 1.0, default: 1.0) */
  volume?: number;
}

interface TTSResult {
  /** Base64-encoded audio data (float32 PCM) */
  audio: string;

  /** Sample rate of the audio */
  sampleRate: number;

  /** Number of samples */
  numSamples: number;

  /** Duration in seconds */
  duration: number;
}

const result = await RunAnywhere.synthesize(
  'Hello from the SDK.',
  { rate: 1.0, pitch: 1.0, volume: 0.8 }
);

console.log('Duration:', result.duration, 'seconds');
console.log('Sample rate:', result.sampleRate);
// result.audio contains base64-encoded float32 PCM

await RunAnywhere.synthesizeStream(
  text: string,
  options?: TTSConfiguration,
  callback?: (chunk: TTSOutput) => void
): Promise<TTSResult>

await RunAnywhere.speak(
  text: string,
  options?: TTSConfiguration
): Promise<TTSSpeakResult>

await RunAnywhere.stopSpeaking(): Promise<void>

await RunAnywhere.isSpeaking(): Promise<boolean>

await RunAnywhere.availableTTSVoices(): Promise<TTSVoiceInfo[]>

await RunAnywhere.initializeVAD(
  config?: VADConfiguration
): Promise<boolean>

interface VADConfiguration {
  /** Energy threshold for speech detection */
  energyThreshold?: number;

  /** Sample rate */
  sampleRate?: number;

  /** Frame length in milliseconds */
  frameLength?: number;

  /** Enable auto calibration */
  autoCalibration?: boolean;
}

await RunAnywhere.loadVADModel(modelPath: string): Promise<boolean>

await RunAnywhere.isVADModelLoaded(): Promise<boolean>

await RunAnywhere.processVAD(
  audioSamples: number[]
): Promise<VADResult>

interface VADResult {
  /** Whether speech is detected */
  isSpeech: boolean;

  /** Confidence score (0.0 - 1.0) */
  confidence: number;

  /** Start time of speech segment */
  startTime?: number;

  /** End time of speech segment */
  endTime?: number;
}

await RunAnywhere.startVAD(): Promise<void>

await RunAnywhere.stopVAD(): Promise<void>

RunAnywhere.setVADSpeechActivityCallback(
  callback: (event: SpeechActivityEvent) => void
): void

await RunAnywhere.initializeVoiceAgent(
  config: VoiceAgentConfig
): Promise<boolean>

interface VoiceAgentConfig {
  /** LLM model ID */
  llmModelId: string;

  /** STT model ID */
  sttModelId: string;

  /** TTS model ID */
  ttsModelId: string;

  /** System prompt for LLM */
  systemPrompt?: string;

  /** Generation options */
  generationOptions?: GenerationOptions;
}

await RunAnywhere.processVoiceTurn(
  audioData: string
): Promise<VoiceTurnResult>

interface VoiceTurnResult {
  /** Transcribed user speech */
  userTranscript: string;

  /** LLM response text */
  assistantResponse: string;

  /** Synthesized audio (base64) */
  audio: string;

  /** Performance metrics */
  metrics: VoiceAgentMetrics;
}

await RunAnywhere.startVoiceSession(
  config: VoiceSessionConfig,
  callback: (event: VoiceSessionEvent) => void
): Promise<VoiceSessionHandle>

await RunAnywhere.getAvailableModels(): Promise<ModelInfo[]>

const models = await RunAnywhere.getAvailableModels();
const llmModels = models.filter(m => m.category === ModelCategory.Language);
const downloadedModels = models.filter(m => m.isDownloaded);

await RunAnywhere.getModelInfo(modelId: string): Promise<ModelInfo | null>

await RunAnywhere.getDownloadedModels(): Promise<string[]>

await RunAnywhere.isModelDownloaded(modelId: string): Promise<boolean>

await RunAnywhere.downloadModel(
  modelId: string,
  onProgress?: (progress: DownloadProgress) => void
): Promise<void>

interface DownloadProgress {
  /** Model ID */
  modelId: string;

  /** Progress (0.0 - 1.0) */
  progress: number;

  /** Bytes downloaded */
  bytesDownloaded: number;

  /** Total bytes */
  bytesTotal: number;

  /** Download state */
  state: DownloadState;
}

enum DownloadState {
  Queued = 'queued',
  Downloading = 'downloading',
  Extracting = 'extracting',
  Completed = 'completed',
  Failed = 'failed',
  Cancelled = 'cancelled',
}

await RunAnywhere.downloadModel('smollm2-360m-q8_0', (progress) => {
  const percent = (progress.progress * 100).toFixed(1);
  console.log(`Downloading: ${percent}%`);

  if (progress.state === DownloadState.Extracting) {
    console.log('Extracting archive...');
  }
});

await RunAnywhere.cancelDownload(modelId: string): Promise<void>

await RunAnywhere.deleteModel(modelId: string): Promise<void>

await RunAnywhere.getStorageInfo(): Promise<StorageInfo>

interface StorageInfo {
  /** Total storage available (bytes) */
  totalSpace: number;

  /** Storage used by SDK (bytes) */
  usedSpace: number;

  /** Free space available (bytes) */
  freeSpace: number;

  /** Models storage path */
  modelsPath: string;
}

await RunAnywhere.clearCache(): Promise<void>

await RunAnywhere.cleanTempFiles(): Promise<boolean>

import { EventBus } from '@runanywhere/core';

// Or via RunAnywhere
RunAnywhere.events

// Subscribe to all events
const unsubscribe = EventBus.on(
  category: EventCategory,
  callback: (event: SDKEvent) => void
): () => void

// Shorthand methods
EventBus.onInitialization(callback)
EventBus.onGeneration(callback)
EventBus.onModel(callback)
EventBus.onVoice(callback)
EventBus.onStorage(callback)
EventBus.onError(callback)

// Initialization Events
interface SDKInitializationEvent {
  type: 'started' | 'completed' | 'failed';
  error?: string;
}

// Generation Events
interface SDKGenerationEvent {
  type: 'started' | 'tokenGenerated' | 'completed' | 'failed' | 'cancelled';
  token?: string;
  response?: GenerationResult;
  error?: string;
}

// Model Events
interface SDKModelEvent {
  type: 'downloadStarted' | 'downloadProgress' | 'downloadCompleted' |
        'downloadFailed' | 'loadStarted' | 'loadCompleted' | 'unloaded';
  modelId: string;
  progress?: number;
  error?: string;
}

// Voice Events
interface SDKVoiceEvent {
  type: 'sttStarted' | 'sttCompleted' | 'ttsStarted' | 'ttsCompleted' |
        'vadSpeechStarted' | 'vadSpeechEnded';
  result?: STTResult | TTSResult;
}

// Subscribe to generation events
const unsubscribe = RunAnywhere.events.onGeneration((event) => {
  switch (event.type) {
    case 'started':
      console.log('Generation started');
      break;
    case 'tokenGenerated':
      process.stdout.write(event.token);
      break;
    case 'completed':
      console.log('\nDone!', event.response.tokensUsed, 'tokens');
      break;
    case 'failed':
      console.error('Error:', event.error);
      break;
  }
});

// Later: unsubscribe
unsubscribe();

import { LlamaCPP, LlamaCppProvider } from '@runanywhere/llamacpp';

LlamaCPP.register(): void

// Register after SDK initialization
await RunAnywhere.initialize({ ... });
LlamaCPP.register();

await LlamaCPP.addModel(options: LlamaCPPModelOptions): Promise<ModelInfo>

interface LlamaCPPModelOptions {
  /** Unique model ID. If not provided, generated from URL filename */
  id?: string;

  /** Display name for the model */
  name: string;

  /** Download URL for the model */
  url: string;

  /** Model category (defaults to Language) */
  modality?: ModelCategory;

  /** Memory requirement in bytes */
  memoryRequirement?: number;

  /** Whether model supports reasoning/thinking tokens */
  supportsThinking?: boolean;
}

await LlamaCPP.addModel({
  id: 'smollm2-360m-q8_0',
  name: 'SmolLM2 360M Q8_0',
  url: 'https://huggingface.co/prithivMLmods/SmolLM2-360M-GGUF/resolve/main/SmolLM2-360M.Q8_0.gguf',
  memoryRequirement: 500_000_000,
});

// Model with thinking support
await LlamaCPP.addModel({
  id: 'qwen2.5-0.5b-instruct',
  name: 'Qwen 2.5 0.5B Instruct',
  url: 'https://huggingface.co/.../qwen2.5-0.5b-instruct-q6_k.gguf',
  memoryRequirement: 600_000_000,
  supportsThinking: true,
});

LlamaCppProvider.register(): void

import { ONNX, ONNXProvider, ModelArtifactType } from '@runanywhere/onnx';

ONNX.register(): void

await ONNX.addModel(options: ONNXModelOptions): Promise<ModelInfo>

interface ONNXModelOptions {
  /** Unique model ID. If not provided, generated from URL filename */
  id?: string;

  /** Display name for the model */
  name: string;

  /** Download URL for the model */
  url: string;

  /** Model category (SpeechRecognition or SpeechSynthesis) */
  modality: ModelCategory;

  /** How the model is packaged */
  artifactType?: ModelArtifactType;

  /** Memory requirement in bytes */
  memoryRequirement?: number;
}

enum ModelArtifactType {
  SingleFile = 'singleFile',
  TarGzArchive = 'tarGzArchive',
  TarBz2Archive = 'tarBz2Archive',
  ZipArchive = 'zipArchive',
}

// STT Model
await ONNX.addModel({
  id: 'sherpa-onnx-whisper-tiny.en',
  name: 'Sherpa Whisper Tiny (English)',
  url: 'https://github.com/RunanywhereAI/sherpa-onnx/releases/.../sherpa-onnx-whisper-tiny.en.tar.gz',
  modality: ModelCategory.SpeechRecognition,
  artifactType: ModelArtifactType.TarGzArchive,
  memoryRequirement: 75_000_000,
});

// TTS Model
await ONNX.addModel({
  id: 'vits-piper-en_US-lessac-medium',
  name: 'Piper TTS (US English)',
  url: 'https://github.com/RunanywhereAI/sherpa-onnx/releases/.../vits-piper-en_US-lessac-medium.tar.gz',
  modality: ModelCategory.SpeechSynthesis,
  artifactType: ModelArtifactType.TarGzArchive,
  memoryRequirement: 65_000_000,
});

enum SDKEnvironment {
  Development = 'development',
  Staging = 'staging',
  Production = 'production',
}

enum ExecutionTarget {
  OnDevice = 'onDevice',
  Cloud = 'cloud',
  Hybrid = 'hybrid',
}

enum LLMFramework {
  CoreML = 'CoreML',
  TensorFlowLite = 'TFLite',
  MLX = 'MLX',
  ONNX = 'ONNX',
  LlamaCpp = 'LlamaCpp',
  FoundationModels = 'FoundationModels',
  WhisperKit = 'WhisperKit',
  SystemTTS = 'SystemTTS',
  PiperTTS = 'PiperTTS',
}

enum ModelCategory {
  Language = 'language',
  SpeechRecognition = 'speech-recognition',
  SpeechSynthesis = 'speech-synthesis',
  Vision = 'vision',
  ImageGeneration = 'image-generation',
  Multimodal = 'multimodal',
  Audio = 'audio',
}

enum ModelFormat {
  GGUF = 'gguf',
  GGML = 'ggml',
  ONNX = 'onnx',
  MLModel = 'mlmodel',
  SafeTensors = 'safetensors',
}

enum HardwareAcceleration {
  CPU = 'cpu',
  GPU = 'gpu',
  NeuralEngine = 'neuralEngine',
  NPU = 'npu',
}

enum ComponentState {
  NotInitialized = 'notInitialized',
  Initializing = 'initializing',
  Ready = 'ready',
  Error = 'error',
  CleaningUp = 'cleaningUp',
}

interface ModelInfo {
  id: string;
  name: string;
  category: ModelCategory;
  format: ModelFormat;
  downloadURL?: string;
  localPath?: string;
  downloadSize?: number;
  memoryRequired?: number;
  compatibleFrameworks: LLMFramework[];
  preferredFramework?: LLMFramework;
  supportsThinking: boolean;
  isDownloaded: boolean;
  isAvailable: boolean;
}

interface GenerationResult {
  text: string;
  thinkingContent?: string;
  tokensUsed: number;
  modelUsed: string;
  latencyMs: number;
  executionTarget: ExecutionTarget;
  framework?: LLMFramework;
  hardwareUsed: HardwareAcceleration;
  memoryUsed: number;
  performanceMetrics: PerformanceMetrics;
  responseTokens: number;
}

interface STTResult {
  text: string;
  segments: STTSegment[];
  language?: string;
  confidence: number;
  duration: number;
  alternatives: STTAlternative[];
}

interface TTSResult {
  audio: string;
  sampleRate: number;
  numSamples: number;
  duration: number;
}

import { SDKError, SDKErrorCode, isSDKError, ErrorCategory } from '@runanywhere/core';

interface SDKError extends Error {
  code: SDKErrorCode;
  category: ErrorCategory;
  underlyingError?: Error;
  recoverySuggestion?: string;
}

function isSDKError(error: unknown): error is SDKError

// Create common errors
import {
  notInitializedError,
  modelNotFoundError,
  modelLoadError,
  generationError,
  networkError,
} from '@runanywhere/core';

// Example
throw notInitializedError();
throw modelNotFoundError('model-id');
throw generationError('Generation timed out');