@liqhtworks/sophon-sdk 0.1.0

package/dist/esm/apis/WebhooksApi.js

@@ -0,0 +1,148 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * SOPHON Encoding API
+ * REST API for submitting, monitoring, and retrieving SOPHON encoding jobs.  Authentication is via Bearer API key or session cookie. All POST endpoints require an Idempotency-Key header. List endpoints use opaque cursor-based pagination.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { CreateWebhookRequestToJSON, WebhookListResponseFromJSON, WebhookResponseFromJSON, } from '../models/index';
+/**
+ *
+ */
+export class WebhooksApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createWebhook without sending the request
+     */
+    async createWebhookRequestOpts(requestParameters) {
+        if (requestParameters['idempotencyKey'] == null) {
+            throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling createWebhook().');
+        }
+        if (requestParameters['createWebhookRequest'] == null) {
+            throw new runtime.RequiredError('createWebhookRequest', 'Required parameter "createWebhookRequest" was null or undefined when calling createWebhook().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerApiKey", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/v1/webhooks`;
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CreateWebhookRequestToJSON(requestParameters['createWebhookRequest']),
+        };
+    }
+    /**
+     * Registers an HTTPS endpoint for terminal job events and returns the HMAC signing secret once at creation time.
+     * Register a webhook endpoint
+     */
+    async createWebhookRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.createWebhookRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => WebhookResponseFromJSON(jsonValue));
+    }
+    /**
+     * Registers an HTTPS endpoint for terminal job events and returns the HMAC signing secret once at creation time.
+     * Register a webhook endpoint
+     */
+    async createWebhook(requestParameters, initOverrides) {
+        const response = await this.createWebhookRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Creates request options for deleteWebhook without sending the request
+     */
+    async deleteWebhookRequestOpts(requestParameters) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteWebhook().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerApiKey", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/v1/webhooks/{id}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Sets the webhook to inactive. It will no longer receive deliveries.
+     * Soft-delete a webhook endpoint
+     */
+    async deleteWebhookRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.deleteWebhookRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Sets the webhook to inactive. It will no longer receive deliveries.
+     * Soft-delete a webhook endpoint
+     */
+    async deleteWebhook(requestParameters, initOverrides) {
+        await this.deleteWebhookRaw(requestParameters, initOverrides);
+    }
+    /**
+     * Creates request options for listWebhooks without sending the request
+     */
+    async listWebhooksRequestOpts() {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerApiKey", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/v1/webhooks`;
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Lists active webhook endpoints for the authenticated organization.
+     * List active webhook endpoints
+     */
+    async listWebhooksRaw(initOverrides) {
+        const requestOptions = await this.listWebhooksRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => WebhookListResponseFromJSON(jsonValue));
+    }
+    /**
+     * Lists active webhook endpoints for the authenticated organization.
+     * List active webhook endpoints
+     */
+    async listWebhooks(initOverrides) {
+        const response = await this.listWebhooksRaw(initOverrides);
+        return await response.value();
+    }
+}

package/dist/esm/apis/index.d.ts

@@ -0,0 +1,5 @@
+export * from './DownloadsApi';
+export * from './HealthApi';
+export * from './JobsApi';
+export * from './UploadsApi';
+export * from './WebhooksApi';

package/dist/esm/apis/index.js

@@ -0,0 +1,7 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './DownloadsApi';
+export * from './HealthApi';
+export * from './JobsApi';
+export * from './UploadsApi';
+export * from './WebhooksApi';

package/dist/esm/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./uploads";
+export * from "./jobs";
+export * from "./webhooks";

package/dist/esm/helpers/index.js

@@ -0,0 +1,3 @@
+export * from "./uploads";
+export * from "./jobs";
+export * from "./webhooks";

package/dist/esm/helpers/jobs.d.ts

