@liqhtworks/sophon-sdk 0.1.0

package/dist/helpers/uploads.js

@@ -0,0 +1,149 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFile = uploadFile;
+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/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/helpers/webhooks.js

@@ -0,0 +1,89 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookSignatureError = void 0;
+exports.verifyWebhookSignature = verifyWebhookSignature;
+class WebhookSignatureError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message ?? reason);
+        this.name = "WebhookSignatureError";
+        this.reason = reason;
+    }
+}
+exports.WebhookSignatureError = WebhookSignatureError;
+/**
+ * Throws `WebhookSignatureError` if the delivery is not authentic. Returns
+ * a resolved promise on success.
+ */
+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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+/* eslint-disable */
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./apis/index"), exports);
+__exportStar(require("./models/index"), exports);
+__exportStar(require("./helpers/index"), exports);

package/dist/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;

package/dist/models/CompleteUploadResponse.js

@@ -0,0 +1,71 @@
+"use strict";
+/* 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompleteUploadResponseStatusEnum = void 0;
+exports.instanceOfCompleteUploadResponse = instanceOfCompleteUploadResponse;
+exports.CompleteUploadResponseFromJSON = CompleteUploadResponseFromJSON;
+exports.CompleteUploadResponseFromJSONTyped = CompleteUploadResponseFromJSONTyped;
+exports.CompleteUploadResponseToJSON = CompleteUploadResponseToJSON;
+exports.CompleteUploadResponseToJSONTyped = CompleteUploadResponseToJSONTyped;
+/**
+* @export
+* @enum {string}
+*/
+var CompleteUploadResponseStatusEnum;
+(function (CompleteUploadResponseStatusEnum) {
+    CompleteUploadResponseStatusEnum["COMPLETED"] = "completed";
+})(CompleteUploadResponseStatusEnum || (exports.CompleteUploadResponseStatusEnum = CompleteUploadResponseStatusEnum = {}));
+/**
+ * Check if a given object implements the CompleteUploadResponse interface.
+ */
+function instanceOfCompleteUploadResponse(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('status' in value) || value['status'] === undefined)
+        return false;
+    if (!('sha256' in value) || value['sha256'] === undefined)
+        return false;
+    if (!('bytes' in value) || value['bytes'] === undefined)
+        return false;
+    return true;
+}
+function CompleteUploadResponseFromJSON(json) {
+    return CompleteUploadResponseFromJSONTyped(json, false);
+}
+function CompleteUploadResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'status': json['status'],
+        'sha256': json['sha256'],
+        'bytes': json['bytes'],
+    };
+}
+function CompleteUploadResponseToJSON(json) {
+    return CompleteUploadResponseToJSONTyped(json, false);
+}
+function CompleteUploadResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'status': value['status'],
+        'sha256': value['sha256'],
+        'bytes': value['bytes'],
+    };
+}

package/dist/models/CreateJobOutputOptions.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 type { OutputContainer } from './OutputContainer';
+/**
+ * Optional output shaping knobs for a new job.
+ * @export
+ * @interface CreateJobOutputOptions
+ */
+export interface CreateJobOutputOptions {
+    /**
+     *
+     * @type {OutputContainer}
+     * @memberof CreateJobOutputOptions
+     */
+    container?: OutputContainer;
+    /**
+     * When true, audio is included in the output. MKV preserves
+     * source audio streams unchanged. MP4 preserves broadly compatible
+     * source audio codecs when possible, and may normalize
+     * incompatible codecs to AAC for playback compatibility.
+     * When false, the output is video only.
+     *
+     * @type {boolean}
+     * @memberof CreateJobOutputOptions
+     */
+    audio?: boolean;
+    /**
+     * Target output height in pixels. When set, output is scaled down
+     * (aspect ratio preserved, width derived from source, both dims
+     * rounded to even). If absent or larger than source height, output
+     * uses source dimensions. Billing tier is determined by the actual
+     * encoded output, not by this requested value.
+     *
+     * @type {number}
+     * @memberof CreateJobOutputOptions
+     */
+    target_height?: number;
+}
+/**
+ * Check if a given object implements the CreateJobOutputOptions interface.
+ */
+export declare function instanceOfCreateJobOutputOptions(value: object): value is CreateJobOutputOptions;
+export declare function CreateJobOutputOptionsFromJSON(json: any): CreateJobOutputOptions;
+export declare function CreateJobOutputOptionsFromJSONTyped(json: any, ignoreDiscriminator: boolean): CreateJobOutputOptions;
+export declare function CreateJobOutputOptionsToJSON(json: any): CreateJobOutputOptions;
+export declare function CreateJobOutputOptionsToJSONTyped(value?: CreateJobOutputOptions | null, ignoreDiscriminator?: boolean): any;

package/dist/models/CreateJobOutputOptions.js

