Revoize SDK TypeScript API Reference

This page documents the TypeScript/JavaScript API for the Revoize SDK. You initialize with a model config, then use processAudio and the helpers below.

Installation

The TypeScript SDK consists of a core package and model-specific packages. For installation instructions, contact Revoize using the contact form.

The core package provides initialization, processing, and lifecycle helpers. Model-specific packages provide a WASM module and a ModelConfig (with asset URLs and metadata) that you pass to initialize().

Types

ModelConfig Interface

interface ModelConfig {
  name: string;
  packageName: string;
  modelType: number;
  sessionType: 'single' | 'multi';
  description: string;
  version: string;
  jsAssetUrl: string;
  wasmAssetUrl: string;
}

Configuration for a model: metadata and asset URLs. Usually imported from a model-specific package (e.g. @revoize/model-capella).

ModelInfo Interface

interface ModelInfo {
  name: string;
  packageName: string;
  modelType: number;
  sessionType: string;
  description: string;
  version: string;
}

Information about the currently initialized model (subset of ModelConfig without asset URLs).

ModelParams Interface

interface ModelParams {
  modelType: number;
  inputChunkSizeSamples: number;
  outputChunkSizeSamples: number;
  inputSampleRate: number;
  outputSampleRate: number;
}

Chunk sizes and sample rates for the current model. Obtained from getCurrentModelParams() after initialization.

SDKError Class

class SDKError extends Error {
  constructor(public code: string, message: string);
}

Error type for SDK failures (e.g. init failure, no model initialized).

Functions

initialize Function

Signature

function initialize(config: ModelConfig): Promise<void>

Initializes the SDK with the given model configuration. Call before any other SDK functions. Typically use a config from a model-specific package.

Parameters

• config – A ModelConfig object (e.g. from @revoize/model-capella).

Returns

• Promise<void> – Resolves when initialization is complete.

Throws

• SDKError – If initialization fails (e.g. WASM loading or model loading).

Example

import { initialize } from "@revoize/sdk";
import { config as capellaConfig } from "@revoize/model-capella";

await initialize(capellaConfig);

processAudio Function

Signature

function processAudio(audioData: number[]): number[]

Processes one chunk of input audio and returns the enhanced audio.

WARNING

• Call initialize() before using this function.
• Chunk length and sample rate must match the initialized model (see getCurrentModelParams()). Input must be an array of numbers (float32 values), typically at the model’s input sample rate (e.g. 48 kHz).

Parameters

• audioData – Array of numbers (float32) representing single-channel audio samples.

Returns

• number[] – Enhanced audio samples.

Throws

• SDKError – If no model is initialized or processing fails (e.g. NO_MODEL_INITIALIZED, BUFFER_ALLOCATION_FAILED, AUDIO_PROCESSING_FAILED).

Example

import { initialize, processAudio, getCurrentModelParams } from "@revoize/sdk";
import { config as capellaConfig } from "@revoize/model-capella";

await initialize(capellaConfig);

const params = getCurrentModelParams();
const chunkSize = params?.inputChunkSizeSamples ?? 480;
const audioData = new Array(chunkSize).fill(0.1);
const enhanced = processAudio(audioData);
console.log("Enhanced audio has", enhanced.length, "samples");

isModelInitialized Function

Signature

function isModelInitialized(): boolean

Returns whether a model is currently initialized and ready for processing.

Returns

• boolean – true if a model is initialized, false otherwise.

getCurrentModelInfo Function

Signature

function getCurrentModelInfo(): ModelInfo | null

Returns information about the currently initialized model (name, description, version, etc.). Returns null if no model is initialized.

Returns

• ModelInfo | null

getCurrentModelName Function

Signature

function getCurrentModelName(): string | null

Returns the name of the currently initialized model. Returns null if no model is initialized.

Returns

• string | null

getCurrentModelParams Function

Signature

function getCurrentModelParams(): ModelParams | null

Returns chunk sizes and sample rates for the currently initialized model. Use this to size buffers and respect input/output sample rates. Returns null if no model is initialized.

Returns

• ModelParams | null – inputChunkSizeSamples, outputChunkSizeSamples, inputSampleRate, outputSampleRate, modelType.

Example

import { getCurrentModelParams, processAudio } from "@revoize/sdk";

const params = getCurrentModelParams();
if (params) {
  const input = new Array(params.inputChunkSizeSamples).fill(0);
  const output = processAudio(input);
  console.log("Output samples:", output.length); // params.outputChunkSizeSamples
}

cleanup Function

Signature

function cleanup(): void

Releases resources and resets SDK state. Call when done using the SDK (e.g. when switching models or tearing down).

Example

import { cleanup } from "@revoize/sdk";

cleanup();

Complete Example

import {
  initialize,
  processAudio,
  isModelInitialized,
  getCurrentModelInfo,
  getCurrentModelParams,
  cleanup,
} from "@revoize/sdk";
import { config as capellaConfig } from "@revoize/model-capella";

async function processAudioFile(audioData: number[]) {
  try {
    await initialize(capellaConfig);

    if (!isModelInitialized()) {
      throw new Error("Failed to initialize model");
    }

    const modelInfo = getCurrentModelInfo();
    const params = getCurrentModelParams();
    console.log("Using model:", modelInfo?.name);
    if (params) {
      console.log("Chunk size:", params.inputChunkSizeSamples);
    }

    const chunkSize = params?.inputChunkSizeSamples ?? 480;
    const processedChunks: number[][] = [];

    for (let i = 0; i < audioData.length; i += chunkSize) {
      const chunk = audioData.slice(i, i + chunkSize);
      const outputChunk = processAudio(chunk);
      processedChunks.push(outputChunk);
    }

    const enhancedAudio = processedChunks.flat();
    console.log(
      "Processing complete. Enhanced audio length:",
      enhancedAudio.length,
    );

    return enhancedAudio;
  } catch (error) {
    console.error("Error processing audio:", error);
    throw error;
  } finally {
    cleanup();
  }
}