@@ -0,0 +1,48 @@
+export type JobTerminalStatus = "completed" | "failed" | "canceled";
+export type JobStatusLike = JobTerminalStatus | "queued" | "probing" | "encoding" | "muxing" | "uploading_output";
+export interface JobLike {
+    id: string;
+    status: JobStatusLike;
+    error?: string | null;
+}
+export interface JobsApiLike {
+    getJob(params: {
+        id: string;
+    }): Promise<JobLike>;
+}
+export interface WaitForJobParams<T extends JobLike = JobLike> {
+    api: {
+        getJob: (p: {
+            id: string;
+        }) => Promise<T>;
+    };
+    jobId: string;
+    /** Resolve only on these statuses. Default: the three terminal ones. */
+    until?: readonly JobStatusLike[];
+    /** Initial poll interval (ms). Default 1000. */
+    pollMinMs?: number;
+    /** Cap on poll interval (ms). Default 15000. */
+    pollMaxMs?: number;
+    /** Exponential backoff multiplier per poll. Default 1.5. */
+    pollBackoff?: number;
+    /** Abort and throw after this many ms. Default 3600000 (1h). */
+    timeoutMs?: number;
+    /** Called on every poll with the freshly fetched job. */
+    onProgress?: (job: T) => void;
+    signal?: AbortSignal;
+}
+export declare class JobTerminalError<T extends JobLike = JobLike> extends Error {
+    readonly job: T;
+    constructor(job: T);
+}
+export declare class JobTimeoutError extends Error {
+    readonly jobId: string;
+    constructor(jobId: string, waitedMs: number);
+}
+/**
+ * Polls `getJob` until the job hits a terminal status (or the requested
+ * `until` list), then returns the final job. Throws `JobTerminalError` on
+ * `failed` / `canceled` unless those are explicitly requested in `until`.
+ * Throws `JobTimeoutError` if the timeout elapses.
+ */
+export declare function waitForJob<T extends JobLike = JobLike>(params: WaitForJobParams<T>): Promise<T>;

package/dist/esm/helpers/jobs.js

