@nodaro/sdk 2.29.0 → 2.31.0

package/dist/entries/creatures.d.ts

@@ -0,0 +1,594 @@
+import { CreatureAttachColumn, ObjectAspectRatio } from '@nodaro/shared/entities';
+export { OBJECT_ASPECT_DEFAULTS as CREATURE_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS as CREATURE_ASPECT_OPTIONS, CREATURE_ATTACH_COLUMNS, ObjectAspectRatio as CreatureAspectRatio, CreatureAttachColumn } from '@nodaro/shared/entities';
+import { TtsProvider } from '@nodaro/shared/models';
+import { N as NodaroClientCore } from '../developer-apps-zSQXWmEG.js';
+import { l as GenerationSessionParams } from '../nodes-C2zu3uqn.js';
+import '@nodaro/shared/apps';
+import '@nodaro/shared/organizations';
+import '@nodaro/shared/types';
+import '@nodaro/shared/video';
+import '@nodaro/shared/nodes';
+import '@nodaro/shared/social';
+import '@nodaro/shared/media';
+import '@nodaro/shared/scene3d';
+import '@nodaro/shared/credits';
+import './jobs.js';
+import './errors.js';
+import '../studio-productions-vbCNSbtf.js';
+import '@nodaro/shared/model-catalog';
+import '@nodaro/prompts/prompt-builder';
+
+/**
+ * Creature voice — IDENTICAL shape + semantics to `Character["voice"]` (the
+ * "talking creature" stack reuses the character voice plumbing verbatim).
+ * Render speech via `client.nodes.run("text-to-speech", { text, voice:
+ * voiceId, provider: ttsProvider, voiceType })`, then feed the audio + the
+ * creature's `sourceImageUrl` to `client.nodes.run("lip-sync", …)` (or
+ * speech-to-video) for a talking-creature clip.
+ */
+interface CreatureVoice {
+    voiceId: string;
+    voiceName: string;
+    traits: string;
+    voiceType?: "premade" | "library" | "custom";
+    /** Playable preview sample (client-played only). */
+    previewUrl?: string;
+    /** Recommended TTS provider — send as `provider` on text-to-speech. */
+    ttsProvider?: TtsProvider;
+}
+/**
+ * Re-export the shared `CreatureAttachColumn` union + its runtime tuple so SDK
+ * consumers don't have to add `@nodaro/shared` as a second dependency just to
+ * typecheck the `attachToColumn` field. Single source of truth lives in
+ * `@nodaro/shared/entity-prompts` (`CREATURE_ATTACH_COLUMNS`).
+ *
+ * `CreatureAspectRatio` is re-exported as an alias of the shared
+ * `ObjectAspectRatio` — `generateMotion`'s `aspectRatio` field is the 5-value
+ * object enum (1:1 / 3:4 / 16:9 / 9:16 / 4:3). The creature motion route
+ * deliberately REUSES `OBJECT_ASPECT_OPTIONS` server-side (a creature reference
+ * clip is centered product-showcase framing, not cinematic 16:9), so the SDK
+ * surfaces the same enum under a creature-friendly name. The runtime tuple is
+ * re-exported as `CREATURE_ASPECT_OPTIONS` / `CREATURE_ASPECT_DEFAULTS` aliases.
+ */
+/**
+ * Creature asset-type enum — the kinds of variant a user can generate off a
+ * creature's anchor main image. Mirrors the literal accepted by
+ * `POST /v1/generate-creature-asset` (`backend/src/routes/generate-creature-asset.ts`).
+ *
+ * Delta vs `ObjectAssetType`: object's `materials` becomes `poses` (a creature
+ * has poses, not materials), and there is NO `motion` value — creature motion
+ * variants flow through the dedicated `/v1/generate-creature-motion` endpoint
+ * (worker-side a different BullMQ job type). `custom` is the free-form bucket;
+ * callers must supply `attachToColumn` explicitly since the worker can't infer
+ * the destination from the asset type.
+ *
+ * The shared `@nodaro/shared` package does NOT export a `CREATURE_ASSET_TYPES`
+ * tuple (the route validates an inline Zod enum), so the SDK defines its own
+ * single-source-of-truth tuple here.
+ */
+declare const CREATURE_ASSET_TYPES: readonly ["angles", "poses", "variations", "custom"];
+type CreatureAssetType = (typeof CREATURE_ASSET_TYPES)[number];
+/**
+ * Reference-photo kind discriminator — the mood-board roles a user can attach
+ * to a creature. Mirrors the `reference_photos.kind` field accepted by
+ * `backend/src/routes/creatures.ts` (the route accepts open strings; this SDK
+ * type narrows to the 6 canonical roles surfaced by the Studio). `other` is
+ * the free-form bucket.
+ */
+type CreatureReferencePhotoKind = "front" | "side" | "detail" | "context" | "moodBoard" | "other";
+interface CreatureReferencePhoto {
+    url: string;
+    kind: CreatureReferencePhotoKind;
+}
+/**
+ * A creature record returned by Nodaro's REST API. Mirrors the camelCase
+ * shape produced by `backend/src/routes/creatures.ts::toCamel()`.
+ *
+ * Asset buckets (`angles`, `poses`, `variations`, `motionClips`) are
+ * independent JSONB arrays keyed by a human-readable variant name (e.g.
+ * `"front"`, `"walking"`, `"scarred"`). Each entry's `url` points at an
+ * R2-hosted asset.
+ *
+ * Creature delta vs object:
+ *   - `species` — free-text creature type (e.g. `"dragon"`, `"wolf"`). This is
+ *     the subject of the establishing-shot prompt and the primary creature
+ *     differentiator (object has no equivalent).
+ *   - `poses` (where object has `materials`) — the pose-variant asset bucket.
+ *   - `category` is free-text (NOT object's fixed 10-value enum) — a creature
+ *     can be any animal/type.
+ *
+ * Identity-foundation fields:
+ *   - `referencePhotos` — caller-supplied mood-board refs (cap 20).
+ *   - `canonicalDescription` — ~80–120-word LLM-authored visual caption,
+ *     populated by `approveMainImage()` / `recaption()`. The wire still sends
+ *     `""` on caption sub-failure, but `get()` normalizes `""` → `null` so
+ *     consumers see the same `string | null` semantics as characters.
+ *   - `styleLock` — whether asset gens should anchor to the canonical style
+ *     captured at approval time. Defaults to `true` on new rows.
+ */
+interface Creature {
+    id: string;
+    userId: string;
+    nodeId: string;
+    projectId: string | null;
+    name: string;
+    description: string | null;
+    /** Free-text creature type/species (e.g. "dragon", "wolf") — the creature
+     *  delta vs object. `null` when unset. */
+    species: string | null;
+    category: string | null;
+    style: string | null;
+    sourceImageUrl: string | null;
+    /** MODEL_CATALOG image-model id the main image was generated with (or `null`).
+     *  Set on create + editable via the update route. */
+    imageProvider: string | null;
+    angles: Array<{
+        name: string;
+        url: string;
+    }>;
+    poses: Array<{
+        name: string;
+        url: string;
+    }>;
+    variations: Array<{
+        name: string;
+        url: string;
+    }>;
+    motionClips: Array<{
+        name: string;
+        url: string;
+    }>;
+    /** Named Creature Boards — dense reference sheets, one per variant/mood
+     *  (the `generate-image/creature-board` factory preset rendered from the
+     *  creature's images). A first-class bucket: community publish snapshots it
+     *  and clone hands the consumer their own copy to extend. Defaults to `[]`.
+     *  `type` marks an image-collage `"identity"` sheet vs a plain `"looks"`
+     *  board; `sourceImages` are the R2 URLs it was collaged from. Both optional
+     *  + backward-compatible (legacy boards have neither). */
+    boards?: Array<{
+        name: string;
+        url: string;
+        type?: "looks" | "identity";
+        sourceImages?: string[];
+    }> | null;
+    /** The creature's voice (the "talking creature" stack) — same shape and
+     *  flow as `Character["voice"]`. `null` when no voice is selected. */
+    voice?: CreatureVoice | null;
+    referencePhotos: CreatureReferencePhoto[];
+    /** `null` when no caption is set (or the LLM caption sub-failed) — the wire
+     *  sends `""`, normalized to `null` in `get()` to match character semantics. */
+    canonicalDescription: string | null;
+    styleLock: boolean;
+    /** The user's chosen DEFAULT asset take per variant (Studio version history).
+     *  OPAQUE map: key `"<bucket>:<variant>"` (e.g. `"angles:front"`) → the chosen
+     *  asset URL (one already present in that bucket). Stored verbatim — keys are
+     *  NOT normalized; soft-capped server-side at 200 keys / 2048-char values
+     *  (overflow dropped silently). Defaults to `{}`. */
+    selectedAssetByVariant?: Record<string, string> | null;
+    deletedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * GET /v1/creatures/:id may append a `pendingJobs` bucket the studio uses to
+ * rehydrate spinners after a reload. Optional on the SDK surface — it doesn't
+ * appear on `list()` rows.
+ */
+interface CreatureDetail extends Creature {
+    pendingJobs?: Array<{
+        jobId: string;
+        assetType: string;
+        name: string;
+        status: string;
+    }>;
+}
+/**
+ * Body for `client.creatures.create()`. Mirrors the INSERT branch of
+ * `upsertCreatureBody` in `backend/src/routes/creatures.ts`. `name` + `nodeId`
+ * are required on create.
+ */
+interface CreateCreatureInput {
+    nodeId: string;
+    name: string;
+    description?: string;
+    /** Free-text creature type/species (the creature delta vs object). */
+    species?: string;
+    /** Free-text category (NOT object's fixed enum — a creature can be anything). */
+    category?: string;
+    style?: string;
+    workflowId?: string;
+    projectId?: string;
+    sourceImageUrl?: string;
+    /** Persistent image-model id (a MODEL_CATALOG image model). Validated
+     *  server-side — unknown / non-image / "" is stored as `null`. */
+    imageProvider?: string | null;
+    referencePhotos?: CreatureReferencePhoto[];
+    canonicalDescription?: string;
+    styleLock?: boolean;
+    /** The user's chosen DEFAULT asset take per variant. OPAQUE
+     *  `"<bucket>:<variant>"` → chosen-URL map; a write REPLACES the whole map.
+     *  Keys stored verbatim; soft-capped server-side at 200 keys / 2048-char values. */
+    selectedAssetByVariant?: Record<string, string>;
+    /** Initial voice selection (see `CreatureVoice`). Omit for a voiceless creature. */
+    voice?: CreatureVoice | null;
+}
+/**
+ * Body for `client.creatures.update()`. Mirrors the UPDATE branch of
+ * `upsertCreatureBody` in `backend/src/routes/creatures.ts`.
+ *
+ * Worker-owned asset buckets (`angles` / `poses` / `variations` /
+ * `motionClips`) are deliberately omitted — the route drops them on UPDATE
+ * so a Studio auto-save with a stale snapshot cannot clobber the worker's
+ * atomic `append_creature_asset()` writes.
+ *
+ * `expectedUpdatedAt` is the optimistic-concurrency token: when present, the
+ * UPDATE only succeeds if the row's `updated_at` still matches; on mismatch
+ * the route returns 409 so the studio can re-fetch + merge.
+ */
+interface UpdateCreatureInput {
+    name?: string;
+    description?: string;
+    /** Free-text creature type/species (the creature delta vs object). */
+    species?: string;
+    category?: string;
+    style?: string;
+    sourceImageUrl?: string;
+    /** Persistent image-model id (a MODEL_CATALOG image model). Validated
+     *  server-side — unknown / non-image / "" is stored as `null`. */
+    imageProvider?: string | null;
+    referencePhotos?: CreatureReferencePhoto[];
+    canonicalDescription?: string;
+    styleLock?: boolean;
+    /** The user's chosen DEFAULT asset take per variant. OPAQUE
+     *  `"<bucket>:<variant>"` → chosen-URL map; a write REPLACES the whole map
+     *  (omit to leave untouched). Keys stored verbatim; soft-capped server-side
+     *  at 200 keys / 2048-char values. */
+    selectedAssetByVariant?: Record<string, string>;
+    /** Named Creature Boards (see `Creature.boards`) — whole-array replace,
+     *  USER-owned (unlike the worker-owned buckets it flows through UPDATE).
+     *  Server caps: 24 boards, 200-char names, 30 sourceImages per board. */
+    boards?: Array<{
+        name: string;
+        url: string;
+        type?: "looks" | "identity";
+        sourceImages?: string[];
+    }>;
+    /** Voice selection (see `CreatureVoice`) — whole-object replace; pass
+     *  `null` to clear the voice, omit to leave untouched. */
+    voice?: CreatureVoice | null;
+    expectedUpdatedAt?: string;
+}
+interface UpdateCreatureResult {
+    id: string;
+    updatedAt: string;
+}
+/**
+ * Combined create + update body (parameter for both branches). Exported for
+ * callers that want to drive a single `upsert` flow without picking between
+ * `Create*` and `Update*`. Mirrors the `upsertCreatureBody` Zod schema in
+ * `backend/src/routes/creatures.ts`. `nodeId` + `name` are required on INSERT;
+ * `id` flips the route into UPDATE mode.
+ */
+interface UpsertCreatureInput extends CreateCreatureInput {
+    id?: string;
+    expectedUpdatedAt?: string;
+}
+type UpsertCreatureResult = {
+    id: string;
+} | UpdateCreatureResult;
+interface ListCreaturesParams {
+    /** When true, return archived creatures instead of active ones. */
+    archived?: boolean;
+    /** Optional project filter — server-scoped to the caller's user. */
+    projectId?: string;
+    /**
+     * Search words: only the creatures whose name or description contains
+     * every word (split on spaces, the first 5), in any order, ignoring case.
+     * Each word is matched as written (`%`, `_` and `*` are not wildcards;
+     * punctuation is kept); blank means no search; up to 200 characters.
+     * Combines with the other filters and with `cursor` paging.
+     */
+    q?: string;
+    /**
+     * Max rows to return (cap 500). OPT-IN: omitted, the server returns the
+     * full legacy listing with no `nextCursor`; supplied, the response is one
+     * page plus `nextCursor` — keep passing it back until it is `null`.
+     */
+    limit?: number;
+    /** Opaque cursor from a prior page's `nextCursor` (fetches the next page). */
+    cursor?: string;
+}
+/**
+ * Input for `client.creatures.generate()` — fires the
+ * `POST /v1/generate-creature` route. Produces 1–10 candidate
+ * main images; each lands as one `jobs` row in `pending` state and is then
+ * enqueued for the worker.
+ *
+ * When `attachToCreatureId` is set AND `count === 1`, the worker writes the
+ * resulting URL directly to `creatures.source_image_url` on completion —
+ * caller doesn't need a separate `approveMainImage` call. Multi-candidate
+ * batches MUST go through explicit approval so the user picks the winner.
+ *
+ * `seedPromptHint` flows the parameter-picker's prompt fragment through to the
+ * worker so a catalog selection (e.g. "armored frost dragon") gets appended to
+ * the generated prompt context.
+ */
+interface GenerateCreatureInput extends GenerationSessionParams {
+    name: string;
+    description?: string;
+    userPrompt?: string;
+    /** Free-text creature type/species (the creature delta vs object). */
+    species?: string;
+    category?: string;
+    style?: "realistic" | "anime" | "3d-pixar" | "illustration";
+    sourceImageUrl?: string;
+    provider?: string;
+    /** Number of candidate images to generate (1–10; server-validated). */
+    count?: number;
+    /** Auto-attach the result to this creature row (single-candidate only). */
+    attachToCreatureId?: string;
+    /** Parameter-picker prompt-fragment pass-through. */
+    seedPromptHint?: string;
+    /** Optional name to set on the attached row alongside the main image. */
+    attachName?: string;
+    /** Optimistic-concurrency token for the single-candidate auto-attach path. */
+    expectedUpdatedAt?: string;
+}
+/**
+ * `generate()` response — `jobIds` is ALWAYS present (the harmonized contract,
+ * matching characters). `jobId` is a deprecated back-compat alias populated only
+ * on `count === 1`; prefer `jobIds`. (Will be removed on the next major.)
+ */
+interface GenerateCreatureResult {
+    jobIds: string[];
+    /** @deprecated count===1 back-compat alias — use `jobIds`. */
+    jobId?: string;
+}
+/**
+ * Input for `client.creatures.generateAsset()` — fires the
+ * `POST /v1/generate-creature-asset` route. Produces a single
+ * angles / poses / variations / custom variant.
+ *
+ * When all three studio-path fields are set (`attachToCreatureId` +
+ * `attachToColumn` + `attachName`), the worker appends
+ * `{ name: attachName, url: <result> }` to the named JSONB array column on
+ * the user's creature row on completion. `attachToColumn` is REQUIRED for
+ * `assetType === "custom"` — the worker can't infer the bucket from the
+ * asset type.
+ */
+interface GenerateCreatureAssetInput extends GenerationSessionParams {
+    assetType: CreatureAssetType;
+    variant: string;
+    name: string;
+    description?: string;
+    userPrompt?: string;
+    category?: string;
+    style?: string;
+    sourceImageUrl?: string;
+    provider?: string;
+    attachToCreatureId?: string;
+    attachToColumn?: CreatureAttachColumn;
+    attachName?: string;
+    /** Parameter-picker prompt-fragment pass-through. */
+    seedPromptHint?: string;
+}
+interface GenerateCreatureAssetResult {
+    jobId: string;
+}
+/**
+ * Input for `client.creatures.generateMotion()` — fires the
+ * `POST /v1/generate-creature-motion` route. Produces a single motion clip
+ * (idle, prowl, attack, etc.) animated FROM a static creature-shot image.
+ *
+ * Mirrors `client.objects.generateMotion()` — the creature motion route reuses
+ * the entity-agnostic object motion helpers server-side. The route hardcodes
+ * the attach column to `motion_clips` — callers supply `attachToCreatureId` +
+ * `attachName` only.
+ *
+ * `sourceImageUrl` is REQUIRED — image-to-video needs a source frame and the
+ * route has no fallback (the studio path supplies the canonical creature-shot
+ * URL explicitly).
+ *
+ * Defaults vs location:
+ *   - `provider` defaults to `"kling-turbo"` (not location's `"kling"`)
+ *   - `aspectRatio` defaults to `"1:1"` server-side via
+ *     `resolveObjectAspectRatio({ assetType: "motion" })` — creatures use
+ *     centered reference framing, not cinematic establishing shots.
+ *
+ * When the studio path is set (`attachToCreatureId` + `attachName`), the
+ * worker appends `{ name: attachName, url: <result> }` to the creature row's
+ * `motion_clips` JSONB column on completion.
+ */
+interface GenerateCreatureMotionInput extends GenerationSessionParams {
+    motionPrompt: string;
+    sourceImageUrl: string;
+    provider?: string;
+    name: string;
+    /** Source clip URL — when set, worker routes to video-to-video refine. */
+    refineFromVideoUrl?: string;
+    category?: string;
+    style?: "realistic" | "anime" | "3d-pixar" | "illustration";
+    canonicalDescription?: string;
+    /** Parameter-picker prompt-fragment pass-through. */
+    seedPromptHint?: string;
+    attachToCreatureId?: string;
+    attachName?: string;
+    /**
+     * Optional aspect ratio override. Defaults to 1:1 server-side. One of the
+     * 5-value `CreatureAspectRatio` union (1:1 / 3:4 / 16:9 / 9:16 / 4:3) — the
+     * creature route reuses the object aspect enum.
+     */
+    aspectRatio?: ObjectAspectRatio;
+    /**
+     * Optional clip duration in seconds. Validated server-side against the chosen
+     * provider's allowed durations (e.g. kling 5/10, wan-i2v 5/10/15); omitted →
+     * the model's own default (no behavior change). Mirrors generate-video's
+     * per-model i2v duration lever.
+     */
+    duration?: number;
+}
+interface GenerateCreatureMotionResult {
+    jobId: string;
+}
+interface ApproveCreatureMainImageResult {
+    sourceImageUrl: string;
+    /**
+     * LLM-authored caption. `null` when the LLM caption sub-failed — the wire
+     * sends `""`, normalized to `null` here so consumers see the same
+     * `string | null` semantics as characters. The main image is still set; call
+     * `recaption()` to retry.
+     */
+    canonicalDescription: string | null;
+}
+interface RecaptionCreatureResult {
+    canonicalDescription: string;
+}
+declare class CreaturesResource {
+    private client;
+    constructor(client: NodaroClientCore);
+    /**
+     * List the caller's creatures. By default returns active creatures only;
+     * pass `archived: true` to fetch soft-deleted rows for an "archive" view.
+     * Optional `projectId` scopes the result to a single project; `q` keeps the
+     * creatures whose name or description contains it.
+     */
+    list(params?: ListCreaturesParams): Promise<{
+        creatures: Creature[];
+        nextCursor?: string | null;
+    }>;
+    /**
+     * Convenience wrapper for `list({ archived: true })`. Returns soft-deleted
+     * rows so callers can drive a UI "Archived" tab without re-encoding the
+     * query param.
+     *
+     * `archived` is omitted from the param type — it's always set to `true` here.
+     */
+    listArchived(params?: Omit<ListCreaturesParams, "archived">): Promise<{
+        creatures: Creature[];
+        nextCursor?: string | null;
+    }>;
+    /**
+     * Fetch a single creature including in-flight asset job state. Soft-deleted
+     * (archived) rows are NOT returned by id — the route enforces
+     * `deleted_at IS NULL` so archived creatures 404 (uniform "not_found" — does
+     * not leak the deleted vs non-existent distinction).
+     */
+    get(id: string): Promise<CreatureDetail>;
+    /**
+     * Create a new creature. `name` + `nodeId` are required — the route 400s
+     * otherwise. Returns the new row's id.
+     *
+     * Note: the underlying route is the same `POST /v1/creatures` upsert that
+     * powers `update()`. This convenience wrapper enforces the INSERT-required
+     * fields at the type level and never sends an `id`.
+     */
+    create(data: CreateCreatureInput): Promise<{
+        id: string;
+    }>;
+    /**
+     * Update a creature. Only the fields you pass are written — undefined keys
+     * are NOT touched on the row. Worker-owned asset buckets are intentionally
+     * not exposed on this surface (see `UpdateCreatureInput` for the rationale).
+     *
+     * Optimistic-concurrency: pass `expectedUpdatedAt` to require the row's
+     * `updated_at` still matches; on mismatch the route returns 409
+     * `concurrent_modification` carrying the fresh `updatedAt`. The SDK
+     * surfaces that as a generic `NodaroError` with the same code.
+     */
+    update(id: string, data: UpdateCreatureInput): Promise<UpdateCreatureResult>;
+    /**
+     * Soft-delete (archive) a creature. The row is hidden from `list()` by
+     * default but recoverable via `restore(id)` or visible under
+     * `listArchived()`. Idempotent — repeating a delete on an already-archived
+     * row is a no-op.
+     */
+    delete(id: string): Promise<{
+        success: true;
+        archived: true;
+    }>;
+    /**
+     * Hard-delete (permanent) a creature — the row + every R2 asset it
+     * references. Archived rows ONLY: active creatures return 400 `not_archived`.
+     * Call `delete()` first to archive, then `permanentDelete()` to destroy.
+     *
+     * Mirrors the `app_runs` permanent-delete pattern (archive-first) so a
+     * stray SDK / curl caller cannot bypass the studio's archive-first UI
+     * flow.
+     */
+    permanentDelete(id: string): Promise<{
+        success: true;
+        permanent: true;
+    }>;
+    /**
+     * Un-archive a creature. If the original name now collides (case-
+     * insensitive) with an active row, the server auto-suffixes "(restored)"
+     * and returns the effective name.
+     */
+    restore(id: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    /**
+     * Fire `POST /v1/generate-creature` to produce one or more candidate main
+     * images. With `count > 1`, all jobs are reserved up-front before any
+     * is enqueued — mid-batch failures roll back atomically.
+     *
+     * When `attachToCreatureId` is set AND `count === 1`, the worker writes
+     * the result directly to the row's `source_image_url`; otherwise you must
+     * call `approveMainImage()` after picking a candidate.
+     */
+    generate(data: GenerateCreatureInput): Promise<GenerateCreatureResult>;
+    /**
+     * Fire `POST /v1/generate-creature-asset` to produce a single variant.
+     * When the studio path is set (`attachToCreatureId` + `attachToColumn` +
+     * `attachName`), the worker appends `{ name: attachName, url: <result> }`
+     * to the named JSONB array column on completion.
+     *
+     * Note: `attachToColumn` is REQUIRED for `assetType === "custom"` — the
+     * worker can't infer the bucket from the asset type. For canonical asset
+     * types (`angles` / `poses` / `variations`), the column is derived
+     * automatically by the route.
+     */
+    generateAsset(data: GenerateCreatureAssetInput): Promise<GenerateCreatureAssetResult>;
+    /**
+     * Fire `POST /v1/generate-creature-motion` to animate the creature's main
+     * image into a motion clip. Image-to-video, single clip per call; the
+     * attach column is hardcoded to `motion_clips` server-side (creatures have a
+     * single motion bucket so the caller doesn't supply `attachToColumn`).
+     * When the studio path is set (`attachToCreatureId` + `attachName`), the
+     * worker appends `{ name: attachName, url: <result> }` to the row's
+     * `motion_clips` column on completion.
+     *
+     * Defaults: `provider` → `"kling-turbo"`, `aspectRatio` → `"1:1"` (set
+     * server-side via `resolveObjectAspectRatio({ assetType: "motion" })`).
+     */
+    generateMotion(data: GenerateCreatureMotionInput): Promise<GenerateCreatureMotionResult>;
+    /**
+     * Approve a completed `generate-creature` job as the creature's main image.
+     * Sets `source_image_url` and fires the LLM caption (Claude Sonnet vision)
+     * inline. Returns the new main-image URL plus the caption.
+     *
+     * Caption-failure semantics: the route still sends `""` on LLM sub-failure,
+     * but the SDK normalizes `""` → `null` here so `canonicalDescription` carries
+     * the same `string | null` semantics as characters. The main image is still
+     * set; call `recaption()` to retry.
+     *
+     * Optimistic-concurrency: pass `expectedUpdatedAt` to gate the update on
+     * the row's current `updated_at`; on mismatch the route returns 409
+     * `concurrent_modification` carrying the fresh token.
+     */
+    approveMainImage(id: string, candidateJobId: string, expectedUpdatedAt?: string): Promise<ApproveCreatureMainImageResult>;
+    /**
+     * Re-fire the LLM caption against the creature's current main image. 502s
+     * on LLM failure (unlike `approveMainImage` which preserves the side-effect
+     * and returns ""); returns 400 `main_image_required` if no main image is
+     * set yet.
+     *
+     * The route is a pure idempotent retry — it does NOT accept an
+     * `expectedUpdatedAt` token (backend route is idempotent retry, not gated on
+     * optimistic-concurrency).
+     */
+    recaption(id: string): Promise<RecaptionCreatureResult>;
+}
+
+export { type ApproveCreatureMainImageResult, CREATURE_ASSET_TYPES, type CreateCreatureInput, type Creature, type CreatureAssetType, type CreatureDetail, type CreatureReferencePhoto, type CreatureReferencePhotoKind, type CreatureVoice, CreaturesResource, type GenerateCreatureAssetInput, type GenerateCreatureAssetResult, type GenerateCreatureInput, type GenerateCreatureMotionInput, type GenerateCreatureMotionResult, type GenerateCreatureResult, type ListCreaturesParams, type RecaptionCreatureResult, type UpdateCreatureInput, type UpdateCreatureResult, type UpsertCreatureInput, type UpsertCreatureResult };

package/dist/entries/creatures.js

@@ -0,0 +1,4 @@
+import '../chunk-EXLAHZKF.js';
+export { OBJECT_ASPECT_DEFAULTS as CREATURE_ASPECT_DEFAULTS, OBJECT_ASPECT_OPTIONS as CREATURE_ASPECT_OPTIONS, CREATURE_ASSET_TYPES, CREATURE_ATTACH_COLUMNS, CreaturesResource } from '../chunk-CK3AMMSC.js';
+//# sourceMappingURL=creatures.js.map
+//# sourceMappingURL=creatures.js.map

package/dist/entries/creatures.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"creatures.js"}

package/dist/entries/credits.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+require('../chunk-ALUUBPDG.cjs');
+var chunk7ISSKQ6S_cjs = require('../chunk-7ISSKQ6S.cjs');
+
+
+
+Object.defineProperty(exports, "CreditsResource", {
+  enumerable: true,
+  get: function () { return chunk7ISSKQ6S_cjs.CreditsResource; }
+});
+//# sourceMappingURL=credits.cjs.map
+//# sourceMappingURL=credits.cjs.map

package/dist/entries/credits.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"credits.cjs"}