diffio 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Diffio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,204 @@
+# Diffio JS SDK
+
+The Diffio JS SDK helps you call the Diffio API from Node. This version covers project creation, upload, generation, progress checks, and download URLs.
+
+## Install
+
+```bash
+npm install diffio
+```
+
+For local development:
+
+```bash
+cd diffio-js
+npm install
+```
+
+## Configuration
+
+Set the API key with `DIFFIO_API_KEY`. You can also override the base URL with `DIFFIO_API_BASE_URL`.
+
+```bash
+export DIFFIO_API_KEY="diffio_live_..."
+export DIFFIO_API_BASE_URL="https://us-central1-diffioai.cloudfunctions.net"
+```
+
+For emulators, set the base URL to the Functions emulator host.
+
+```bash
+export DIFFIO_API_BASE_URL="http://127.0.0.1:5001/diffioai/us-central1"
+```
+
+## Request options
+
+Use request options to override headers, timeouts, retries, or the API key per request.
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const projects = await client.listProjects({
+  requestOptions: {
+    headers: { "X-Debug": "1" },
+    timeoutInSeconds: 30,
+    maxRetries: 2,
+    retryBackoff: 0.5
+  }
+});
+```
+
+## Create a project and generation
+
+`createProject` uploads the file and returns the project metadata.
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const filePath = "sample.wav";
+
+const project = await client.createProject({
+  filePath
+});
+
+const generation = await client.createGeneration({
+  apiProjectId: project.apiProjectId,
+  model: "diffio-2",
+  sampling: { steps: 12, guidance: 1.5 }
+});
+
+console.log(generation.generationId);
+```
+
+## Audio isolation helper
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const result = await client.audioIsolation.isolate({
+  filePath: "sample.wav",
+  model: "diffio-2",
+  sampling: { steps: 12, guidance: 1.5 }
+});
+
+console.log(result.generation.generationId);
+```
+
+## Restore audio in one call
+
+This helper runs the full flow and returns the downloaded bytes plus a metadata object.
+
+```ts
+import fs from "node:fs";
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const [audioBytes, info] = await client.restoreAudio({
+  filePath: "sample.wav",
+  model: "diffio-2",
+  sampling: { steps: 12, guidance: 1.5 },
+  onProgress: (progress) => console.log(progress.status)
+});
+
+if (info.error) {
+  console.log(info.error);
+} else if (audioBytes) {
+  fs.writeFileSync("restored.mp3", Buffer.from(audioBytes));
+}
+
+console.log(info.apiProjectId, info.generationId);
+```
+
+## Generation progress
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const progress = await client.generations.getProgress({
+  generationId: "gen_123",
+  apiProjectId: "proj_123"
+});
+
+console.log(progress.status);
+```
+
+## Generation download
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const download = await client.generations.getDownload({
+  generationId: "gen_123",
+  apiProjectId: "proj_123",
+  downloadType: "audio"
+});
+
+console.log(download.downloadUrl);
+```
+
+## List projects
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const projects = await client.projects.list();
+
+for (const project of projects.projects) {
+  console.log(project.apiProjectId, project.status);
+}
+```
+
+## List project generations
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const generations = await client.projects.listGenerations({ apiProjectId: "proj_123" });
+
+for (const generation of generations.generations) {
+  console.log(generation.generationId, generation.status);
+}
+```
+
+## Webhooks portal access
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const portal = await client.webhooks.getPortalAccess({ mode: "test" });
+console.log(portal.portalUrl);
+```
+
+## Send a test webhook event
+
+```ts
+import { DiffioClient } from "diffio";
+
+const client = new DiffioClient({ apiKey: "diffio_live_..." });
+const event = await client.webhooks.sendTestEvent({
+  eventType: "generation.completed",
+  mode: "test",
+  samplePayload: { apiProjectId: "proj_123" }
+});
+
+console.log(event.svixMessageId);
+```
+
+## Runtime compatibility
+
+Use Node 18 or later so `fetch` is available without extra packages.
+Examples use ES modules. Save files with a `.mjs` extension or set `"type": "module"` in your package.json.
+
+## Tests
+
+```bash
+cd diffio-js
+npm run build
+```

package/dist/BaseClient.d.ts

@@ -0,0 +1,26 @@
+import type { Supplier } from "./core/supplier";
+export interface BaseClientOptions {
+    baseUrl?: Supplier<string>;
+    apiKey?: Supplier<string | undefined>;
+    headers?: Record<string, string | Supplier<string | null | undefined> | null | undefined>;
+    timeoutInSeconds?: number;
+    timeout?: number;
+    maxRetries?: number;
+    retryBackoff?: number;
+    retryStatusCodes?: number[];
+    fetch?: typeof fetch;
+}
+export interface BaseRequestOptions {
+    timeoutInSeconds?: number;
+    timeout?: number;
+    maxRetries?: number;
+    retryBackoff?: number;
+    retryStatusCodes?: number[];
+    abortSignal?: AbortSignal;
+    apiKey?: string | undefined;
+    headers?: Record<string, string | Supplier<string | null | undefined> | null | undefined>;
+}
+export type NormalizedClientOptions<T extends BaseClientOptions> = T & {
+    headers: Record<string, string | Supplier<string | null | undefined> | null | undefined>;
+};
+export declare function normalizeClientOptions<T extends BaseClientOptions>(options: T): NormalizedClientOptions<T>;

