@hedra/sdk 5.0.0 → 5.2.0

package/README.md

@@ -3,15 +3,19 @@
 [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=Hedra%2FTypeScript)
 [![npm shield](https://img.shields.io/npm/v/@hedra/sdk)](https://www.npmjs.com/package/@hedra/sdk)
 
-The Hedra TypeScript library provides convenient access to the Hedra APIs from TypeScript.
+The Hedra TypeScript library provides convenient access to the Hedra API v3 from TypeScript and
+JavaScript.
 
 ## Table of Contents
 
 - [Installation](#installation)
 - [Reference](#reference)
 - [Usage](#usage)
+- [Authentication](#authentication)
 - [Custom base URL](#custom-base-url)
+- [Resources](#resources)
 - [Request and Response Types](#request-and-response-types)
+- [Streaming](#streaming)
 - [Pagination](#pagination)
 - [Exception Handling](#exception-handling)
 - [File Uploads](#file-uploads)
@@ -22,6 +26,7 @@ The Hedra TypeScript library provides convenient access to the Hedra APIs from T
   - [Timeouts](#timeouts)
   - [Aborting Requests](#aborting-requests)
   - [Access Raw Response Data](#access-raw-response-data)
+  - [Spec Version Header](#spec-version-header)
   - [Logging](#logging)
   - [Custom Fetch](#custom-fetch)
   - [Runtime Compatibility](#runtime-compatibility)
@@ -46,12 +51,12 @@ import { HedraClient } from "@hedra/sdk";
 
 const client = new HedraClient({ apiKey: "YOUR_API_KEY" });
 
-const submitted = await client.jobs.submitKlingO3({
+const submitted = await client.jobs.submitMinimaxH3({
     input: {
         prompt: "a fox sprinting across fresh snow",
         aspect_ratio: "16:9",
-        duration_ms: 5000,
-        quality: "standard",
+        resolution: "768p",
+        duration_ms: 6000,
     },
 });
 
@@ -63,24 +68,66 @@ while (status.status === "IN_QUEUE" || status.status === "IN_PROGRESS") {
 }
 
 const result = await client.jobs.get(submitted.job_id);
-console.log(result.outputs?.[0]?.url);
+for (const output of result.outputs ?? []) {
+    console.log(output.url);
+}
 ```
 
-Every model has its own submit method — `submitKlingO3`, `submitVeo3`, `submitNanoBanana`
-and so on — each taking the `input` that model actually accepts, checked at compile time.
-The [reference](./reference.md) lists all of them.
+Every model has its own submit method — `submitMinimaxH3`, `submitKlingO3`, `submitVeo3`,
+`submitNanoBanana` and so on — each taking the `input` that model actually accepts, checked at
+compile time. The [reference](./reference.md) lists all of them.
+
+To run a model by its public id instead, with an untyped `input` that the API validates at submit
+time, use `client.jobs.submit(model, { input })`. This is the call to reach for when the model is
+not known ahead of time, or when a client generated before a model shipped needs to run it:
+
+```typescript
+const submitted = await client.jobs.submit("minimax-h3", {
+    input: {
+        prompt: "a fox sprinting across fresh snow",
+        aspect_ratio: "16:9",
+        resolution: "768p",
+        duration_ms: 6000,
+    },
+});
+```
 
-Instead of polling you can consume the job's server-sent event stream with
-`client.jobs.stream(job_id)`.
+Every submit body also accepts two optional fields: `webhook`, a URL that receives a signed
+completion webhook, and `idempotency_key`, which replays the original acknowledgement for a
+retried submit instead of enqueueing a duplicate job.
+
+Instead of polling you can follow the job over server-sent events; see [Streaming](#streaming).
+
+## Authentication
 
 The client authenticates with `Authorization: Bearer <api key>`; an API key is the
-`<key_id>:<secret>` credential from the Hedra console. When `apiKey` is not passed,
-it is read from the `HEDRA_API_KEY` environment variable.
+`<key_id>:<secret>` credential from the Hedra console. The API key can also be provided via the
+`HEDRA_API_KEY` environment variable, in which case `apiKey` may be omitted:
+
+```typescript
+import { HedraClient } from "@hedra/sdk";
+
+// Reads HEDRA_API_KEY from the environment
+const client = new HedraClient();
+```
+
+Ephemeral tokens minted with `client.tokens.create(...)` are valid Bearer credentials until they
+expire; pass the returned `token` as `apiKey` to authenticate with one.
+To take over header construction entirely, pass `auth` — either `false` to send no credentials,
+or a function returning the headers to attach:
+
+```typescript
+import { HedraClient } from "@hedra/sdk";
+
+const client = new HedraClient({
+    auth: async () => ({ headers: { Authorization: `Bearer ${await fetchTokenSomehow()}` } }),
+});
+```
 
 ## Custom base URL
 
-The client targets `https://api.hedra.com/v3`. Pass a URL as `environment` to point
-elsewhere (e.g. a mock server in tests):
+The client targets `https://api.hedra.com/v3` (`HedraEnvironment.Production`). Pass a URL as
+`environment` to point elsewhere (e.g. a mock server in tests):
 
 ```typescript
 import { HedraClient } from "@hedra/sdk";
@@ -90,6 +137,32 @@ const client = new HedraClient({
 });
 ```
 
+## Resources
+
+The client exposes one sub-client per API resource:
+
+| Sub-client | What it covers |
+| --- | --- |
+| `client.jobs` | Submit generation jobs (typed per model, or by id), poll status, fetch results, tail logs, stream progress, list history. |
+| `client.models` | Browse the model catalog and each model's input schema, list voices, estimate cost, fetch the OpenAPI document. |
+| `client.files` | Upload media to reference from a submit. |
+| `client.keys` | List, create, rotate and revoke API keys. |
+| `client.tokens` | Mint ephemeral Bearer tokens that expire on a schedule, for clients that should not hold a long-lived key. |
+| `client.billing` | Balance, usage and transaction history. |
+| `client.webhooks` | Manage and test the account's default completion webhook, list and redeliver deliveries, fetch the signing public key. |
+| `client.logDrains` | Manage log drains that batch-forward job logs to an endpoint you own. |
+
+```typescript
+const catalog = await client.models.list({ modality: "video" });
+const detail = await client.models.get("minimax-h3");
+const balance = await client.billing.getBalance();
+```
+
+Each resource is also published as a package subpath — `@hedra/sdk/jobs`, `@hedra/sdk/models`,
+`@hedra/sdk/files`, `@hedra/sdk/keys`, `@hedra/sdk/tokens`, `@hedra/sdk/billing`,
+`@hedra/sdk/webhooks`, `@hedra/sdk/logDrains` — exporting that resource's client class and
+request types on their own.
+
 ## Request and Response Types
 
 The SDK exports all request and response types as TypeScript interfaces. Simply import them with the
@@ -98,15 +171,57 @@ following namespace:
 ```typescript
 import { Hedra } from "@hedra/sdk";
 
-const request: Hedra.SubmitBodyKlingO3 = {
-    ...
+const input: Hedra.InputMinimaxH3 = {
+    prompt: "a fox sprinting across fresh snow",
+    aspect_ratio: "16:9",
+    resolution: "768p",
+    duration_ms: 6000,
 };
+
+const request: Hedra.SubmitBodyMinimaxH3 = { input };
+```
+
+Enum-valued fields are exported as `as const` objects alongside their types, so
+`Hedra.InputMinimaxH3.Resolution.SevenHundredSixtyEightP` and the literal `"768p"` are
+interchangeable. Response envelopes are typed the same way: `Hedra.SubmitResponse`,
+`Hedra.StatusResponse`, `Hedra.ResultResponse`, `Hedra.OutputItem`, and `Hedra.JobStatus`
+(`"IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED"`).
+
+## Streaming
+
+`client.jobs.stream(job_id)` follows a job over server-sent events instead of polling. It resolves
+to an async iterable that yields a `StatusResponse` for every `status` frame and a `JobLogItem` for
+every `log` frame, and ends once the job reaches a terminal state:
+
+```typescript
+// submitted is the SubmitResponse returned by any submit call
+const stream = await client.jobs.stream(submitted.job_id);
+for await (const event of stream) {
+    if ("status" in event) {
+        console.log(event.status, event.progress);
+    } else {
+        console.log(event.level, event.message);
+    }
+}
+```
+
+A dropped connection is resumed automatically from the last event id. Tune that with the `stream`
+option, on the client or per request:
+
+```typescript
+const client = new HedraClient({
+    stream: { reconnectionEnabled: true, maxReconnectionAttempts: 5 },
+});
+
+const stream = await client.jobs.stream(submitted.job_id, {}, {
+    stream: { reconnectionEnabled: false },
+});
 ```
 
 ## Pagination
 
-`client.jobs.list(...)` returns a `Page` that can be iterated asynchronously; it
-fetches cursor pages lazily as you iterate:
+Paginated requests return a `Page` that can be iterated asynchronously; it fetches cursor pages
+lazily as you iterate:
 
 ```typescript
 const page = await client.jobs.list({ limit: 50 });
@@ -115,21 +230,43 @@ for await (const job of page) {
 }
 ```
 
+You can also iterate page by page and access the typed response for each one:
+
+```typescript
+let page = await client.jobs.list({ limit: 50 });
+while (true) {
+    console.log(page.response); // the typed JobListResponse for this page
+    for (const job of page.data) {
+        console.log(job.job_id);
+    }
+    if (!page.hasNextPage()) break;
+    page = await page.getNextPage();
+}
+```
+
 ## Exception Handling
 
-When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
-will be thrown.
+When the API returns a non-success status code (4xx or 5xx response), a subclass of `HedraError` is
+thrown. Each documented status has its own class under the `Hedra` namespace — `BadRequestError`,
+`UnauthorizedError`, `PaymentRequiredError`, `ForbiddenError`, `NotFoundError`,
+`UnprocessableEntityError`, `TooManyRequestsError` and `InternalServerError` — with a typed
+`body`. A request that exceeds its timeout throws `HedraTimeoutError`.
 
 ```typescript
-import { HedraError } from "@hedra/sdk";
+import { Hedra, HedraError, HedraTimeoutError } from "@hedra/sdk";
 
 try {
-    await client.jobs.submitKlingO3(...);
+    await client.jobs.get("job_does_not_exist");
 } catch (err) {
-    if (err instanceof HedraError) {
+    if (err instanceof Hedra.NotFoundError) {
+        console.log(err.body); // typed Hedra.ErrorResponse
+    } else if (err instanceof HedraTimeoutError) {
+        console.log("timed out", err.cause);
+    } else if (err instanceof HedraError) {
         console.log(err.statusCode);
         console.log(err.message);
         console.log(err.body);
+        console.log(err.requestId); // the response's x-request-id, if any
         console.log(err.rawResponse);
     }
 }
@@ -137,17 +274,33 @@ try {
 
 ## File Uploads
 
-You can upload files using the client:
+Media inputs (`start_image`, `end_image`, `images`, `audio`, `video`, …) take either a public URL or
+a file you uploaded first. `client.files.upload` stores the bytes and returns a presigned URL that is
+the file's handle for the next hour; pass it back verbatim as a `url` source:
 
 ```typescript
 import * as fs from "fs";
 import { HedraClient } from "@hedra/sdk";
 
 const client = new HedraClient({ apiKey: "YOUR_API_KEY" });
-await client.files.upload({
-    file: fs.createReadStream("/path/to/your/file"),
+
+const upload = await client.files.upload({
+    file: fs.createReadStream("frame.png"),
+});
+
+await client.jobs.submitMinimaxH3({
+    input: {
+        prompt: "the fox turns toward the camera",
+        resolution: "768p",
+        duration_ms: 6000,
+        start_image: { source: "url", url: upload.url },
+    },
 });
 ```
+
+A completed job's outputs carry an `asset_id`; pass `{ source: "asset", asset_id }` instead of a
+URL to reuse an output as the input to a later job.
+
 The client accepts a variety of types for file upload parameters:
 * Stream types: `fs.ReadStream`, `stream.Readable`, and `ReadableStream`
 * Buffered types: `Buffer`, `Blob`, `File`, `ArrayBuffer`, `ArrayBufferView`, and `Uint8Array`
@@ -199,7 +352,7 @@ const client = new HedraClient({
     }
 });
 
-const response = await client.jobs.submitKlingO3(..., {
+const response = await client.jobs.submitMinimaxH3(..., {
     headers: {
         'X-Custom-Header': 'custom value'
     }
@@ -211,7 +364,7 @@ const response = await client.jobs.submitKlingO3(..., {
 If you would like to send additional query string parameters as part of the request, use the `queryParams` request option.
 
 ```typescript
-const response = await client.jobs.submitKlingO3(..., {
+const response = await client.jobs.submitMinimaxH3(..., {
     queryParams: {
         'customQueryParamKey': 'custom query param value'
     }
@@ -222,26 +375,17 @@ const response = await client.jobs.submitKlingO3(..., {
 
 The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
 as the request is deemed retryable and the number of retry attempts has not grown larger than the configured
-retry limit (default: 2).
-
-Which status codes are retried depends on the `retryStatusCodes` generator configuration:
+retry limit (default: 2). A response is retryable when its status is:
 
-**`legacy`** (current default): retries on
 - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
 - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
 - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#server_error_responses) (All server errors, including 500)
 
-**`recommended`**: retries on
-- [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
-- [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
-- [502](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/502) (Bad Gateway)
-- [503](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503) (Service Unavailable)
-- [504](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504) (Gateway Timeout)
-
-Use the `maxRetries` request option to configure this behavior.
+A `Retry-After` header is honoured when the server sends one. Use the `maxRetries` option, on the
+client or per request, to configure this behavior.
 
 ```typescript
-const response = await client.jobs.submitKlingO3(..., {
+const response = await client.jobs.submitMinimaxH3(..., {
     maxRetries: 0 // override maxRetries at the request level
 });
 ```
@@ -251,7 +395,7 @@ const response = await client.jobs.submitKlingO3(..., {
 The SDK defaults to a 60 second timeout. Use the `timeoutInSeconds` option to configure this behavior.
 
 ```typescript
-const response = await client.jobs.submitKlingO3(..., {
+const response = await client.jobs.submitMinimaxH3(..., {
     timeoutInSeconds: 30 // override timeout to 30s
 });
 ```
@@ -262,7 +406,7 @@ The SDK allows users to abort requests at any point by passing in an abort signa
 
 ```typescript
 const controller = new AbortController();
-const response = await client.jobs.submitKlingO3(..., {
+const response = await client.jobs.submitMinimaxH3(..., {
     abortSignal: controller.signal
 });
 controller.abort(); // aborts the request
@@ -274,12 +418,19 @@ The SDK provides access to raw response data, including headers, through the `.w
 The `.withRawResponse()` method returns a promise that results to an object with a `data` and a `rawResponse` property.
 
 ```typescript
-const { data, rawResponse } = await client.jobs.submitKlingO3(...).withRawResponse();
+const { data, rawResponse } = await client.jobs.submitMinimaxH3(...).withRawResponse();
 
 console.log(data);
-console.log(rawResponse.headers['X-My-Header']);
+console.log(rawResponse.headers.get("x-request-id"));
 ```
 
+### Spec Version Header
+
+Every request carries an `X-Hedra-Spec-Version` header naming the OpenAPI spec version this client
+was generated from, so the server can tell which generation of the API a caller was built against.
+It is sent automatically; the `specVersion` option that backs it is typed to the pinned version, so
+there is nothing to configure.
+
 ### Logging
 
 The SDK supports logging. You can configure the logger by passing in a `logging` object to the client options.
@@ -382,11 +533,8 @@ other than your configured base.
 
 ### Runtime Compatibility
 
-
 The SDK works in the following runtimes:
 
-
-
 - Node.js 18+
 - Vercel
 - Cloudflare Workers
@@ -394,7 +542,6 @@ The SDK works in the following runtimes:
 - Bun 1.0+
 - React Native
 
-
 ## Contributing
 
 While we value open-source contributions to this SDK, this library is generated programmatically.

package/dist/cjs/BaseClient.d.ts

@@ -7,7 +7,7 @@ export type BaseClientOptions = {
     /** Specify a custom URL to connect the client to. */
     baseUrl?: core.Supplier<string>;
     /** Override the X-Hedra-Spec-Version header */
-    specVersion?: "3.16.0";
+    specVersion?: "3.16.2";
     /** Additional headers to include in requests. */
     headers?: Record<string, string | core.Supplier<string | null | undefined> | null | undefined>;
     /** The default maximum time to wait for a response in seconds. */
@@ -34,7 +34,7 @@ export interface BaseRequestOptions {
     /** A hook to abort the request. */
     abortSignal?: AbortSignal;
     /** Override the X-Hedra-Spec-Version header */
-    specVersion?: "3.16.0";
+    specVersion?: "3.16.2";
     /** Additional query string parameters to include in the request. */
     queryParams?: Record<string, unknown>;
     /** A dictionary containing additional parameters to spread into the request's body. */

package/dist/cjs/BaseClient.js

@@ -44,11 +44,11 @@ function normalizeClientOptions(options) {
     const headers = (0, headers_js_1.mergeHeaders)({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "@hedra/sdk",
-        "X-Fern-SDK-Version": "5.0.0",
-        "User-Agent": "hedra-node/5.0.0",
+        "X-Fern-SDK-Version": "5.2.0",
+        "User-Agent": "hedra-node/5.2.0",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
-        "X-Hedra-Spec-Version": (_a = options === null || options === void 0 ? void 0 : options.specVersion) !== null && _a !== void 0 ? _a : "3.16.0",
+        "X-Hedra-Spec-Version": (_a = options === null || options === void 0 ? void 0 : options.specVersion) !== null && _a !== void 0 ? _a : "3.16.2",
     }, options === null || options === void 0 ? void 0 : options.headers);
     return Object.assign(Object.assign({}, options), { logging: core.logging.createLogger(options === null || options === void 0 ? void 0 : options.logging), headers });
 }

package/dist/cjs/api/resources/billing/client/Client.js

@@ -80,7 +80,7 @@ class BillingClient {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
             const _authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.0" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.2" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield core.fetcher({
                 url: core.url.join((_d = (_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.HedraEnvironment.Production, "balance"),
                 method: "GET",
@@ -149,7 +149,7 @@ class BillingClient {
                 group_by: groupBy != null ? groupBy : undefined,
             };
             const _authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.0" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.2" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield core.fetcher({
                 url: core.url.join((_d = (_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.HedraEnvironment.Production, "usage"),
                 method: "GET",
@@ -225,7 +225,7 @@ class BillingClient {
                 cursor,
             };
             const _authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.0" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.2" }), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield core.fetcher({
                 url: core.url.join((_d = (_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.HedraEnvironment.Production, "transactions"),
                 method: "GET",

package/dist/cjs/api/resources/files/client/Client.js

@@ -90,7 +90,7 @@ class FilesClient {
             yield _body.appendFile("file", request.file);
             const _maybeEncodedRequest = yield _body.getRequest();
             const _authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)(Object.assign({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.0" }, _maybeEncodedRequest.headers)), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
+            const _headers = (0, headers_js_1.mergeHeaders)(_authRequest.headers, (_a = this._options) === null || _a === void 0 ? void 0 : _a.headers, (0, headers_js_1.mergeOnlyDefinedHeaders)(Object.assign({ "X-Hedra-Spec-Version": (_b = requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.specVersion) !== null && _b !== void 0 ? _b : "3.16.2" }, _maybeEncodedRequest.headers)), requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.headers);
             const _response = yield core.fetcher({
                 url: core.url.join((_d = (_c = (yield core.Supplier.get(this._options.baseUrl))) !== null && _c !== void 0 ? _c : (yield core.Supplier.get(this._options.environment))) !== null && _d !== void 0 ? _d : environments.HedraEnvironment.Production, "files"),
                 method: "POST",

package/dist/cjs/api/resources/jobs/client/Client.d.ts

@@ -88,6 +88,42 @@ export declare class JobsClient {
     listJobLogs(job_id: string, request?: Hedra.JobsListJobLogsRequest, requestOptions?: JobsClient.RequestOptions): Promise<core.Page<Hedra.JobLogItem, Hedra.JobLogListResponse>>;
     stream(job_id: string, request?: Hedra.JobsStreamRequest, requestOptions?: JobsClient.RequestOptions): core.HttpResponsePromise<core.Stream<Hedra.JobsStreamResponse>>;
     private __stream;
+    /**
+     * Create high-fidelity speaking or singing avatar videos.
+     *
+     * Submits an asynchronous job and returns `202` with a job id. Fetch the result at `GET /v3/jobs/{job_id}` — each item in its `outputs[]` follows the `OutputItem` schema — or track progress via `GET /v3/jobs/{job_id}/status` / the SSE stream at `GET /v3/jobs/{job_id}/stream`.
+     *
+     * @param {Hedra.SubmitBodyCreatifyAurora} request
+     * @param {JobsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Hedra.BadRequestError}
+     * @throws {@link Hedra.UnauthorizedError}
+     * @throws {@link Hedra.PaymentRequiredError}
+     * @throws {@link Hedra.ForbiddenError}
+     * @throws {@link Hedra.NotFoundError}
+     * @throws {@link Hedra.UnprocessableEntityError}
+     * @throws {@link Hedra.TooManyRequestsError}
+     * @throws {@link Hedra.InternalServerError}
+     * @throws {@link errors.HedraError}
+     * @throws {@link errors.HedraTimeoutError}
+     *
+     * @example
+     *     await client.jobs.submitCreatifyAurora({
+     *         input: {
+     *             resolution: "480p",
+     *             start_image: {
+     *                 source: "url",
+     *                 url: "url"
+     *             },
+     *             audio: {
+     *                 source: "url",
+     *                 url: "url"
+     *             }
+     *         }
+     *     })
+     */
+    submitCreatifyAurora(request: Hedra.SubmitBodyCreatifyAurora, requestOptions?: JobsClient.RequestOptions): core.HttpResponsePromise<Hedra.SubmitResponse>;
+    private __submitCreatifyAurora;
     /**
      * Polished, print-ready stills when the brief is a finished image rather than a sketch.
      *
@@ -991,6 +1027,43 @@ export declare class JobsClient {
      */
     submitHedraCharacter3(request: Hedra.SubmitBodyHedraCharacter3, requestOptions?: JobsClient.RequestOptions): core.HttpResponsePromise<Hedra.SubmitResponse>;
     private __submitHedraCharacter3;
+    /**
+     * Turn a clear portrait and driving audio into a talking avatar.
+     *
+     * Submits an asynchronous job and returns `202` with a job id. Fetch the result at `GET /v3/jobs/{job_id}` — each item in its `outputs[]` follows the `OutputItem` schema — or track progress via `GET /v3/jobs/{job_id}/status` / the SSE stream at `GET /v3/jobs/{job_id}/stream`.
+     *
+     * @param {Hedra.SubmitBodyHeygenPhotoAvatar4} request
+     * @param {JobsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Hedra.BadRequestError}
+     * @throws {@link Hedra.UnauthorizedError}
+     * @throws {@link Hedra.PaymentRequiredError}
+     * @throws {@link Hedra.ForbiddenError}
+     * @throws {@link Hedra.NotFoundError}
+     * @throws {@link Hedra.UnprocessableEntityError}
+     * @throws {@link Hedra.TooManyRequestsError}
+     * @throws {@link Hedra.InternalServerError}
+     * @throws {@link errors.HedraError}
+     * @throws {@link errors.HedraTimeoutError}
+     *
+     * @example
+     *     await client.jobs.submitHeygenPhotoAvatar4({
+     *         input: {
+     *             aspect_ratio: "16:9",
+     *             resolution: "360p",
+     *             start_image: {
+     *                 source: "url",
+     *                 url: "url"
+     *             },
+     *             audio: {
+     *                 source: "url",
+     *                 url: "url"
+     *             }
+     *         }
+     *     })
+     */
+    submitHeygenPhotoAvatar4(request: Hedra.SubmitBodyHeygenPhotoAvatar4, requestOptions?: JobsClient.RequestOptions): core.HttpResponsePromise<Hedra.SubmitResponse>;
+    private __submitHeygenPhotoAvatar4;
     /**
      * HiDream.ai's open-weights HiDream-O1-Image (8B): one pixel-native model that generates, edits, and personalizes without a VAE or a separate text encoder.
      *