@@ -0,0 +1,61 @@
+// Polling helper that resolves when a job hits a terminal state.
+export class JobTerminalError extends Error {
+    job;
+    constructor(job) {
+        super(job.error ?? `job ${job.id} ended in status ${job.status}`);
+        this.name = "JobTerminalError";
+        this.job = job;
+    }
+}
+export class JobTimeoutError extends Error {
+    jobId;
+    constructor(jobId, waitedMs) {
+        super(`job ${jobId} did not finish within ${waitedMs}ms`);
+        this.name = "JobTimeoutError";
+        this.jobId = jobId;
+    }
+}
+const DEFAULT_TERMINAL = ["completed", "failed", "canceled"];
+/**
+ * Polls `getJob` until the job hits a terminal status (or the requested
+ * `until` list), then returns the final job. Throws `JobTerminalError` on
+ * `failed` / `canceled` unless those are explicitly requested in `until`.
+ * Throws `JobTimeoutError` if the timeout elapses.
+ */
+export async function waitForJob(params) {
+    const { api, jobId, until = DEFAULT_TERMINAL, pollMinMs = 1000, pollMaxMs = 15000, pollBackoff = 1.5, timeoutMs = 60 * 60 * 1000, onProgress, signal, } = params;
+    const start = Date.now();
+    let interval = pollMinMs;
+    while (true) {
+        if (signal?.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        if (Date.now() - start > timeoutMs)
+            throw new JobTimeoutError(jobId, Date.now() - start);
+        const job = await api.getJob({ id: jobId });
+        onProgress?.(job);
+        if (until.some((s) => s === job.status)) {
+            // The caller opted into this status; only synthesize a JobTerminalError
+            // when they are waiting for the default-terminal set and we landed on a
+            // failed/canceled status.
+            if (until === DEFAULT_TERMINAL && (job.status === "failed" || job.status === "canceled")) {
+                throw new JobTerminalError(job);
+            }
+            return job;
+        }
+        await sleep(interval, signal);
+        interval = Math.min(Math.ceil(interval * pollBackoff), pollMaxMs);
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/esm/helpers/uploads.d.ts

@@ -0,0 +1,71 @@
+export interface UploadsApiLike {
+    createUpload(params: {
+        createUploadRequest: {
+            file_name: string;
+            file_size: number;
+            mime_type: string;
+        };
+        idempotencyKey: string;
+    }): Promise<{
+        id: string;
+        chunk_size: number;
+        total_chunks: number;
+        expires_at: string;
+    }>;
+    uploadPart(params: {
+        id: string;
+        partNumber: number;
+        body: Blob;
+    }): Promise<{
+        part_number: number;
+        received: boolean;
+    }>;
+    completeUpload(params: {
+        id: string;
+        idempotencyKey: string;
+    }): Promise<{
+        id: string;
+        status: string;
+        sha256: string;
+        bytes: number;
+    }>;
+    getUpload(params: {
+        id: string;
+    }): Promise<{
+        id: string;
+        status: string;
+        total_chunks: number;
+        received_chunks: number[];
+    }>;
+}
+export interface UploadProgress {
+    bytesUploaded: number;
+    bytesTotal: number;
+    partsDone: number;
+    partsTotal: number;
+}
+export interface UploadFileParams {
+    api: UploadsApiLike;
+    source: Blob;
+    fileName: string;
+    mimeType: string;
+    /** Resume a prior session instead of creating a new one. */
+    uploadId?: string;
+    /** Parallel in-flight chunks. Default 4. */
+    concurrency?: number;
+    /** Retries per chunk before aborting. Default 3. */
+    retries?: number;
+    /** Base backoff in ms; doubles each attempt. Default 500. */
+    retryBaseMs?: number;
+    /** Idempotency key reused for createUpload + completeUpload. Auto-generated if omitted. */
+    idempotencyKey?: string;
+    onProgress?: (p: UploadProgress) => void;
+    /** Abort the whole upload. Chunks in flight will still settle. */
+    signal?: AbortSignal;
+}
+export interface UploadFileResult {
+    uploadId: string;
+    sha256: string;
+    bytes: number;
+}
+export declare function uploadFile(params: UploadFileParams): Promise<UploadFileResult>;

package/dist/esm/helpers/uploads.js

@@ -0,0 +1,146 @@
+// Upload orchestration on top of the generated UploadsApi.
+//
+// The generated SDK exposes createUpload / uploadPart / completeUpload as
+// separate calls; this wrapper handles chunk slicing, bounded concurrency,
+// per-part retry, resume against existing sessions, and progress reporting.
+export async function uploadFile(params) {
+    const { api, source, fileName, mimeType, uploadId: resumeId, concurrency = 4, retries = 3, retryBaseMs = 500, idempotencyKey = randomIdempotencyKey(), onProgress, signal, } = params;
+    if (concurrency < 1)
+        throw new RangeError("concurrency must be >= 1");
+    if (retries < 0)
+        throw new RangeError("retries must be >= 0");
+    let uploadId;
+    let chunkSize;
+    let totalChunks;
+    let alreadyReceived = new Set();
+    if (resumeId) {
+        const status = await api.getUpload({ id: resumeId });
+        uploadId = status.id;
+        totalChunks = status.total_chunks;
+        alreadyReceived = new Set(status.received_chunks);
+        // Derive chunk size from file size / totalChunks. Last chunk may be smaller;
+        // we only need the head size to slice, so use ceil.
+        chunkSize = Math.ceil(source.size / totalChunks);
+    }
+    else {
+        const session = await api.createUpload({
+            createUploadRequest: {
+                file_name: fileName,
+                file_size: source.size,
+                mime_type: mimeType,
+            },
+            idempotencyKey,
+        });
+        uploadId = session.id;
+        chunkSize = session.chunk_size;
+        totalChunks = session.total_chunks;
+    }
+    const progress = {
+        bytesUploaded: 0,
+        bytesTotal: source.size,
+        partsDone: 0,
+        partsTotal: totalChunks,
+    };
+    // Seed progress from any resumed parts so callers see accurate counts.
+    for (const part of alreadyReceived) {
+        progress.partsDone += 1;
+        progress.bytesUploaded += partBytes(source.size, chunkSize, totalChunks, part);
+    }
+    onProgress?.({ ...progress });
+    const pending = [];
+    for (let i = 0; i < totalChunks; i++) {
+        if (!alreadyReceived.has(i))
+            pending.push(i);
+    }
+    let nextIdx = 0;
+    const workers = [];
+    for (let w = 0; w < Math.min(concurrency, pending.length); w++) {
+        workers.push((async () => {
+            while (true) {
+                if (signal?.aborted)
+                    throw new DOMException("Aborted", "AbortError");
+                const idx = nextIdx++;
+                if (idx >= pending.length)
+                    return;
+                const partNumber = pending[idx];
+                const start = partNumber * chunkSize;
+                const end = Math.min(start + chunkSize, source.size);
+                const chunk = source.slice(start, end, "application/octet-stream");
+                await withRetry(() => api.uploadPart({ id: uploadId, partNumber, body: chunk }), retries, retryBaseMs, signal);
+                progress.partsDone += 1;
+                progress.bytesUploaded += chunk.size;
+                onProgress?.({ ...progress });
+            }
+        })());
+    }
+    await Promise.all(workers);
+    const done = await api.completeUpload({ id: uploadId, idempotencyKey });
+    return { uploadId: done.id, sha256: done.sha256, bytes: done.bytes };
+}
+function partBytes(total, chunkSize, totalChunks, part) {
+    if (part < totalChunks - 1)
+        return chunkSize;
+    return total - chunkSize * (totalChunks - 1);
+}
+async function withRetry(fn, retries, baseMs, signal) {
+    let attempt = 0;
+    // One initial try + `retries` follow-ups.
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (signal?.aborted)
+                throw err;
+            if (attempt >= retries || !isRetryable(err))
+                throw err;
+            const delay = baseMs * 2 ** attempt + Math.floor(Math.random() * baseMs);
+            await sleep(delay, signal);
+            attempt += 1;
+        }
+    }
+}
+function isRetryable(err) {
+    if (err instanceof TypeError)
+        return true; // network-level fetch errors
+    const maybeResponse = err.response;
+    const status = maybeResponse?.status;
+    if (typeof status !== "number")
+        return false;
+    return status === 408 || status === 429 || (status >= 500 && status < 600);
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function randomIdempotencyKey() {
+    // Single capture of the global `crypto` object so the TS narrowing from
+    // one `in` check doesn't bleed into the next branch.
+    const c = typeof crypto !== "undefined"
+        ? crypto
+        : undefined;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    // Fallback for very old runtimes without crypto.randomUUID. Web Crypto's
+    // getRandomValues has been in Node since 15 and all evergreen browsers, so
+    // this almost never runs — but we avoid Math.random so idempotency keys
+    // stay uncorrelated across callers even on ancient targets.
+    if (c?.getRandomValues) {
+        const bytes = new Uint8Array(16);
+        c.getRandomValues(bytes);
+        let hex = "";
+        for (const b of bytes)
+            hex += b.toString(16).padStart(2, "0");
+        return `idem_${hex}`;
+    }
+    throw new Error("crypto API unavailable; pass an explicit idempotencyKey to uploadFile");
+}

package/dist/esm/helpers/webhooks.d.ts

@@ -0,0 +1,23 @@
+export interface VerifyWebhookSignatureParams {
+    /** Raw HTTP body exactly as received, before any JSON parsing. */
+    rawBody: string | Uint8Array;
+    /** Value of `X-Turbo-Signature-256`, e.g. `"sha256=abc..."`. */
+    signatureHeader: string | null | undefined;
+    /** Value of `X-Turbo-Timestamp`. */
+    timestampHeader: string | null | undefined;
+    /** Webhook secret returned by `POST /v1/webhooks`. */
+    secret: string;
+    /** Maximum acceptable clock skew in ms. Default 5 min. Set 0 to disable. */
+    replayWindowMs?: number;
+    /** Override "now" for deterministic tests. */
+    now?: () => number;
+}
+export declare class WebhookSignatureError extends Error {
+    readonly reason: "missing_signature" | "missing_timestamp" | "invalid_timestamp" | "replay_window_exceeded" | "bad_prefix" | "bad_signature_encoding" | "signature_mismatch";
+    constructor(reason: WebhookSignatureError["reason"], message?: string);
+}
+/**
+ * Throws `WebhookSignatureError` if the delivery is not authentic. Returns
+ * a resolved promise on success.
+ */
+export declare function verifyWebhookSignature(params: VerifyWebhookSignatureParams): Promise<void>;

package/dist/esm/helpers/webhooks.js

@@ -0,0 +1,84 @@
+// Webhook signature verification for inbound terminal-job deliveries.
+//
+// SOPHON signs each delivery with HMAC-SHA256 over `"{timestamp}.{raw_body}"`
+// using the per-webhook secret. The hex digest is sent as
+// `X-Turbo-Signature-256: sha256=<hex>`.
+//
+// Isomorphic: uses the Web Crypto API (`crypto.subtle`), available globally in
+// Node 18+ and modern browsers. No Node-specific imports.
+//
+// Consumers call `verifyWebhookSignature` with the RAW request body (string or
+// Uint8Array — NOT a parsed JSON object), the signature header, the timestamp
+// header, and the webhook secret. The helper does a constant-time comparison
+// and enforces a replay window by default.
+export class WebhookSignatureError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message ?? reason);
+        this.name = "WebhookSignatureError";
+        this.reason = reason;
+    }
+}
+/**
+ * Throws `WebhookSignatureError` if the delivery is not authentic. Returns
+ * a resolved promise on success.
+ */
+export async function verifyWebhookSignature(params) {
+    const { rawBody, signatureHeader, timestampHeader, secret, replayWindowMs = 5 * 60 * 1000, now = Date.now, } = params;
+    if (!signatureHeader)
+        throw new WebhookSignatureError("missing_signature");
+    if (!timestampHeader)
+        throw new WebhookSignatureError("missing_timestamp");
+    const deliveredTs = Date.parse(timestampHeader);
+    if (Number.isNaN(deliveredTs)) {
+        throw new WebhookSignatureError("invalid_timestamp");
+    }
+    if (replayWindowMs > 0) {
+        const drift = Math.abs(now() - deliveredTs);
+        if (drift > replayWindowMs) {
+            throw new WebhookSignatureError("replay_window_exceeded");
+        }
+    }
+    if (!signatureHeader.startsWith("sha256=")) {
+        throw new WebhookSignatureError("bad_prefix");
+    }
+    const deliveredHex = signatureHeader.slice("sha256=".length).trim();
+    const delivered = hexToBytes(deliveredHex);
+    if (!delivered) {
+        throw new WebhookSignatureError("bad_signature_encoding");
+    }
+    const bodyBytes = typeof rawBody === "string" ? new TextEncoder().encode(rawBody) : rawBody;
+    const payload = concatBytes(new TextEncoder().encode(`${timestampHeader}.`), bodyBytes);
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const expected = new Uint8Array(
+    // TS 5.7+ tightened BufferSource to require ArrayBufferView<ArrayBuffer>;
+    // our concatenated Uint8Array is backed by an ArrayBuffer at runtime.
+    await crypto.subtle.sign("HMAC", key, payload));
+    if (!constantTimeEqual(delivered, expected)) {
+        throw new WebhookSignatureError("signature_mismatch");
+    }
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex))
+        return null;
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return out;
+}
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+function constantTimeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < a.length; i++) {
+        diff |= (a[i] ?? 0) ^ (b[i] ?? 0);
+    }
+    return diff === 0;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './runtime';
+export * from './apis/index';
+export * from './models/index';
+export * from './helpers/index';

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './runtime';
+export * from './apis/index';
+export * from './models/index';
+export * from './helpers/index';