package/dist/BaseClient.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeClientOptions = normalizeClientOptions;
+const version_1 = require("./version");
+const headers_1 = require("./core/headers");
+function normalizeClientOptions(options) {
+    const headers = (0, headers_1.mergeHeaders)({
+        "X-Diffio-SDK-Language": "JavaScript",
+        "X-Diffio-SDK-Name": "diffio",
+        "X-Diffio-SDK-Version": version_1.DIFFIO_SDK_VERSION,
+        "User-Agent": `diffio/${version_1.DIFFIO_SDK_VERSION}`
+    }, options?.headers);
+    return {
+        ...options,
+        headers
+    };
+}

package/dist/Client.d.ts

@@ -0,0 +1,109 @@
+import type { BaseClientOptions, BaseRequestOptions, NormalizedClientOptions } from "./BaseClient";
+import type { AudioIsolationResult, CreateGenerationResponse, CreateProjectResponse, GenerationDownloadResponse, GenerationProgressResponse, ListProjectGenerationsResponse, ListProjectsResponse, RestoreMetadata, WebhookPortalResponse, WebhookTestEventResponse } from "./api/types";
+import { AudioIsolationClient, GenerationsClient, ProjectsClient, WebhooksClient } from "./api/resources";
+export declare namespace DiffioClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+export declare class DiffioClient {
+    protected readonly _options: NormalizedClientOptions<DiffioClient.Options>;
+    readonly audioIsolation: AudioIsolationClient;
+    readonly generations: GenerationsClient;
+    readonly projects: ProjectsClient;
+    readonly webhooks: WebhooksClient;
+    constructor(options?: DiffioClient.Options);
+    close(): void;
+    createProject(options: {
+        filePath: string;
+        contentType?: string;
+        contentLength?: number;
+        params?: Record<string, unknown>;
+        fileFormat?: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<CreateProjectResponse>;
+    private _uploadFile;
+    createGeneration(options: {
+        apiProjectId: string;
+        model?: string;
+        sampling?: Record<string, unknown>;
+        params?: Record<string, unknown>;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<CreateGenerationResponse>;
+    listProjects(options?: {
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<ListProjectsResponse>;
+    listProjectGenerations(options: {
+        apiProjectId: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<ListProjectGenerationsResponse>;
+    getGenerationProgress(options: {
+        generationId: string;
+        apiProjectId?: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<GenerationProgressResponse>;
+    waitForGeneration(options: {
+        generationId: string;
+        apiProjectId?: string;
+        pollInterval?: number;
+        timeout?: number;
+        timeoutInSeconds?: number;
+        onProgress?: (progress: GenerationProgressResponse) => void | Promise<void>;
+        showProgress?: boolean;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<GenerationProgressResponse>;
+    getGenerationDownload(options: {
+        generationId: string;
+        apiProjectId: string;
+        downloadType?: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<GenerationDownloadResponse>;
+    getWebhooksPortalAccess(options: {
+        mode: string;
+        apiKeyId?: string;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<WebhookPortalResponse>;
+    sendWebhookTestEvent(options: {
+        eventType: string;
+        mode: string;
+        apiKeyId?: string;
+        samplePayload?: Record<string, unknown>;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<WebhookTestEventResponse>;
+    restoreAudio(options: {
+        filePath: string;
+        contentType?: string;
+        contentLength?: number;
+        fileFormat?: string;
+        model?: string;
+        sampling?: Record<string, unknown>;
+        projectParams?: Record<string, unknown>;
+        generationParams?: Record<string, unknown>;
+        downloadType?: string;
+        pollInterval?: number;
+        timeout?: number;
+        timeoutInSeconds?: number;
+        onProgress?: (progress: GenerationProgressResponse) => void | Promise<void>;
+        showProgress?: boolean;
+        requestOptions?: DiffioClient.RequestOptions;
+        progressRequestOptions?: DiffioClient.RequestOptions;
+        downloadRequestOptions?: DiffioClient.RequestOptions;
+        raiseOnError?: boolean;
+    }): Promise<[Uint8Array | null, RestoreMetadata]>;
+    restore(options: Parameters<DiffioClient["restoreAudio"]>[0]): Promise<[Uint8Array | null, RestoreMetadata]>;
+    audioIsolationIsolate(options: {
+        filePath: string;
+        contentType?: string;
+        contentLength?: number;
+        fileFormat?: string;
+        model?: string;
+        sampling?: Record<string, unknown>;
+        projectParams?: Record<string, unknown>;
+        generationParams?: Record<string, unknown>;
+        requestOptions?: DiffioClient.RequestOptions;
+    }): Promise<AudioIsolationResult>;
+    private _downloadBinary;
+    private _requestJson;
+    private _requestBinary;
+    private _buildRequest;
+}