@@ -0,0 +1,53 @@
+"use strict";
+/* 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfCreateJobOutputOptions = instanceOfCreateJobOutputOptions;
+exports.CreateJobOutputOptionsFromJSON = CreateJobOutputOptionsFromJSON;
+exports.CreateJobOutputOptionsFromJSONTyped = CreateJobOutputOptionsFromJSONTyped;
+exports.CreateJobOutputOptionsToJSON = CreateJobOutputOptionsToJSON;
+exports.CreateJobOutputOptionsToJSONTyped = CreateJobOutputOptionsToJSONTyped;
+const OutputContainer_1 = require("./OutputContainer");
+/**
+ * Check if a given object implements the CreateJobOutputOptions interface.
+ */
+function instanceOfCreateJobOutputOptions(value) {
+    return true;
+}
+function CreateJobOutputOptionsFromJSON(json) {
+    return CreateJobOutputOptionsFromJSONTyped(json, false);
+}
+function CreateJobOutputOptionsFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'container': json['container'] == null ? undefined : (0, OutputContainer_1.OutputContainerFromJSON)(json['container']),
+        'audio': json['audio'] == null ? undefined : json['audio'],
+        'target_height': json['target_height'] == null ? undefined : json['target_height'],
+    };
+}
+function CreateJobOutputOptionsToJSON(json) {
+    return CreateJobOutputOptionsToJSONTyped(json, false);
+}
+function CreateJobOutputOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'container': (0, OutputContainer_1.OutputContainerToJSON)(value['container']),
+        'audio': value['audio'],
+        'target_height': value['target_height'],
+    };
+}

package/dist/models/CreateJobRequest.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 type { CreateJobOutputOptions } from './CreateJobOutputOptions';
+import type { JobProfile } from './JobProfile';
+import type { UploadJobSource } from './UploadJobSource';
+/**
+ *
+ * @export
+ * @interface CreateJobRequest
+ */
+export interface CreateJobRequest {
+    /**
+     *
+     * @type {UploadJobSource}
+     * @memberof CreateJobRequest
+     */
+    source: UploadJobSource;
+    /**
+     *
+     * @type {JobProfile}
+     * @memberof CreateJobRequest
+     */
+    profile: JobProfile;
+    /**
+     *
+     * @type {CreateJobOutputOptions}
+     * @memberof CreateJobRequest
+     */
+    output?: CreateJobOutputOptions;
+    /**
+     * IDs of registered webhook endpoints to notify on job state changes.
+     * @type {Array<string>}
+     * @memberof CreateJobRequest
+     */
+    webhook_ids?: Array<string>;
+    /**
+     * Arbitrary key-value metadata attached to the job. Max 16 KiB serialized.
+     * @type {{ [key: string]: any; }}
+     * @memberof CreateJobRequest
+     */
+    metadata?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Check if a given object implements the CreateJobRequest interface.
+ */
+export declare function instanceOfCreateJobRequest(value: object): value is CreateJobRequest;
+export declare function CreateJobRequestFromJSON(json: any): CreateJobRequest;
+export declare function CreateJobRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): CreateJobRequest;
+export declare function CreateJobRequestToJSON(json: any): CreateJobRequest;
+export declare function CreateJobRequestToJSONTyped(value?: CreateJobRequest | null, ignoreDiscriminator?: boolean): any;

package/dist/models/CreateJobRequest.js

@@ -0,0 +1,63 @@
+"use strict";
+/* 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfCreateJobRequest = instanceOfCreateJobRequest;
+exports.CreateJobRequestFromJSON = CreateJobRequestFromJSON;
+exports.CreateJobRequestFromJSONTyped = CreateJobRequestFromJSONTyped;
+exports.CreateJobRequestToJSON = CreateJobRequestToJSON;
+exports.CreateJobRequestToJSONTyped = CreateJobRequestToJSONTyped;
+const CreateJobOutputOptions_1 = require("./CreateJobOutputOptions");
+const JobProfile_1 = require("./JobProfile");
+const UploadJobSource_1 = require("./UploadJobSource");
+/**
+ * Check if a given object implements the CreateJobRequest interface.
+ */
+function instanceOfCreateJobRequest(value) {
+    if (!('source' in value) || value['source'] === undefined)
+        return false;
+    if (!('profile' in value) || value['profile'] === undefined)
+        return false;
+    return true;
+}
+function CreateJobRequestFromJSON(json) {
+    return CreateJobRequestFromJSONTyped(json, false);
+}
+function CreateJobRequestFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'source': (0, UploadJobSource_1.UploadJobSourceFromJSON)(json['source']),
+        'profile': (0, JobProfile_1.JobProfileFromJSON)(json['profile']),
+        'output': json['output'] == null ? undefined : (0, CreateJobOutputOptions_1.CreateJobOutputOptionsFromJSON)(json['output']),
+        'webhook_ids': json['webhook_ids'] == null ? undefined : json['webhook_ids'],
+        'metadata': json['metadata'] == null ? undefined : json['metadata'],
+    };
+}
+function CreateJobRequestToJSON(json) {
+    return CreateJobRequestToJSONTyped(json, false);
+}
+function CreateJobRequestToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'source': (0, UploadJobSource_1.UploadJobSourceToJSON)(value['source']),
+        'profile': (0, JobProfile_1.JobProfileToJSON)(value['profile']),
+        'output': (0, CreateJobOutputOptions_1.CreateJobOutputOptionsToJSON)(value['output']),
+        'webhook_ids': value['webhook_ids'],
+        'metadata': value['metadata'],
+    };
+}