package/dist/esm/models/CompleteUploadResponse.d.ts

@@ -0,0 +1,57 @@
+/**
+ * SOPHON Encoding API
+ * REST API for submitting, monitoring, and retrieving SOPHON encoding jobs.  Authentication is via Bearer API key or session cookie. All POST endpoints require an Idempotency-Key header. List endpoints use opaque cursor-based pagination.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface CompleteUploadResponse
+ */
+export interface CompleteUploadResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof CompleteUploadResponse
+     */
+    id: string;
+    /**
+     *
+     * @type {CompleteUploadResponseStatusEnum}
+     * @memberof CompleteUploadResponse
+     */
+    status: CompleteUploadResponseStatusEnum;
+    /**
+     * SHA-256 hex digest of the assembled file.
+     * @type {string}
+     * @memberof CompleteUploadResponse
+     */
+    sha256: string;
+    /**
+     *
+     * @type {number}
+     * @memberof CompleteUploadResponse
+     */
+    bytes: number;
+}
+/**
+* @export
+* @enum {string}
+*/
+export declare enum CompleteUploadResponseStatusEnum {
+    COMPLETED = "completed"
+}
+/**
+ * Check if a given object implements the CompleteUploadResponse interface.
+ */
+export declare function instanceOfCompleteUploadResponse(value: object): value is CompleteUploadResponse;
+export declare function CompleteUploadResponseFromJSON(json: any): CompleteUploadResponse;
+export declare function CompleteUploadResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): CompleteUploadResponse;
+export declare function CompleteUploadResponseToJSON(json: any): CompleteUploadResponse;
+export declare function CompleteUploadResponseToJSONTyped(value?: CompleteUploadResponse | null, ignoreDiscriminator?: boolean): any;