diffio 0.1.0

package/dist/Client.js

@@ -0,0 +1,689 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffioClient = void 0;
+const BaseClient_1 = require("./BaseClient");
+const headers_1 = require("./core/headers");
+const supplier_1 = require("./core/supplier");
+const url_1 = require("./core/url");
+const retry_1 = require("./core/retry");
+const errors_1 = require("./errors");
+const serialization_1 = require("./api/serialization");
+const resources_1 = require("./api/resources");
+const mime_types_1 = require("mime-types");
+const DEFAULT_BASE_URL = "https://us-central1-diffioai.cloudfunctions.net";
+const API_PREFIX = "v1";
+const MODEL_ENDPOINTS = {
+    "diffio-2": "diffio-2.0-generation",
+    "diffio-2-flash": "diffio-2.0-flash-generation",
+    "diffio-3": "diffio-3.0-generation"
+};
+const DEFAULT_RETRY_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+const DEFAULT_RETRY_BACKOFF = 0.5;
+const DEFAULT_TIMEOUT_SECONDS = 60;
+const WEBHOOK_EVENT_TYPES = [
+    "generation.queued",
+    "generation.processing",
+    "generation.failed",
+    "generation.completed"
+];
+const WEBHOOK_MODES = ["test", "live"];
+class DiffioClient {
+    constructor(options = {}) {
+        const envApiKey = typeof process !== "undefined" ? process.env.DIFFIO_API_KEY : undefined;
+        const apiKey = options.apiKey ?? envApiKey;
+        if (apiKey == null) {
+            throw new errors_1.DiffioApiError("apiKey is required");
+        }
+        this._options = (0, BaseClient_1.normalizeClientOptions)({ ...options, apiKey });
+        this.audioIsolation = new resources_1.AudioIsolationClient(this);
+        this.generations = new resources_1.GenerationsClient(this);
+        this.projects = new resources_1.ProjectsClient(this);
+        this.webhooks = new resources_1.WebhooksClient(this);
+    }
+    close() {
+        return;
+    }
+    async createProject(options) {
+        const { filePath, contentType, contentLength, params, fileFormat, requestOptions } = options;
+        if (!filePath) {
+            throw new errors_1.DiffioApiError("filePath is required");
+        }
+        const resolvedFileName = getBaseName(filePath);
+        const resolvedContentType = contentType ?? guessContentType(filePath) ?? "application/octet-stream";
+        let resolvedContentLength = contentLength;
+        if (resolvedContentLength == null && filePath) {
+            resolvedContentLength = getFileSize(filePath);
+        }
+        const payload = {
+            fileName: resolvedFileName,
+            contentType: resolvedContentType
+        };
+        if (resolvedContentLength != null) {
+            payload.contentLength = Number(resolvedContentLength);
+        }
+        if (params) {
+            payload.params = params;
+        }
+        if (fileFormat != null) {
+            payload.fileFormat = fileFormat;
+        }
+        const response = await this._requestJson("POST", "create_project", payload, requestOptions);
+        const project = (0, serialization_1.parseCreateProjectResponse)(response);
+        await this._uploadFile({
+            uploadUrl: project.uploadUrl,
+            uploadMethod: project.uploadMethod,
+            filePath,
+            contentType: resolvedContentType,
+            requestOptions
+        });
+        return project;
+    }
+    async _uploadFile(options) {
+        const { uploadUrl, uploadMethod, filePath, data, contentType, requestOptions } = options;
+        if ((filePath == null) === (data == null)) {
+            throw new errors_1.DiffioApiError("Provide filePath or data");
+        }
+        let resolvedContentType = contentType;
+        if (!resolvedContentType && filePath) {
+            const guessed = (0, mime_types_1.lookup)(filePath);
+            resolvedContentType = typeof guessed === "string" ? guessed : undefined;
+        }
+        if (!resolvedContentType) {
+            resolvedContentType = "application/octet-stream";
+        }
+        const method = (uploadMethod || "PUT").toUpperCase();
+        const extraHeaders = {
+            "Content-Type": resolvedContentType
+        };
+        if (isStorageEmulatorUrl(uploadUrl)) {
+            extraHeaders.Authorization = "Bearer owner";
+        }
+        const body = filePath ? await createFileReadStream(filePath) : data;
+        await this._requestBinary(method, uploadUrl, body, requestOptions, extraHeaders, true);
+    }
+    async createGeneration(options) {
+        const { apiProjectId, model = "diffio-2", sampling, params, requestOptions } = options;
+        const endpoint = MODEL_ENDPOINTS[model];
+        if (!endpoint) {
+            throw new errors_1.DiffioApiError(`Unsupported model: ${model}`);
+        }
+        const payload = { apiProjectId };
+        if (sampling != null) {
+            payload.sampling = sampling;
+        }
+        if (params) {
+            payload.params = params;
+        }
+        const response = await this._requestJson("POST", endpoint, payload, requestOptions);
+        return (0, serialization_1.parseCreateGenerationResponse)(response);
+    }
+    async listProjects(options = {}) {
+        const response = await this._requestJson("POST", "list_projects", {}, options.requestOptions);
+        return (0, serialization_1.parseListProjectsResponse)(response);
+    }
+    async listProjectGenerations(options) {
+        const { apiProjectId, requestOptions } = options;
+        if (!apiProjectId) {
+            throw new errors_1.DiffioApiError("apiProjectId is required");
+        }
+        const response = await this._requestJson("POST", "list_project_generations", { apiProjectId }, requestOptions);
+        return (0, serialization_1.parseListProjectGenerationsResponse)(response);
+    }
+    async getGenerationProgress(options) {
+        const { generationId, apiProjectId, requestOptions } = options;
+        const payload = { generationId };
+        if (apiProjectId != null) {
+            payload.apiProjectId = apiProjectId;
+        }
+        const response = await this._requestJson("POST", "get_generation_progress", payload, requestOptions);
+        return (0, serialization_1.parseGenerationProgressResponse)(response);
+    }
+    async waitForGeneration(options) {
+        const { generationId, apiProjectId, pollInterval = 2, timeout, timeoutInSeconds, onProgress, showProgress, requestOptions } = options;
+        const timeoutSeconds = timeoutInSeconds ?? timeout ?? DEFAULT_TIMEOUT_SECONDS;
+        const deadline = Date.now() + timeoutSeconds * 1000;
+        let lastProgress = null;
+        while (Date.now() < deadline) {
+            const progress = await this.getGenerationProgress({ generationId, apiProjectId, requestOptions });
+            lastProgress = progress;
+            await reportProgress(progress, onProgress, showProgress);
+            if (progress.status === "complete") {
+                return progress;
+            }
+            if (progress.status === "failed") {
+                throw new errors_1.DiffioApiError("Generation failed" +
+                    ` (preProcessing=${progress.preProcessing.status},` +
+                    ` inference=${progress.inference.status},` +
+                    ` error=${progress.error},` +
+                    ` details=${progress.errorDetails})`);
+            }
+            await sleepSeconds(pollInterval);
+        }
+        throw new errors_1.DiffioApiError("Timed out waiting for generation completion" +
+            ` (lastStatus=${lastProgress ? lastProgress.status : "unknown"})`);
+    }
+    async getGenerationDownload(options) {
+        const { generationId, apiProjectId, downloadType, requestOptions } = options;
+        const payload = { generationId, apiProjectId };
+        if (downloadType != null) {
+            if (downloadType !== "audio" && downloadType !== "video") {
+                throw new errors_1.DiffioApiError("downloadType must be audio or video");
+            }
+            payload.downloadType = downloadType;
+        }
+        const response = await this._requestJson("POST", "get_generation_download", payload, requestOptions);
+        return (0, serialization_1.parseGenerationDownloadResponse)(response);
+    }
+    async getWebhooksPortalAccess(options) {
+        const { mode, apiKeyId, requestOptions } = options;
+        if (!WEBHOOK_MODES.includes(mode)) {
+            throw new errors_1.DiffioApiError("mode must be test or live");
+        }
+        const payload = { mode };
+        if (apiKeyId != null) {
+            payload.apiKeyId = apiKeyId;
+        }
+        const response = await this._requestJson("POST", "webhooks/app_portal_access", payload, requestOptions);
+        return (0, serialization_1.parseWebhookPortalResponse)(response);
+    }
+    async sendWebhookTestEvent(options) {
+        const { eventType, mode, apiKeyId, samplePayload, requestOptions } = options;
+        if (!WEBHOOK_EVENT_TYPES.includes(eventType)) {
+            throw new errors_1.DiffioApiError("eventType is not supported");
+        }
+        if (!WEBHOOK_MODES.includes(mode)) {
+            throw new errors_1.DiffioApiError("mode must be test or live");
+        }
+        if (samplePayload != null && (typeof samplePayload !== "object" || Array.isArray(samplePayload))) {
+            throw new errors_1.DiffioApiError("samplePayload must be an object");
+        }
+        const payload = { eventType, mode };
+        if (apiKeyId != null) {
+            payload.apiKeyId = apiKeyId;
+        }
+        if (samplePayload != null) {
+            payload.samplePayload = samplePayload;
+        }
+        const response = await this._requestJson("POST", "webhooks/send_test_event", payload, requestOptions);
+        return (0, serialization_1.parseWebhookTestEventResponse)(response);
+    }
+    async restoreAudio(options) {
+        const metadata = initRestoreMetadata();
+        metadata.downloadType = options.downloadType ?? "audio";
+        const resolvedProgressOptions = options.progressRequestOptions ?? options.requestOptions;
+        const resolvedDownloadOptions = options.downloadRequestOptions ?? options.requestOptions;
+        let result = null;
+        try {
+            result = await this.audioIsolationIsolate({
+                filePath: options.filePath,
+                contentType: options.contentType,
+                contentLength: options.contentLength,
+                fileFormat: options.fileFormat,
+                model: options.model,
+                sampling: options.sampling,
+                projectParams: options.projectParams,
+                generationParams: options.generationParams,
+                requestOptions: options.requestOptions
+            });
+        }
+        catch (error) {
+            metadata.stage = "isolate";
+            setRestoreError(metadata, error);
+            if (options.raiseOnError) {
+                attachRestoreMetadata(error, metadata);
+                throw error;
+            }
+            return [null, metadata];
+        }
+        metadata.project = result.project;
+        metadata.generation = result.generation;
+        metadata.apiProjectId = result.project.apiProjectId;
+        metadata.generationId = result.generation.generationId;
+        metadata.stage = "generation";
+        let progress = null;
+        try {
+            progress = await this.waitForGeneration({
+                generationId: result.generation.generationId,
+                apiProjectId: result.project.apiProjectId,
+                pollInterval: options.pollInterval,
+                timeout: options.timeout,
+                timeoutInSeconds: options.timeoutInSeconds,
+                onProgress: options.onProgress,
+                showProgress: options.showProgress,
+                requestOptions: resolvedProgressOptions
+            });
+        }
+        catch (error) {
+            metadata.stage = "progress";
+            try {
+                progress = await this.getGenerationProgress({
+                    generationId: result.generation.generationId,
+                    apiProjectId: result.project.apiProjectId,
+                    requestOptions: resolvedProgressOptions
+                });
+            }
+            catch {
+                progress = null;
+            }
+            metadata.progress = progress;
+            metadata.status = progress?.status ?? null;
+            setRestoreError(metadata, error);
+            if (progress) {
+                metadata.error = progress.error ?? String(error);
+                metadata.errorDetails = progress.errorDetails ?? null;
+            }
+            if (options.raiseOnError) {
+                attachRestoreMetadata(error, metadata);
+                throw error;
+            }
+            return [null, metadata];
+        }
+        metadata.progress = progress;
+        metadata.status = progress.status;
+        metadata.error = progress.error ?? null;
+        metadata.errorDetails = progress.errorDetails ?? null;
+        metadata.stage = "download_info";
+        let download;
+        try {
+            download = await this.getGenerationDownload({
+                generationId: result.generation.generationId,
+                apiProjectId: result.project.apiProjectId,
+                downloadType: options.downloadType ?? "audio",
+                requestOptions: resolvedDownloadOptions
+            });
+        }
+        catch (error) {
+            setRestoreError(metadata, error);
+            if (options.raiseOnError) {
+                attachRestoreMetadata(error, metadata);
+                throw error;
+            }
+            return [null, metadata];
+        }
+        metadata.download = download;
+        metadata.downloadType = download.downloadType;
+        metadata.downloadUrl = download.downloadUrl;
+        metadata.fileName = download.fileName;
+        metadata.mimeType = download.mimeType;
+        metadata.stage = "download";
+        let content;
+        try {
+            content = await this._downloadBinary(download.downloadUrl, resolvedDownloadOptions);
+        }
+        catch (error) {
+            setRestoreError(metadata, error);
+            if (options.raiseOnError) {
+                attachRestoreMetadata(error, metadata);
+                throw error;
+            }
+            return [null, metadata];
+        }
+        metadata.stage = "complete";
+        metadata.ok = true;
+        return [content, metadata];
+    }
+    async restore(options) {
+        return this.restoreAudio(options);
+    }
+    async audioIsolationIsolate(options) {
+        const project = await this.createProject({
+            filePath: options.filePath,
+            contentType: options.contentType,
+            contentLength: options.contentLength,
+            params: options.projectParams,
+            fileFormat: options.fileFormat,
+            requestOptions: options.requestOptions
+        });
+        const generation = await this.createGeneration({
+            apiProjectId: project.apiProjectId,
+            model: options.model,
+            sampling: options.sampling,
+            params: options.generationParams,
+            requestOptions: options.requestOptions
+        });
+        return (0, serialization_1.createAudioIsolationResult)(project, generation);
+    }
+    async _downloadBinary(downloadUrl, requestOptions) {
+        const extraHeaders = {};
+        if (isStorageEmulatorUrl(downloadUrl)) {
+            extraHeaders.Authorization = "Bearer owner";
+        }
+        const response = await this._requestBinary("GET", downloadUrl, undefined, requestOptions, extraHeaders, true);
+        return response;
+    }
+    async _requestJson(method, path, payload, requestOptions) {
+        const { url, headers, timeoutMs, maxRetries, retryBackoff, retryStatusCodes, fetchFn, abortSignal } = await this._buildRequest(method, path, requestOptions, {
+            "Content-Type": "application/json"
+        });
+        const requestBody = JSON.stringify(payload);
+        const makeRequest = () => fetchWithTimeout(fetchFn, url, {
+            method,
+            headers,
+            body: requestBody
+        }, timeoutMs, abortSignal);
+        const response = await (0, retry_1.requestWithRetries)(makeRequest, { maxRetries, retryBackoff, retryStatusCodes });
+        return parseJsonResponse(response);
+    }
+    async _requestBinary(method, urlOrPath, body, requestOptions, extraHeaders, isAbsoluteUrl = false) {
+        const { url, headers, timeoutMs, maxRetries, retryBackoff, retryStatusCodes, fetchFn, abortSignal } = await this._buildRequest(method, urlOrPath, requestOptions, extraHeaders, isAbsoluteUrl);
+        const requestInit = {
+            method,
+            headers,
+            body: body,
+            signal: abortSignal
+        };
+        if (body && isNodeReadable(body)) {
+            requestInit.duplex = "half";
+        }
+        const makeRequest = () => fetchWithTimeout(fetchFn, url, requestInit, timeoutMs, abortSignal);
+        const response = await (0, retry_1.requestWithRetries)(makeRequest, { maxRetries, retryBackoff, retryStatusCodes });
+        if (method === "GET") {
+            return parseBinaryResponse(response);
+        }
+        await parseJsonResponse(response);
+    }
+    async _buildRequest(method, path, requestOptions, extraHeaders, isAbsoluteUrl = false) {
+        const { baseUrl, apiPrefix } = await resolveBaseUrl(this._options.baseUrl);
+        const apiKey = requestOptions?.apiKey ?? (await supplier_1.Supplier.get(this._options.apiKey));
+        if (!apiKey && !isAbsoluteUrl) {
+            throw new errors_1.DiffioApiError("apiKey is required");
+        }
+        const baseHeaders = isAbsoluteUrl ? undefined : this._options.headers;
+        const authHeaders = !isAbsoluteUrl && apiKey ? (0, headers_1.mergeOnlyDefinedHeaders)({ Authorization: `Bearer ${apiKey}` }) : undefined;
+        const mergedHeaders = (0, headers_1.mergeHeaders)(baseHeaders, authHeaders, requestOptions?.headers, extraHeaders);
+        const headers = await (0, headers_1.resolveHeaders)(mergedHeaders);
+        const timeoutSeconds = requestOptions?.timeoutInSeconds ??
+            requestOptions?.timeout ??
+            this._options.timeoutInSeconds ??
+            this._options.timeout ??
+            DEFAULT_TIMEOUT_SECONDS;
+        const timeoutMs = timeoutSeconds != null ? timeoutSeconds * 1000 : undefined;
+        const maxRetries = requestOptions?.maxRetries ?? this._options.maxRetries ?? 0;
+        const retryBackoff = requestOptions?.retryBackoff ?? this._options.retryBackoff ?? DEFAULT_RETRY_BACKOFF;
+        const retryStatusCodes = requestOptions?.retryStatusCodes ?? this._options.retryStatusCodes ?? DEFAULT_RETRY_STATUS_CODES;
+        const fetchFn = this._options.fetch ?? globalThis.fetch;
+        if (!fetchFn) {
+            throw new errors_1.DiffioApiError("fetch is not available in this runtime");
+        }
+        const requestPath = path.replace(/^\/+/, "");
+        const url = isAbsoluteUrl
+            ? path
+            : (0, url_1.join)(baseUrl, apiPrefix ? `${apiPrefix}/${requestPath}` : requestPath);
+        return {
+            url,
+            headers,
+            timeoutMs,
+            maxRetries,
+            retryBackoff,
+            retryStatusCodes,
+            fetchFn,
+            abortSignal: requestOptions?.abortSignal
+        };
+    }
+}
+exports.DiffioClient = DiffioClient;
+function isAbortError(error) {
+    return typeof error === "object" && error != null && error.name === "AbortError";
+}
+function createAbortSignal(timeoutMs, externalSignal) {
+    if (!timeoutMs && !externalSignal) {
+        return { cleanup: () => undefined, didTimeout: () => false };
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    let timeoutId = null;
+    const abortListener = () => controller.abort();
+    if (externalSignal) {
+        if (externalSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            externalSignal.addEventListener("abort", abortListener, { once: true });
+        }
+    }
+    if (timeoutMs != null) {
+        timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+    }
+    const cleanup = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        if (externalSignal) {
+            externalSignal.removeEventListener("abort", abortListener);
+        }
+    };
+    return { signal: controller.signal, cleanup, didTimeout: () => timedOut };
+}
+async function fetchWithTimeout(fetchFn, url, init, timeoutMs, externalSignal) {
+    const { signal, cleanup, didTimeout } = createAbortSignal(timeoutMs, externalSignal);
+    try {
+        return await fetchFn(url, { ...init, signal });
+    }
+    catch (error) {
+        if (isAbortError(error) && didTimeout()) {
+            throw new errors_1.DiffioTimeoutError("Request timed out");
+        }
+        throw error;
+    }
+    finally {
+        cleanup();
+    }
+}
+function parseJsonResponse(response) {
+    if (response.ok) {
+        const contentType = response.headers.get("Content-Type") || "";
+        if (contentType.includes("application/json")) {
+            return response.json();
+        }
+        if (response.status === 204) {
+            return Promise.resolve({});
+        }
+        return response.text().then((text) => {
+            if (!text) {
+                return {};
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return {};
+            }
+        });
+    }
+    return parseErrorResponse(response).then((errorBody) => {
+        const message = getErrorMessage(errorBody, response.status);
+        throw new errors_1.DiffioApiError(message, { statusCode: response.status, responseBody: errorBody });
+    });
+}
+async function parseBinaryResponse(response) {
+    if (response.ok) {
+        const buffer = await response.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+    const errorBody = await parseErrorResponse(response);
+    const message = getErrorMessage(errorBody, response.status);
+    throw new errors_1.DiffioApiError(message, { statusCode: response.status, responseBody: errorBody });
+}
+async function parseErrorResponse(response) {
+    const contentType = response.headers.get("Content-Type") || "";
+    if (contentType.includes("application/json")) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return null;
+        }
+    }
+    const text = await response.text();
+    return text || null;
+}
+function getErrorMessage(body, status) {
+    if (body && typeof body === "object" && "error" in body) {
+        const message = body.error;
+        if (message) {
+            return String(message);
+        }
+    }
+    return `Request failed with status ${status}`;
+}
+async function resolveBaseUrl(baseUrlSupplier) {
+    const envBase = typeof process !== "undefined" ? process.env.DIFFIO_API_BASE_URL : undefined;
+    const resolvedBase = (await supplier_1.Supplier.get(baseUrlSupplier)) ?? envBase ?? DEFAULT_BASE_URL;
+    const trimmed = resolvedBase.replace(/\/+$/, "");
+    const apiPrefix = trimmed.endsWith(`/${API_PREFIX}`) ? "" : API_PREFIX;
+    return { baseUrl: trimmed, apiPrefix };
+}
+function guessContentType(filePath) {
+    const guessed = (0, mime_types_1.lookup)(filePath);
+    if (typeof guessed === "string") {
+        return guessed;
+    }
+    return undefined;
+}
+function isStorageEmulatorUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const host = parsed.hostname.toLowerCase();
+        const port = parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+        if (["127.0.0.1", "localhost", "0.0.0.0", "::1"].includes(host)) {
+            if (!parsed.port || port === 9199) {
+                return true;
+            }
+        }
+        const envHost = typeof process !== "undefined"
+            ? process.env.STORAGE_EMULATOR_HOST || process.env.FIREBASE_STORAGE_EMULATOR_HOST
+            : undefined;
+        if (!envHost) {
+            return false;
+        }
+        const normalized = envHost.startsWith("http://") || envHost.startsWith("https://") ? envHost : `http://${envHost}`;
+        const emulatorParsed = new URL(normalized);
+        const emulatorHost = emulatorParsed.hostname.toLowerCase();
+        const emulatorPort = emulatorParsed.port
+            ? Number(emulatorParsed.port)
+            : emulatorParsed.protocol === "https:"
+                ? 443
+                : 80;
+        return host === emulatorHost && port === emulatorPort;
+    }
+    catch {
+        return false;
+    }
+}
+function isNodeReadable(value) {
+    return Boolean(value) && typeof value === "object" && typeof value.pipe === "function";
+}
+async function createFileReadStream(filePath) {
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs")));
+    return fs.createReadStream(filePath);
+}
+function getFileSize(filePath) {
+    const fs = require("node:fs");
+    return fs.statSync(filePath).size;
+}
+function getBaseName(filePath) {
+    const path = require("node:path");
+    return path.basename(filePath);
+}
+function initRestoreMetadata() {
+    return {
+        ok: false,
+        stage: "start",
+        apiProjectId: null,
+        generationId: null,
+        project: null,
+        generation: null,
+        progress: null,
+        download: null,
+        downloadType: null,
+        downloadUrl: null,
+        fileName: null,
+        mimeType: null,
+        status: null,
+        error: null,
+        errorDetails: null,
+        exceptionType: null,
+        exceptionMessage: null
+    };
+}
+function setRestoreError(metadata, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    metadata.error = message;
+    metadata.exceptionType = error instanceof Error ? error.name : typeof error;
+    metadata.exceptionMessage = message;
+}
+function attachRestoreMetadata(error, metadata) {
+    if (error && typeof error === "object") {
+        try {
+            error.restoreInfo = metadata;
+        }
+        catch {
+            return;
+        }
+    }
+}
+async function reportProgress(progress, onProgress, showProgress) {
+    if (onProgress) {
+        await onProgress(progress);
+    }
+    if (showProgress) {
+        // eslint-disable-next-line no-console
+        console.log(formatProgress(progress));
+    }
+}
+function formatProgress(progress) {
+    const parts = [];
+    if (progress.preProcessing) {
+        parts.push(`pre=${progress.preProcessing.status}:${progress.preProcessing.progress}%`);
+    }
+    if (progress.inference) {
+        parts.push(`inf=${progress.inference.status}:${progress.inference.progress}%`);
+    }
+    if (progress.restoredVideo) {
+        parts.push(`vid=${progress.restoredVideo.status}:${progress.restoredVideo.progress}%`);
+    }
+    const joined = parts.join(", ");
+    if (joined) {
+        return `${progress.status} (${joined})`;
+    }
+    return progress.status;
+}
+async function sleepSeconds(seconds) {
+    await new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+}

package/dist/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./resources";