@deepraxis/sdk 0.1.1-dev.da8587f → 0.1.1-dev.daf2585

package/dist/generated/sdk.gen.js

@@ -903,6 +903,24 @@ export const browserListEvents = (options) => (options.client ?? client).get({
     url: '/browser/v1/sessions/{sessionId}/events',
     ...options
 });
+/**
+ * 执行页面动作
+ *
+ * 在会话的浏览器里执行一个页面动作并返回结果，由浏览器服务执行，客户端不需要 Playwright。同一会话的动作按到达顺序串行执行，单个动作 30 秒内完成。先用 snapshot 读取页面：元素带 [ref=eN]，click、fill 按 ref 操作；ref 只在最近一次快照里有效，页面跳转后失效（409 ACTION_REF_STALE，重新 snapshot）。省略 tab 时作用于当前标签页。
+ */
+export const browserRunPageAction = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BrowserBearer',
+            scheme: 'bearer',
+            type: 'http'
+        }],
+    url: '/browser/v1/sessions/{sessionId}/actions',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
 /**
  * 请求人工接管
  *
@@ -956,7 +974,7 @@ export const browserViewerHeartbeat = (options) => (options.client ?? client).po
 /**
  * 列出浏览器上下文
  *
- * 分页列出当前账户保存的登录态，按登录态 ID 升序排列。每项返回名称、标签及保存内容的统计信息；将 nextCursor 原样传入读取下一页，直到其为 null。
+ * 分页列出当前账户保存的登录态，按登录态 ID 升序排列。每项返回名称、标签及保存内容的统计信息；将 nextCursor 原样传入读取下一页，直到其为 null。传 name 时只返回该名称的登录态；名称在当前账户内唯一，所以最多一条。
  */
 export const browserListContexts = (options) => (options?.client ?? client).get({
     security: [{
@@ -6428,9 +6446,9 @@ export const cutUndeleteProject = (options) => (options.client ?? client).post({
  * - `GetTimeline` — Duration, tracks, joins; clips are under `items`.
  * - `GetItem` — One clip's compact view, by id.
  * - `FindItems` — Visit every clip with its track; collect results.
- * - `GetMedia` — Media metadata; `durationUs` is microseconds.
+ * - `GetMedia` — Media metadata; `duration` is seconds.
  * - `GetTranscript` — Transcript words in source microseconds.
- * - `GetAnalysis` — Silence, filler or scene segments.
+ * - `GetAnalysis` — Silence, filler, scene or beat segments.
  * - `ListTransitions` — Join transition kinds and parameters.
  * - `ListEffects` — Visual-effect catalog and parameters.
  * - `ListAnimations` — Animation presets by phase and target.
@@ -6466,7 +6484,7 @@ export const cutUndeleteProject = (options) => (options.client ?? client).post({
  *
  * - `type` — Clip kind; decides which fields apply.
  * - `start` — Clip start in seconds; snaps to frames.
- * - `length` — Duration; optional for video and audio.
+ * - `length` — Duration; video and audio may omit it or write "auto".
  * - `media` — Source `{ libraryId, assetId }`.
  * - `sourceIn` — First source second kept; default 0.
  * - `sourceOut` — Exclusive source end; read-only.
@@ -6532,6 +6550,7 @@ export const cutUndeleteProject = (options) => (options.client ?? client).post({
  * - `TOO_MANY_EFFECTS` — More than 8 effects on one clip.
  * - `PROJECT_NOT_FOUND` — No visible project has this id.
  * - `EXPORT_NOT_FOUND` — No such export in this project.
+ * - `DRAFT_RENDER_NOT_FOUND` — No such draft render.
  * - `VERSION_NOT_FOUND` — No saved version has this revision.
  * - `LIBRARY_NOT_FOUND` — The library is missing or invisible.
  * - `BINDING_INVALID` — The binding request is malformed.
@@ -6546,6 +6565,7 @@ export const cutUndeleteProject = (options) => (options.client ?? client).post({
  * - `SCRIPT_LIMIT` — An execute budget was exceeded.
  * - `OPS_REJECTED` — An op failed; the whole edit rolled back.
  * - `EDIT_EXPIRED` — The saved edit id is over ten minutes old.
+ * - `MEDIA_NOT_FOUND` — The asset id is not in that library.
  * - `MEDIA_OFFLINE` — The asset cannot be fetched right now.
  * - `MEDIA_UNAVAILABLE` — The asset is not usable for rendering.
  * - `MEDIA_IMPORT_FAILED` — Importing media failed.
@@ -6632,9 +6652,9 @@ export const cutListFrames = (options) => (options.client ?? client).get({
     ...options
 });
 /**
- * Analyze project media
+ * Analyze project media or measure the project mix
  *
- * Request silence, filler-word or scene analysis for selected bound assets before editing. Omit media to select project sources; ranges returned in segments use source seconds. A pending result is not completion: use retry_after_sec before checking again, and inspect failed or unsupported asset results before deciding which edits are possible. Silence measures transcript-based speech pauses, not music or loudness. A completed transcript without words returns ready with empty segments and reason no_speech; no completed transcript returns unsupported with reason no_transcript. A failed transcription remains failed.
+ * Request silence, filler-word, scene or beat analysis for selected bound assets before editing, or measure the mix the timeline itself renders with kind mix. That kind is a render job, not a read: it answers pending with retry_after_sec and an id. Poll by calling this same method again with body { kinds: ["mix"], id } (there is no separate retrieve method); that call reads the measurement and renders nothing. The answer only exists once the audio has been rendered and measured. Omit media to select project sources; ranges returned in segments use source seconds. A pending result is not completion: use retry_after_sec before checking again, and inspect failed or unsupported asset results before deciding which edits are possible. Silence measures transcript-based speech pauses, not music or loudness. A completed transcript without words returns ready with empty segments and reason no_speech; no completed transcript returns unsupported with reason no_transcript. A failed transcription remains failed. kind mix is separate: it reports the project mix loudness, the loudness of each role and where music masks speech, so an editor can fix the mix rather than guess at it.
  */
 export const cutCreateAnalysis = (options) => (options.client ?? client).post({
     security: [{
@@ -6776,7 +6796,7 @@ export const cutCreateExport = (options) => (options.client ?? client).post({
 /**
  * Create draft range render
  *
- * Render one interval of the timeline so you can hear or look at how that passage comes out, without publishing anything to a media library. Choose kind audio for the mixed soundtrack as an .m4a file, or kind video for a draft-quality .mp4 with picture and sound. from and to are seconds on the project clock and must satisfy 0 <= from < to, to <= the timeline duration, and to - from <= 120; a longer passage is requested in several 分段请求 ranges and joined by the caller. The result is a temporary file (purpose user_data) that expires 24 hours after it is stored and is never imported into a library, so it is not a deliverable and carries no cut-export tag. HTTP 202 only accepts the job; poll praxis.cut.renders.retrieve using the returned id until status is done or failed, then read url while it lasts. A draft also bills like a draft export, by rendered seconds. Each project runs at most 2 draft renders at a time, a budget separate from its exports; a third answers HTTP 429 CUT_BUSY and the same call succeeds once one finishes.
+ * Render one interval of the timeline so you can hear or look at how that passage comes out, without publishing anything to a media library. Choose kind audio for the mixed soundtrack as an .m4a file, or kind video for a draft-quality .mp4 with picture and sound. from and to are seconds on the project clock and must satisfy 0 <= from < to, to <= the timeline duration (an end up to 0.05 s past it, a rounded duration, is read as the end), and to - from <= 120; a longer passage is requested in several 分段请求 ranges and joined by the caller. The result is a temporary file (purpose user_data) that expires 24 hours after it is stored and is never imported into a library, so it is not a deliverable and carries no cut-export tag. HTTP 202 only accepts the job; poll praxis.cut.renders.retrieve using the returned id until status is done or failed, then read url while it lasts. A draft also bills like a draft export, by rendered seconds. Each project runs at most 2 draft renders at a time, a budget separate from its exports; a third answers HTTP 429 CUT_BUSY and the same call succeeds once one finishes.
  */
 export const cutCreateRender = (options) => (options.client ?? client).post({
     security: [{
@@ -7432,7 +7452,7 @@ export const devopsTestRunsList = (options) => (options.client ?? client).get({
 /**
  * Create a test run
  *
- * Start a run of the project's tests at one commit. Name a plan to use its selector, or pass a selector directly for this run alone; the ref says which commit to test and is required, because a run without a commit has nothing to report against. waitUntil decides how far the call waits before answering — queued returns as soon as the run exists, finished waits for a verdict and may take minutes. A retry of an earlier run is a new run: pass its commit and selector, and read the earlier run to compare.
+ * Start a run of the project's tests at one commit. Name a plan to use its selector, or pass a selector directly for this run alone; the ref says which commit to test and is required, because a run without a commit has nothing to report against. waitUntil decides how far the call waits before answering — queued, the default, returns as soon as the run exists; started waits until the run has begun, except for an external run, which is answered at once because it leaves queued only when your own CI uploads; finished waits for a verdict. The wait is bounded at about 25 seconds, and a wait that reaches that bound returns the run as it stands rather than failing — read state to see whether it finished. A retry of an earlier run is a new run: pass its commit and selector, and read the earlier run to compare.
  */
 export const devopsTestRunsCreate = (options) => (options.client ?? client).post({
     security: [{
@@ -7510,7 +7530,7 @@ export const devopsTestExecutionsGet = (options) => (options.client ?? client).g
 /**
  * Upload an external test report
  *
- * Record the results of a run executed outside Praxis by uploading a CTRF or JUnit report. The report is folded into the run named by ref and the run's counts and verdict are recomputed from it. Uploading the same reportId again is idempotent and counts once, so a retry after a timeout is safe; a different reportId for the same run adds its results. Pass the run you created with executor external — a report for a run that does not exist is NOT_FOUND, never silently recorded against another run.
+ * Record the results of a run executed outside Praxis by uploading a CTRF or JUnit report. Nothing has to exist first: a first upload from CI creates the run it reports on (executor external) and catalogues the cases the report names, so there is no setup call before the first result. When the report already belongs to a run, pass ref and the upload joins it; the run's counts and verdict are recomputed from the report. Uploading the same reportId again is idempotent and counts once, so a retry after a timeout is safe — and a reported case is catalogued once, however many reports carry it. The report's bytes are kept as a file (the file field of the answer) rather than in the results database, so the original document stays retrievable.
  */
 export const devopsTestReportsUpload = (options) => (options.client ?? client).post({
     security: [{
@@ -8507,6 +8527,20 @@ export const ontologyUpdateNode = (options) => (options.client ?? client).patch(
         ...options.headers
     }
 });
+/**
+ * Retrieve neighborhood
+ *
+ * Load the subgraph around one node instead of the whole graph — the read to use when a screen or an agent needs the context of one entity. Returns the start node, every node within depth hops of it, the relations whose both ends are in that set, and truncated true when the node limit cut the walk short. direction chooses which way relations are followed; as_of and include_invalid read the graph as those parameters do elsewhere. Visibility is exactly nodes.retrieve's — a node you may reach but not read comes back restricted with its name only, and relations touching it are withheld, so this read never reaches further than a node read does. The node id comes from nodes.list, nodes.create or a changeset; an unknown one answers ONTOLOGY_NODE_NOT_FOUND, the same answer nodes.retrieve gives.
+ */
+export const ontologyNeighborhood = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'ontology-bearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }],
+    url: '/ontology/v1/nodes/{node_id}/neighborhood',
+    ...options
+});
 /**
  * Merge node
  *
@@ -9708,6 +9742,1008 @@ export const searchMap = (options) => (options.client ?? client).post({
         ...options.headers
     }
 });
+/**
+ * List the genres Studio can write
+ *
+ * List the genre catalog so you can choose how a piece is structured before creating a draft. Each genre names its unit kinds, draft properties, deterministic checks and writing rules, and by default only the genres open today are returned. Read the chosen genre in full with studioGenresGet before the first write, because its kinds and limits decide what that draft accepts.
+ */
+export const studioGenresList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/genres',
+    ...options
+});
+/**
+ * Read one genre with its built-in templates
+ *
+ * Read the full rules of one genre: its unit kinds and what each may contain, the draft properties with their limits, the deterministic checks the software runs, the semantic review list, and the built-in templates that can seed a draft. Ask for this before creating a draft of that genre, and again when a write is refused for an unknown kind, a property limit or a block type the genre does not allow.
+ */
+export const studioGenresGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/genres/{genre}',
+    ...options
+});
+/**
+ * List the platforms a work can be produced for
+ *
+ * List rendition targets with the format each needs, whether it receives a finished piece through an API, a draft box or an export, and the hard limits a piece must respect. Pass a genre to see only the platforms that genre produces by default. Read one platform in full before rendering, because its limits decide whether the rendition validates.
+ */
+export const studioPlatformsList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/platforms',
+    ...options
+});
+/**
+ * Read the rules of one platform
+ *
+ * Read one platform in full: the format it consumes, how it receives a finished piece, the preview fidelity the Console can offer, the limits on title, body, image count and aspect, and whether a connected channel is required. Read this before creating a rendition, and again when validation reports that the piece breaks a platform limit.
+ */
+export const studioPlatformsGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/platforms/{platform}',
+    ...options
+});
+/**
+ * List the works of this organization
+ *
+ * List works owned by the API key organization so you can find the one being discussed, with its drafts and how long ago each moved. Archived works are left out unless you ask for them. Continue with next_page_token until the answer stops carrying one; the summaries carry no unit bodies, so read a work before writing in it.
+ */
+export const studioWorksList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works',
+    ...options
+});
+/**
+ * Create a work with its goal
+ *
+ * Create a work: one deliverable piece plus everything around it. Pass the goal the writing serves — the reader, what that reader should get or do, the one-sentence message and the constraints — and the original brief the person gave in their own words. A slug is derived from the title unless you pass one. The work starts with no drafts; create the first one with the drafts create call, because the genre decides the structure.
+ */
+export const studioWorksCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Resolve a loose reference to a work, draft or unit
+ *
+ * Turn a loose reference into the address the other calls take: a slug, a work title, a draft key or a unit number, as a person or another tool would say it. A hit answers the work slug and, when the reference pointed deeper, the draft key and unit number; a miss answers an empty resolved value with up to three near matches instead of failing. Use it when a person names something instead of an id.
+ */
+export const studioWorksResolve = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works:resolve',
+    ...options
+});
+/**
+ * Read a work, optionally with one draft and unit
+ *
+ * Read a work and, in the same answer, whatever part of it the page needs: pass draft to get that draft with its todos, its unit outline and its properties, and unit to get one unit with its blocks and Markdown body. This is the call that opens an editing session, because it answers the goal, the brief, the current revisions and the unit to write in one round trip.
+ */
+export const studioWorksGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}',
+    ...options
+});
+/**
+ * Change the title, goal or attached libraries
+ *
+ * Change work-level settings: the title, the slug, the goal, the attached reference libraries, the style or the archived flag. Send update_mask naming exactly the fields you change; a field left out keeps its value. Pass expected_revision to have the write refused when someone else changed the work first, and note that changing the message makes every draft derived from it stale.
+ */
+export const studioWorksUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Add to or correct the original brief
+ *
+ * Extend the original brief: append text, attach files, add points taken from an outline, edit one point, or drop a point. Points are how the software checks that every requirement landed in a written unit, so split the person's outline into points here rather than burying them in prose. The brief carries its own revision, separate from the work and from each draft.
+ */
+export const studioWorksUpdateBrief = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/brief',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * List the drafts a work carries
+ *
+ * List every draft of one work, each with its genre, its size and whether it is out of date against what it was derived from. Use it to choose the draft a later call works in: the key beside each draft is what the draft path segment takes. This list is not paged, because a work carries a handful of drafts rather than thousands.
+ */
+export const studioDraftsList = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts',
+    ...options
+});
+/**
+ * Create a draft of a genre inside a work
+ *
+ * Create a draft: one way of delivering the work, written in one genre. The genre decides the unit kinds, the properties and the checks, so read it first with the genre call and pass its key. A template may seed the unit tree, an outline may be given instead, and derived_from records that this draft is built from the goal message or from another draft of the work. The work may hold several drafts, one per platform or per length.
+ */
+export const studioDraftsCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Read one draft with optional units and todos
+ *
+ * Read one draft: its genre, its properties, its revisions, whether it is stale, and optionally its unit tree and its todo list. Pass expand to add the parts you need in this one call instead of reading them separately. Read this before writing to the draft, because the revision it returns is the precondition the next write has to carry.
+ */
+export const studioDraftsGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}',
+    ...options
+});
+/**
+ * Change a draft title, key, properties or style
+ *
+ * Change the draft itself rather than its units: its page title, its in-work key, its generic properties, the style that overrides the work style, or its mode. Send update_mask naming exactly the fields you change. Changing the key keeps the previous one resolving, so old links and old references still work; a key another draft of the work already uses answers DRAFT_KEY_TAKEN.
+ */
+export const studioDraftsUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Read the whole unit outline as Markdown
+ *
+ * Read the draft structure as one Markdown page: one line per unit carrying its number, structure name, intent, status, length and revision, followed by the unit list itself. Use it to plan a sequence of writes without reading every unit, since it carries no body text. Read one unit in full with the unit call once you know which one to write.
+ */
+export const studioDraftsOutline = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/outline',
+    ...options
+});
+/**
+ * Read the computed todo list of a draft
+ *
+ * Read what is outstanding in one draft, computed from the data rather than from a plan: a unit without an intent, a body behind its intent, an unclaimed brief point, a failed check, a stale rendition. Each item names the layer it belongs to and suggests the call that resolves it. Follow the list instead of inventing an order, and re-read it after a batch of writes.
+ */
+export const studioDraftsStatus = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/status',
+    ...options
+});
+/**
+ * Read a review pass over the whole draft
+ *
+ * Read everything a reviewer needs in one answer: the deterministic check results, the semantic review list the genre asks a reader to judge, the brief coverage showing which unit claims each requirement point, and the body text. When the draft is long the body is a synopsis with an excerpt around each unit and next_page_token carries the full text. This is the call an agent makes before writing review comments.
+ */
+export const studioDraftsReview = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/review',
+    ...options
+});
+/**
+ * Confirm a draft already follows its source
+ *
+ * Clear the stale flag after checking that the draft still matches what it was derived from: the recorded source revision moves to the source current revision without touching any unit. Call it after the source moved and you have brought this draft up to date, not to make the flag disappear while the text is still behind. It answers the same shape as a draft write, and the draft revision does not move.
+ */
+export const studioDraftsRebase = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}:rebase',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Export the draft as Markdown or plain text
+ *
+ * Read the whole draft as one document in Markdown or plain text, returned synchronously in the answer. This is the quick path for a person who wants the text now; a file in a platform format, a card image or a docx comes from creating a rendition instead. Ask for text rather than markdown when the reader should not see block anchors or heading syntax.
+ */
+export const studioDraftsExport = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/export',
+    ...options
+});
+/**
+ * Add one unit to the draft tree
+ *
+ * Add a unit to the structure: a chapter, a scene, a section, an argument or a product depending on the genre. Say where it goes with parent and after, give it the structure name people will use to manage it, and write the intent that says what it has to accomplish. Adding a unit changes the draft revision, so pass expected_revision, and the new unit itself starts with no body.
+ */
+export const studioUnitsCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/units',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Add a whole outline of units at once
+ *
+ * Create many units in one write from a nested outline, which is how a structure is built after the person approved a plan. Nesting in the outline becomes the parent chain, numbers are assigned in order, and the draft gets one revision for the whole batch rather than one per unit. Sending the same outline twice would duplicate it, so pass the draft revision you read and repeat the call only after a refusal.
+ */
+export const studioUnitsBatchCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/units:batchCreate',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Write intents for many units in one call
+ *
+ * Change the intent of several units in one write: the synopsis, the points and the brief points each of them claims. Bodies are not part of this call, because a body is written one unit at a time with its own revision; here the whole batch shares the draft revision you read. Use it to lay out a plan across the tree, then write bodies one by one.
+ */
+export const studioUnitsBatchUpdate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/drafts/{draft}/units:batchUpdate',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Read one unit with its blocks and Markdown
+ *
+ * Read one unit: its intent, its status, its revision, its links to reference entries, and its body as both blocks and Markdown. The Markdown carries each block identifier inline as an anchor comment, so a rewrite can keep the identifiers of the blocks it keeps. Read this before writing the body, because the revision it returns is the precondition that write has to carry.
+ */
+export const studioUnitsGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/units/{unit}',
+    ...options
+});
+/**
+ * Change a unit intent, body or status
+ *
+ * Change one unit: its name, its heading, its synopsis and points, the brief points it claims, its status, its links to reference entries, or its body as a whole Markdown text. A body write requires expected_revision, because replacing the whole text would drop blocks someone else inserted. The answer carries the unit as it now stands, so read the next field of the answer instead of re-reading the unit.
+ */
+export const studioUnitsUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/units/{unit}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Move a unit to another place in the tree
+ *
+ * Move a unit under another parent or after another sibling, without changing its number, its identifier, its intent or its body. A move that would put a unit inside its own descendant, or that would cross into another draft, is refused. Only the moved unit changes, so the revision to pass is its own.
+ */
+export const studioUnitsMove = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/units/{unit}:move',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Edit a unit body block by block
+ *
+ * Change a body by naming the blocks to insert, replace or delete instead of resending the whole text. This is the safe way for a writer that only touches part of a unit, because a block another writer changed after your revision is refused rather than overwritten. The revision is required, and the answer carries the unit with its blocks so the next edit can address them.
+ */
+export const studioUnitsPatchBlocks = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/units/{unit}/blocks:patch',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Read the context pack for writing one unit
+ *
+ * Read everything a writer needs before touching one unit: the genre rules, the goal, the brief, the style, the upstream source, the reference entries this unit draws on, the synopses of the units before it, and the intent of this unit, assembled in a fixed order and measured against a token budget. Entries left out say why, so a missing detail is visible rather than silent. Same input gives the same pack, which is what makes a written result reproducible.
+ */
+export const studioUnitsContext = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/works/{work}/units/{unit}/context',
+    ...options
+});
+/**
+ * List the reference libraries of this organization
+ *
+ * List the reference libraries this API key organization owns, each with how many entries it holds, so you can choose the one a work draws on. Continue with next_page_token until the answer stops carrying one. A library is shared across works, so the list is the whole organization's rather than one work's.
+ */
+export const studioCodexesList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes',
+    ...options
+});
+/**
+ * Create a reference library
+ *
+ * Create a reference library: a shared store of the people, places, products and facts a piece draws on, reusable across works. Attach it to a work with the work update call, and the entries it holds then reach the context packs of that work's units. A library is not private to one work, so the same brand facts can serve every piece that mentions them.
+ */
+export const studioCodexesCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Delete a reference library
+ *
+ * Delete a library and every entry inside it. A library attached to any work is refused with CODEX_IN_USE, because deleting it would silently strip the reference material those units draw on; detach it from the work first. This cannot be undone, so confirm which library the identifier names.
+ */
+export const studioCodexesDelete = (options) => (options.client ?? client).delete({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}',
+    ...options
+});
+/**
+ * Read one reference library
+ *
+ * Read one reference library: its name, its description, its labels and how many entries it holds. Read this to confirm a library exists before attaching it to a work; the entries themselves are listed with the entry list call, because a library may hold more of them than fit in one answer.
+ */
+export const studioCodexesGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}',
+    ...options
+});
+/**
+ * Rename a reference library or change its description
+ *
+ * Change the library itself: its name, its description or its labels. Send update_mask naming exactly the fields you change; a field left out keeps its value. The entries inside are untouched, and a work that has the library attached keeps it attached under the new name.
+ */
+export const studioCodexesUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * List the entries of a reference library
+ *
+ * List the entries of one library in pages, each with its type, its name, its aliases and whether it is always present in context. Use it to see what a work already knows before adding an entry, since a duplicate name is refused rather than merged. Continue with next_page_token until the answer stops carrying one.
+ */
+export const studioEntriesList = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}/entries',
+    ...options
+});
+/**
+ * Add an entry to a reference library
+ *
+ * Add one entry: a character, a place, a product, a source of facts. Give it the type the genre uses, the name the text will mention, and the description and facts that should reach a writer when it is mentioned. Aliases and excluded phrases keep detection honest, so a common word inside an idiom is not mistaken for the entry. A name already used in the library is refused.
+ */
+export const studioEntriesCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}/entries',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Delete a reference entry
+ *
+ * Delete one entry from a library, which also removes the mentions and the links that pointed at it. Units that claimed it keep their text; only the reference goes away. This cannot be undone, so confirm the name of the entry before deleting it, and prefer changing its tracking setting to never when it should stop reaching writers but stay recorded.
+ */
+export const studioEntriesDelete = (options) => (options.client ?? client).delete({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}/entries/{entry}',
+    ...options
+});
+/**
+ * Read one reference entry
+ *
+ * Read one entry in full: its description, its fact ledger, its relations to other entries, its detection settings and its images. Read it before changing it, because an update replaces the fields it names rather than merging them. The entry is addressed by its name in this library, or by its ent_ identifier.
+ */
+export const studioEntriesGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}/entries/{entry}',
+    ...options
+});
+/**
+ * Change what a reference entry says
+ *
+ * Change one entry: its type, its name, its aliases, its description, its facts, its notes, its tracking setting, its images or its relations. Send update_mask naming exactly the fields you change, because a field the mask leaves out keeps its value while a list field the mask names is replaced whole. Renaming an entry changes what the text has to mention for detection to find it.
+ */
+export const studioEntriesUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/codexes/{codex}/entries/{entry}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * List the writing styles of this organization
+ *
+ * List the styles this API key organization owns, each with its name and description, so you can choose the voice a work should be written in. Continue with next_page_token until the answer stops carrying one. Read one style in full before attaching it, because its samples are what actually shape the writing.
+ */
+export const studioStylesList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/styles',
+    ...options
+});
+/**
+ * Create a writing style
+ *
+ * Create a style: the voice a piece is written in, held as samples rather than as adjectives. Samples matter more than a description, so paste one to five paragraphs of writing the piece should sound like, and put the words to avoid into avoid so the banned-word check uses them. Attach a style to a work, or to one draft of it, and its samples then reach every context pack.
+ */
+export const studioStylesCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/styles',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Delete a writing style
+ *
+ * Delete a style, which detaches it from every work and draft that used it; those units then stop receiving its samples and glossary in their context packs. This cannot be undone, so confirm the style identifier before deleting it, and read the work first when it is not certain which style it uses.
+ */
+export const studioStylesDelete = (options) => (options.client ?? client).delete({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/styles/{style}',
+    ...options
+});
+/**
+ * Read one writing style
+ *
+ * Read one style in full: its samples, the wording to use and to avoid, and its glossary of wrong-to-right terms. Read it before attaching it to a work, since samples decide the sound of the writing far more than the description does, and a glossary term also becomes a deterministic check against the text.
+ */
+export const studioStylesGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/styles/{style}',
+    ...options
+});
+/**
+ * Change a writing style
+ *
+ * Change a style: its name, its description, its samples, its use and avoid lists, or its glossary. Send update_mask naming exactly the fields you change; a list the mask names is replaced whole. Adding a term to the glossary or to avoid also changes what the deterministic checks flag, so a work that uses this style sees new findings on its next check.
+ */
+export const studioStylesUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/styles/{style}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * List the templates a genre can start from
+ *
+ * List templates: the built-in starting structures of each genre, followed by the ones this organization saved. Pass a genre to see only the templates that genre can use. A template is used once when a draft is created and is then detached, so changing a template never rewrites a draft that already started from it.
+ */
+export const studioTemplatesList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/templates',
+    ...options
+});
+/**
+ * Save a starting structure as a template
+ *
+ * Save a unit tree as a reusable template for one genre, so the same structure can seed later drafts. Give the genre, a name, the outline of units with their intents, and optionally the writing guidance a writer should follow. Creating a template from an existing draft is a separate milestone and answers NOT_IMPLEMENTED, so build the outline here instead.
+ */
+export const studioTemplatesCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/templates',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Delete a saved template
+ *
+ * Delete a template this organization saved. A built-in template belongs to the catalog and cannot be deleted, so this answers TEMPLATE_NOT_FOUND for one. Drafts that already started from the template are unaffected, because the template was detached when they were created. This cannot be undone.
+ */
+export const studioTemplatesDelete = (options) => (options.client ?? client).delete({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/templates/{template}',
+    ...options
+});
+/**
+ * Read one template
+ *
+ * Read one template: its genre, the writing guidance it carries and the unit outline it seeds, with each unit's intent. Address a saved template by its identifier and a built-in one by its key, alone or with its genre prefix such as novel_long:three_act when two genres share a key. Read it before creating a draft from it, because the template decides the structure the draft starts with.
+ */
+export const studioTemplatesGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/templates/{template}',
+    ...options
+});
+/**
+ * List the rendition themes of a platform
+ *
+ * List themes: the layouts a rendition is produced with, for one platform or for all of them. Pass a platform to see only the themes that platform can use. A theme decides the page or card a rendition is built into, so read the chosen theme before creating a rendition rather than after the output looks wrong.
+ */
+export const studioThemesList = (options) => (options?.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/themes',
+    ...options
+});
+/**
+ * Create a rendition theme
+ *
+ * Create a theme for one platform: the HTML and CSS a written piece is rendered into, plus the fixed header and footer every rendition carries. A DOCX platform takes a reference document instead of markup, and a card theme takes its aspect, width and fonts. An agent may write a theme here, which is how a new layout appears without a release.
+ */
+export const studioThemesCreate = (options) => (options.client ?? client).post({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/themes',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
+/**
+ * Delete a rendition theme
+ *
+ * Delete a theme this organization created. A built-in theme belongs to the platform and cannot be deleted, so this answers THEME_NOT_FOUND for one. Renditions already produced with the theme keep their output, because the produced file no longer depends on the theme. This cannot be undone.
+ */
+export const studioThemesDelete = (options) => (options.client ?? client).delete({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/themes/{theme}',
+    ...options
+});
+/**
+ * Read one rendition theme
+ *
+ * Read one theme in full: the HTML template and stylesheet it renders with, the header and footer it always carries, the reference document a DOCX rendition uses, or the card proportions a card rendition uses. Read it before creating a rendition with it, because a theme decides what the output looks like and a DOCX theme is a file rather than markup.
+ */
+export const studioThemesGet = (options) => (options.client ?? client).get({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/themes/{theme}',
+    ...options
+});
+/**
+ * Change a rendition theme
+ *
+ * Change a theme: its name, its markup, its stylesheet, or the fixed fragments around every rendition. Send update_mask naming exactly the fields you change. Changing a theme does not rewrite renditions already produced with an earlier version, because each rendition records the theme version it was built from.
+ */
+export const studioThemesUpdate = (options) => (options.client ?? client).patch({
+    security: [{
+            key: 'BearerAuth',
+            scheme: 'bearer',
+            type: 'http'
+        }, {
+            key: 'ApiKeyAuth',
+            name: 'X-API-Key',
+            type: 'apiKey'
+        }],
+    url: '/studio/v1/themes/{theme}',
+    ...options,
+    headers: {
+        'Content-Type': 'application/json',
+        ...options.headers
+    }
+});
 /**
  * List vaults
  *