@widgetic/api-sdk 1.0.24 → 1.0.25

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

@@ -10,10 +10,22 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { GetAllManagedUsers200Response, ManagedUser, NewManagedUser, UpdateManagedUser } from '../models/index';
+import type { CopyMyPresetRequest, CopyPartnerPresetRequest, EditorSession, GetAllManagedUsers200Response, GetManagedUsersByManagerId200Response, ListMyPresets200Response, ManagedUser, ManagedUserUsage, MyPresetCopy, NewEditorSession, NewManagedUser, PartnerPresetCopy, RevokeManagedUserEditorSessions200Response, UpdateManagedUser } from '../models/index';
+export interface CopyMyPresetOperationRequest {
+    copyMyPresetRequest: CopyMyPresetRequest;
+}
+export interface CopyPresetForManagedUserRequest {
+    id: string;
+    key: string;
+    copyPartnerPresetRequest?: CopyPartnerPresetRequest;
+}
 export interface CreateManagedUserRequest {
     newManagedUser: NewManagedUser;
 }
+export interface CreateManagedUserEditorSessionRequest {
+    id: string;
+    newEditorSession: NewEditorSession;
+}
 export interface DeleteManagedUserRequest {
     id: string;
 }
@@ -25,12 +37,24 @@ export interface GetAllManagedUsersRequest {
 export interface GetManagedUserByIdRequest {
     id: string;
 }
+export interface GetManagedUserUsageRequest {
+    id: string;
+    startDate?: string;
+    endDate?: string;
+}
 export interface GetManagedUsersByManagerIdRequest {
     managerId: string;
     page?: number;
     size?: number;
     sort?: string;
 }
+export interface RevokeManagedUserEditorSessionRequest {
+    id: string;
+    sessionId: string;
+}
+export interface RevokeManagedUserEditorSessionsRequest {
+    id: string;
+}
 export interface UpdateManagedUserRequest {
     id: string;
     updateManagedUser: UpdateManagedUser;
@@ -40,32 +64,62 @@ export interface UpdateManagedUserRequest {
  */
 export declare class ManagedUsersApi extends runtime.BaseAPI {
     /**
-     * Creates a new managed user for a partner account.
+     * Copies the preset `key` (from `listMyPresets`) onto a new canvas for the customer the editor session was made for. The widget creator module calls it when a customer picks a starting point, and then opens on the canvas and widget it answers with. The copy is the same one `copyPresetForManagedUser` makes for you: a draft widget in your account, filed under the customer, with the preset\'s code, design and content schemas, and thumbnail, and a fork of its code repository. No other customer\'s editor can reach it, and changing or removing the preset afterwards never touches it.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session says whose presets and which customer, so the body names only the preset: a customer cannot ask for a copy for another customer or from another partner. The `Idempotency-Key` header is required (`400` without it): send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: use `copyPresetForManagedUser`, which names the customer.
+     * Give a customer\'s editor session a copy of one of your presets
+     */
+    copyMyPresetRaw(requestParameters: CopyMyPresetOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MyPresetCopy>>;
+    /**
+     * Copies the preset `key` (from `listMyPresets`) onto a new canvas for the customer the editor session was made for. The widget creator module calls it when a customer picks a starting point, and then opens on the canvas and widget it answers with. The copy is the same one `copyPresetForManagedUser` makes for you: a draft widget in your account, filed under the customer, with the preset\'s code, design and content schemas, and thumbnail, and a fork of its code repository. No other customer\'s editor can reach it, and changing or removing the preset afterwards never touches it.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session says whose presets and which customer, so the body names only the preset: a customer cannot ask for a copy for another customer or from another partner. The `Idempotency-Key` header is required (`400` without it): send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: use `copyPresetForManagedUser`, which names the customer.
+     * Give a customer\'s editor session a copy of one of your presets
+     */
+    copyMyPreset(requestParameters: CopyMyPresetOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MyPresetCopy>;
+    /**
+     * Copies the preset `key` (see `setPartnerPreset`) onto a new canvas for one of your managed users, so their widget creator opens on a widget of their own that starts from yours. The copy is a draft widget in your account, filed under the managed user: `getAllWidgets` with `managedUserId` lists it, and no other managed user\'s editor can reach it.  The copy carries the preset\'s code, design and content schemas, and thumbnail, and starts from a fork of its code repository, so the user\'s chat edits begin where yours left off. It does not carry the preset\'s database or its compositions. It is not a preset itself, and changing or removing the preset afterwards never touches it.  To start a composition (the content and design editor) instead, you do not need a copy: call `createComposition` with the preset\'s `widgetId` (from `listPartnerPresets`) and the managed user.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  The managed user must be yours and active.
+     * Give a managed user a copy of one of your presets
+     */
+    copyPresetForManagedUserRaw(requestParameters: CopyPresetForManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PartnerPresetCopy>>;
+    /**
+     * Copies the preset `key` (see `setPartnerPreset`) onto a new canvas for one of your managed users, so their widget creator opens on a widget of their own that starts from yours. The copy is a draft widget in your account, filed under the managed user: `getAllWidgets` with `managedUserId` lists it, and no other managed user\'s editor can reach it.  The copy carries the preset\'s code, design and content schemas, and thumbnail, and starts from a fork of its code repository, so the user\'s chat edits begin where yours left off. It does not carry the preset\'s database or its compositions. It is not a preset itself, and changing or removing the preset afterwards never touches it.  To start a composition (the content and design editor) instead, you do not need a copy: call `createComposition` with the preset\'s `widgetId` (from `listPartnerPresets`) and the managed user.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  The managed user must be yours and active.
+     * Give a managed user a copy of one of your presets
+     */
+    copyPresetForManagedUser(requestParameters: CopyPresetForManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerPresetCopy>;
+    /**
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
      * Create Managed User
      */
     createManagedUserRaw(requestParameters: CreateManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagedUser>>;
     /**
-     * Creates a new managed user for a partner account.
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
      * Create Managed User
      */
     createManagedUser(requestParameters: CreateManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedUser>;
     /**
-     * Deletes a managed user by ID.
+     * Makes a short-lived credential that lets the browser of ONE of your managed users use Widgetic\'s editor pieces, such as the File Browser and the composition editor, without your API key ever reaching that browser. Call this from your server when the page that hosts the editor opens, and hand the `token` in the answer to that page.  The token is shown once. It starts with `wgt_ses_` and the browser sends it as `Authorization: Bearer <token>`. It can do only what the `surfaces` you name allow, and only for this managed user:  - `files`: upload a file (`uploadsPost`) and list the files uploaded for this user (`uploadsGet`). Every   file is filed for this user and stored in your own storage destination, never in Widgetic\'s: a file a   customer uploads is yours to keep, and takes none of your storage allowance. So a session with `files`   can be made only after you have set a destination (`setPartnerStorageDestination`); until then it is   refused with 409 and `PARTNER_STORAGE_REQUIRED`, and when the destination cannot be used with 503 and   `STORAGE_DESTINATION_UNAVAILABLE`. A destination you remove after the session was made stops its   uploads too (the same 409; the browser is only told that the feature is not available right now).   Sessions without `files` need no destination: hand the editors your own media library instead   (`mediaLibrary`), and make them without it. - `editor`: edit one of this user\'s compositions: read it (`getCompositionById`, its content, design,   embed settings and schemas), check a content change (`validateCompositionContent`), and change its   name, content, design and embed settings (`updateComposition`, `setDynamicContent`). It can reach   only compositions you created for this managed user (tag them with `managedUserId` when you create   them); any other composition, including another of your users\', answers 404. - `creator`: use Widgetic\'s widget creator for this user, including its AI. Draw on canvases and save   them (`getAllCanvases`, `getCanvas`, `createCanvas`, `updateCanvas`, `previewDeleteCanvas`,   `deleteCanvas`); make, change, copy and delete the widgets on them (`createWidget`, `getWidgets`,   `getWidgetsBatch`, `updateWidget`, `uploadWidgetThumbnail`, `duplicateWidget`, `deleteWidget`);   list and make the compositions of a widget it built (`getAllCompositions`, `createComposition`), which   is how it shows the widget with sample values; read and add their   components (`getComponentsByWidgetId`, `createComponent`); keep the   conversation of each widget (`getConversationsByWidgetId`, `createConversationForWidget`,   `updateConversation`, `getMessages`, `createMessage`, `updateMessage`, `restoreCheckpoint`); and read a   widget\'s schemas and give it its repository (`getWidgetContentSchema`, `getWidgetDesignSchema`,   `updateWidgetRepository`). The AI that builds a widget is part of it: list the models   (`agentModelsGet`), open the widget\'s repository (`agentRepositoriesPost`,   `agentRepositoriesRepoIdGet`), start a generation and follow or cancel it (`agentCodeGeneratePost`,   `operationsStreamGet`, `operationsIdGet`, `operationsIdCancelPost`), build and preview the result   (`agentWidgetBuilderRepoHeadWidgetIdGet`, `buildWidgetFromRepo`, `previewWidgetVersion`), publish a   version of the widget and move between its versions (`agentWidgetBuilderPublishWidgetIdPost`,   `getWidgetPublishHistory`, `setWidgetPublishHistoryLive`, `renameWidgetPublishHistoryTitle`), and   turn a stroke or a sentence into a decision (`agentShapeRecognizePost`, `agentDesignResolvePost`). It can   also offer the customer your presets as starting points: read them and ask for a copy for this customer   (`listMyPresets`, `copyMyPreset`; you choose the presets with `setPartnerPreset`).   What the session makes is filed for this managed user, and the lists it reads hold only this user\'s   canvases, widgets and compositions. It can reach only canvases, widgets, compositions, repositories,   uploaded files and operations made for this managed user (tag the canvases and widgets you create   with `managedUserId`); any other canvas, widget, composition, conversation, message, repository, file   or operation, including another of your users\', answers 404. The creator also saves the composition   it is editing (`updateComposition`, from the `editor` surface) and attaches pictures to its chat   (`uploadsPost`, from the `files` surface), and the surfaces do not imply one another: to open the   whole creator for a user, ask for `creator`, `editor` and `files` together. A generation or a build   one user starts can be followed and cancelled by that user and by you, never by another of your   users. The AI is paid for by your account, as your own calls are: its credits and allowances are   yours. A session cannot make a widget public (publishing a version does not), file one under a   project or an organization, or set anything the creator does not set: a body with another field is   refused with 403 and `EDITOR_SESSION_FIELD_NOT_ALLOWED`.  Everything else is refused with 403 and `EDITOR_SESSION_ROUTE_NOT_ALLOWED`: a session cannot read your account, make more sessions, change your presets or delete a composition, and a session without the `creator` surface cannot create or list compositions. Create the composition yourself with your API key, then open the editor on it.  A session ends at `expiresAt` (at most four hours), when you end it (`revokeManagedUserEditorSession`), or when the managed user is switched off or deleted. A managed user can have at most 100 live sessions at once (`429 EDITOR_SESSION_LIMIT_REACHED`). A session that is bound to a web page (`allowed_origin`) is refused from any other origin.  The AI the session runs is paid for with your credits. Set `max_credits` to hold the session to a number of them: once its generations have taken that many (a generation that fails is refunded and does not count), the next one is refused with 402 and `EDITOR_SESSION_CREDIT_LIMIT_REACHED`, and the browser is told only that the feature is not available right now. Without it, the credits of your account are the only ceiling. What each of your users\' sessions has spent is in `getManagedUserUsage`.  Each call makes a new session. It does not take an `Idempotency-Key`: the answer holds the token, and the token is never stored where a retry could read it back. The answer is sent with `Cache-Control: no-store`.
+     * Create an editor session for a managed user
+     */
+    createManagedUserEditorSessionRaw(requestParameters: CreateManagedUserEditorSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EditorSession>>;
+    /**
+     * Makes a short-lived credential that lets the browser of ONE of your managed users use Widgetic\'s editor pieces, such as the File Browser and the composition editor, without your API key ever reaching that browser. Call this from your server when the page that hosts the editor opens, and hand the `token` in the answer to that page.  The token is shown once. It starts with `wgt_ses_` and the browser sends it as `Authorization: Bearer <token>`. It can do only what the `surfaces` you name allow, and only for this managed user:  - `files`: upload a file (`uploadsPost`) and list the files uploaded for this user (`uploadsGet`). Every   file is filed for this user and stored in your own storage destination, never in Widgetic\'s: a file a   customer uploads is yours to keep, and takes none of your storage allowance. So a session with `files`   can be made only after you have set a destination (`setPartnerStorageDestination`); until then it is   refused with 409 and `PARTNER_STORAGE_REQUIRED`, and when the destination cannot be used with 503 and   `STORAGE_DESTINATION_UNAVAILABLE`. A destination you remove after the session was made stops its   uploads too (the same 409; the browser is only told that the feature is not available right now).   Sessions without `files` need no destination: hand the editors your own media library instead   (`mediaLibrary`), and make them without it. - `editor`: edit one of this user\'s compositions: read it (`getCompositionById`, its content, design,   embed settings and schemas), check a content change (`validateCompositionContent`), and change its   name, content, design and embed settings (`updateComposition`, `setDynamicContent`). It can reach   only compositions you created for this managed user (tag them with `managedUserId` when you create   them); any other composition, including another of your users\', answers 404. - `creator`: use Widgetic\'s widget creator for this user, including its AI. Draw on canvases and save   them (`getAllCanvases`, `getCanvas`, `createCanvas`, `updateCanvas`, `previewDeleteCanvas`,   `deleteCanvas`); make, change, copy and delete the widgets on them (`createWidget`, `getWidgets`,   `getWidgetsBatch`, `updateWidget`, `uploadWidgetThumbnail`, `duplicateWidget`, `deleteWidget`);   list and make the compositions of a widget it built (`getAllCompositions`, `createComposition`), which   is how it shows the widget with sample values; read and add their   components (`getComponentsByWidgetId`, `createComponent`); keep the   conversation of each widget (`getConversationsByWidgetId`, `createConversationForWidget`,   `updateConversation`, `getMessages`, `createMessage`, `updateMessage`, `restoreCheckpoint`); and read a   widget\'s schemas and give it its repository (`getWidgetContentSchema`, `getWidgetDesignSchema`,   `updateWidgetRepository`). The AI that builds a widget is part of it: list the models   (`agentModelsGet`), open the widget\'s repository (`agentRepositoriesPost`,   `agentRepositoriesRepoIdGet`), start a generation and follow or cancel it (`agentCodeGeneratePost`,   `operationsStreamGet`, `operationsIdGet`, `operationsIdCancelPost`), build and preview the result   (`agentWidgetBuilderRepoHeadWidgetIdGet`, `buildWidgetFromRepo`, `previewWidgetVersion`), publish a   version of the widget and move between its versions (`agentWidgetBuilderPublishWidgetIdPost`,   `getWidgetPublishHistory`, `setWidgetPublishHistoryLive`, `renameWidgetPublishHistoryTitle`), and   turn a stroke or a sentence into a decision (`agentShapeRecognizePost`, `agentDesignResolvePost`). It can   also offer the customer your presets as starting points: read them and ask for a copy for this customer   (`listMyPresets`, `copyMyPreset`; you choose the presets with `setPartnerPreset`).   What the session makes is filed for this managed user, and the lists it reads hold only this user\'s   canvases, widgets and compositions. It can reach only canvases, widgets, compositions, repositories,   uploaded files and operations made for this managed user (tag the canvases and widgets you create   with `managedUserId`); any other canvas, widget, composition, conversation, message, repository, file   or operation, including another of your users\', answers 404. The creator also saves the composition   it is editing (`updateComposition`, from the `editor` surface) and attaches pictures to its chat   (`uploadsPost`, from the `files` surface), and the surfaces do not imply one another: to open the   whole creator for a user, ask for `creator`, `editor` and `files` together. A generation or a build   one user starts can be followed and cancelled by that user and by you, never by another of your   users. The AI is paid for by your account, as your own calls are: its credits and allowances are   yours. A session cannot make a widget public (publishing a version does not), file one under a   project or an organization, or set anything the creator does not set: a body with another field is   refused with 403 and `EDITOR_SESSION_FIELD_NOT_ALLOWED`.  Everything else is refused with 403 and `EDITOR_SESSION_ROUTE_NOT_ALLOWED`: a session cannot read your account, make more sessions, change your presets or delete a composition, and a session without the `creator` surface cannot create or list compositions. Create the composition yourself with your API key, then open the editor on it.  A session ends at `expiresAt` (at most four hours), when you end it (`revokeManagedUserEditorSession`), or when the managed user is switched off or deleted. A managed user can have at most 100 live sessions at once (`429 EDITOR_SESSION_LIMIT_REACHED`). A session that is bound to a web page (`allowed_origin`) is refused from any other origin.  The AI the session runs is paid for with your credits. Set `max_credits` to hold the session to a number of them: once its generations have taken that many (a generation that fails is refunded and does not count), the next one is refused with 402 and `EDITOR_SESSION_CREDIT_LIMIT_REACHED`, and the browser is told only that the feature is not available right now. Without it, the credits of your account are the only ceiling. What each of your users\' sessions has spent is in `getManagedUserUsage`.  Each call makes a new session. It does not take an `Idempotency-Key`: the answer holds the token, and the token is never stored where a retry could read it back. The answer is sent with `Cache-Control: no-store`.
+     * Create an editor session for a managed user
+     */
+    createManagedUserEditorSession(requestParameters: CreateManagedUserEditorSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EditorSession>;
+    /**
+     * Deletes a managed user by ID. Its editor sessions end with it. What was filed under it (compositions, widgets, uploads) stays in your account, untagged.
      * Delete Managed User
      */
     deleteManagedUserRaw(requestParameters: DeleteManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
     /**
-     * Deletes a managed user by ID.
+     * Deletes a managed user by ID. Its editor sessions end with it. What was filed under it (compositions, widgets, uploads) stays in your account, untagged.
      * Delete Managed User
      */
     deleteManagedUser(requestParameters: DeleteManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
-     * Retrieve all managed users with pagination support.
+     * Retrieve the managed users you manage, with pagination support. (Admins see every partner\'s managed users.)
      * Get Managed Users
      */
     getAllManagedUsersRaw(requestParameters: GetAllManagedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetAllManagedUsers200Response>>;
     /**
-     * Retrieve all managed users with pagination support.
+     * Retrieve the managed users you manage, with pagination support. (Admins see every partner\'s managed users.)
      * Get Managed Users
      */
     getAllManagedUsers(requestParameters?: GetAllManagedUsersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAllManagedUsers200Response>;
@@ -79,23 +133,63 @@ export declare class ManagedUsersApi extends runtime.BaseAPI {
      * Get Managed User By ID
      */
     getManagedUserById(requestParameters: GetManagedUserByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedUser>;
+    /**
+     * Says how many credits the editor sessions of one of your managed users took from your account over a period, in total and for each operation. A generation costs one credit, taken from your account when it starts; one that fails is refunded and is counted as refunded, not as spent.  Only what was spent through editor sessions is here, and only since usage was first recorded: what you spend with your API key, and anything from before, is not. Use it to see which of your users spend the most, or to charge them for it. To hold one session to a number of credits, set `max_credits` when you make it (`createManagedUserEditorSession`).  The period runs from `startDate` (included) to `endDate` (not included): the 30 days before now when you give neither, and at most 366 days. A date without a time is midnight UTC at the start of that day, so for all of October give `startDate=2026-10-01` and `endDate=2026-11-01`.
+     * What a managed user\'s editor sessions spent
+     */
+    getManagedUserUsageRaw(requestParameters: GetManagedUserUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagedUserUsage>>;
+    /**
+     * Says how many credits the editor sessions of one of your managed users took from your account over a period, in total and for each operation. A generation costs one credit, taken from your account when it starts; one that fails is refunded and is counted as refunded, not as spent.  Only what was spent through editor sessions is here, and only since usage was first recorded: what you spend with your API key, and anything from before, is not. Use it to see which of your users spend the most, or to charge them for it. To hold one session to a number of credits, set `max_credits` when you make it (`createManagedUserEditorSession`).  The period runs from `startDate` (included) to `endDate` (not included): the 30 days before now when you give neither, and at most 366 days. A date without a time is midnight UTC at the start of that day, so for all of October give `startDate=2026-10-01` and `endDate=2026-11-01`.
+     * What a managed user\'s editor sessions spent
+     */
+    getManagedUserUsage(requestParameters: GetManagedUserUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedUserUsage>;
     /**
      * Retrieve managed users for a specific manager with pagination support.
      * Get Managed Users By Manager
      */
-    getManagedUsersByManagerIdRaw(requestParameters: GetManagedUsersByManagerIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetAllManagedUsers200Response>>;
+    getManagedUsersByManagerIdRaw(requestParameters: GetManagedUsersByManagerIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetManagedUsersByManagerId200Response>>;
     /**
      * Retrieve managed users for a specific manager with pagination support.
      * Get Managed Users By Manager
      */
-    getManagedUsersByManagerId(requestParameters: GetManagedUsersByManagerIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAllManagedUsers200Response>;
+    getManagedUsersByManagerId(requestParameters: GetManagedUsersByManagerIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetManagedUsersByManagerId200Response>;
+    /**
+     * Lists the presets your account offers (`setPartnerPreset`), as the picker in a customer\'s widget creator shows them: a key, a title, a description and a thumbnail, in the order you gave them. It is what the widget creator module reads when it opens with nothing of the customer\'s own yet.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session acts as your account and names the one customer it is for, so a customer reads only your presets, and nothing in the request chooses whose. Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: you read your own list with `listPartnerPresets`, which also tells you the widget behind each preset.
+     * The starting points a customer\'s editor session may copy
+     */
+    listMyPresetsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListMyPresets200Response>>;
+    /**
+     * Lists the presets your account offers (`setPartnerPreset`), as the picker in a customer\'s widget creator shows them: a key, a title, a description and a thumbnail, in the order you gave them. It is what the widget creator module reads when it opens with nothing of the customer\'s own yet.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session acts as your account and names the one customer it is for, so a customer reads only your presets, and nothing in the request chooses whose. Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: you read your own list with `listPartnerPresets`, which also tells you the widget behind each preset.
+     * The starting points a customer\'s editor session may copy
+     */
+    listMyPresets(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListMyPresets200Response>;
+    /**
+     * Ends the session at once: its token stops working on the next request (on another server of ours, within a few seconds). Ending a session that has already ended is fine.
+     * End one editor session of a managed user
+     */
+    revokeManagedUserEditorSessionRaw(requestParameters: RevokeManagedUserEditorSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Ends the session at once: its token stops working on the next request (on another server of ours, within a few seconds). Ending a session that has already ended is fine.
+     * End one editor session of a managed user
+     */
+    revokeManagedUserEditorSession(requestParameters: RevokeManagedUserEditorSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Ends all of the managed user\'s live editor sessions at once, for example when the user signs out of your platform. Their tokens stop working on the next request (on another server of ours, within a few seconds). It is fine to call it for a user who has none.
+     * End every editor session of a managed user
+     */
+    revokeManagedUserEditorSessionsRaw(requestParameters: RevokeManagedUserEditorSessionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RevokeManagedUserEditorSessions200Response>>;
+    /**
+     * Ends all of the managed user\'s live editor sessions at once, for example when the user signs out of your platform. Their tokens stop working on the next request (on another server of ours, within a few seconds). It is fine to call it for a user who has none.
+     * End every editor session of a managed user
+     */
+    revokeManagedUserEditorSessions(requestParameters: RevokeManagedUserEditorSessionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RevokeManagedUserEditorSessions200Response>;
     /**
-     * Updates an existing managed user.
+     * Updates an existing managed user. Only `external_id`, `metadata` and `is_active` can change, and `metadata` is replaced as a whole, so send all of it. `is_active: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `is_active: true`. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The `Idempotency-Key` header is required (`400` without it).
      * Update Managed User
      */
     updateManagedUserRaw(requestParameters: UpdateManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ManagedUser>>;
     /**
-     * Updates an existing managed user.
+     * Updates an existing managed user. Only `external_id`, `metadata` and `is_active` can change, and `metadata` is replaced as a whole, so send all of it. `is_active: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `is_active: true`. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The `Idempotency-Key` header is required (`400` without it).
      * Update Managed User
      */
     updateManagedUser(requestParameters: UpdateManagedUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ManagedUser>;

package/dist/esm/apis/ManagedUsersApi.js

@@ -21,13 +21,94 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime.js';
-import { GetAllManagedUsers200ResponseFromJSON, ManagedUserFromJSON, NewManagedUserToJSON, UpdateManagedUserToJSON, } from '../models/index.js';
+import { CopyMyPresetRequestToJSON, CopyPartnerPresetRequestToJSON, EditorSessionFromJSON, GetAllManagedUsers200ResponseFromJSON, GetManagedUsersByManagerId200ResponseFromJSON, ListMyPresets200ResponseFromJSON, ManagedUserFromJSON, ManagedUserUsageFromJSON, MyPresetCopyFromJSON, NewEditorSessionToJSON, NewManagedUserToJSON, PartnerPresetCopyFromJSON, RevokeManagedUserEditorSessions200ResponseFromJSON, UpdateManagedUserToJSON, } from '../models/index.js';
 /**
  *
  */
 export class ManagedUsersApi extends runtime.BaseAPI {
     /**
-     * Creates a new managed user for a partner account.
+     * Copies the preset `key` (from `listMyPresets`) onto a new canvas for the customer the editor session was made for. The widget creator module calls it when a customer picks a starting point, and then opens on the canvas and widget it answers with. The copy is the same one `copyPresetForManagedUser` makes for you: a draft widget in your account, filed under the customer, with the preset\'s code, design and content schemas, and thumbnail, and a fork of its code repository. No other customer\'s editor can reach it, and changing or removing the preset afterwards never touches it.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session says whose presets and which customer, so the body names only the preset: a customer cannot ask for a copy for another customer or from another partner. The `Idempotency-Key` header is required (`400` without it): send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: use `copyPresetForManagedUser`, which names the customer.
+     * Give a customer\'s editor session a copy of one of your presets
+     */
+    copyMyPresetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['copyMyPresetRequest'] == null) {
+                throw new runtime.RequiredError('copyMyPresetRequest', 'Required parameter "copyMyPresetRequest" was null or undefined when calling copyMyPreset().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/me/presets/copy`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CopyMyPresetRequestToJSON(requestParameters['copyMyPresetRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MyPresetCopyFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Copies the preset `key` (from `listMyPresets`) onto a new canvas for the customer the editor session was made for. The widget creator module calls it when a customer picks a starting point, and then opens on the canvas and widget it answers with. The copy is the same one `copyPresetForManagedUser` makes for you: a draft widget in your account, filed under the customer, with the preset\'s code, design and content schemas, and thumbnail, and a fork of its code repository. No other customer\'s editor can reach it, and changing or removing the preset afterwards never touches it.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session says whose presets and which customer, so the body names only the preset: a customer cannot ask for a copy for another customer or from another partner. The `Idempotency-Key` header is required (`400` without it): send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: use `copyPresetForManagedUser`, which names the customer.
+     * Give a customer\'s editor session a copy of one of your presets
+     */
+    copyMyPreset(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.copyMyPresetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Copies the preset `key` (see `setPartnerPreset`) onto a new canvas for one of your managed users, so their widget creator opens on a widget of their own that starts from yours. The copy is a draft widget in your account, filed under the managed user: `getAllWidgets` with `managedUserId` lists it, and no other managed user\'s editor can reach it.  The copy carries the preset\'s code, design and content schemas, and thumbnail, and starts from a fork of its code repository, so the user\'s chat edits begin where yours left off. It does not carry the preset\'s database or its compositions. It is not a preset itself, and changing or removing the preset afterwards never touches it.  To start a composition (the content and design editor) instead, you do not need a copy: call `createComposition` with the preset\'s `widgetId` (from `listPartnerPresets`) and the managed user.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  The managed user must be yours and active.
+     * Give a managed user a copy of one of your presets
+     */
+    copyPresetForManagedUserRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling copyPresetForManagedUser().');
+            }
+            if (requestParameters['key'] == null) {
+                throw new runtime.RequiredError('key', 'Required parameter "key" was null or undefined when calling copyPresetForManagedUser().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/presets/{key}/copy`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters['key']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: CopyPartnerPresetRequestToJSON(requestParameters['copyPartnerPresetRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PartnerPresetCopyFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Copies the preset `key` (see `setPartnerPreset`) onto a new canvas for one of your managed users, so their widget creator opens on a widget of their own that starts from yours. The copy is a draft widget in your account, filed under the managed user: `getAllWidgets` with `managedUserId` lists it, and no other managed user\'s editor can reach it.  The copy carries the preset\'s code, design and content schemas, and thumbnail, and starts from a fork of its code repository, so the user\'s chat edits begin where yours left off. It does not carry the preset\'s database or its compositions. It is not a preset itself, and changing or removing the preset afterwards never touches it.  To start a composition (the content and design editor) instead, you do not need a copy: call `createComposition` with the preset\'s `widgetId` (from `listPartnerPresets`) and the managed user.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one copy is made, not two. A copy that could not be made leaves nothing behind (503 `PRESET_COPY_FAILED`).  The managed user must be yours and active.
+     * Give a managed user a copy of one of your presets
+     */
+    copyPresetForManagedUser(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.copyPresetForManagedUserRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
      * Create Managed User
      */
     createManagedUserRaw(requestParameters, initOverrides) {
@@ -56,7 +137,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Creates a new managed user for a partner account.
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
      * Create Managed User
      */
     createManagedUser(requestParameters, initOverrides) {
@@ -66,7 +147,49 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Deletes a managed user by ID.
+     * Makes a short-lived credential that lets the browser of ONE of your managed users use Widgetic\'s editor pieces, such as the File Browser and the composition editor, without your API key ever reaching that browser. Call this from your server when the page that hosts the editor opens, and hand the `token` in the answer to that page.  The token is shown once. It starts with `wgt_ses_` and the browser sends it as `Authorization: Bearer <token>`. It can do only what the `surfaces` you name allow, and only for this managed user:  - `files`: upload a file (`uploadsPost`) and list the files uploaded for this user (`uploadsGet`). Every   file is filed for this user and stored in your own storage destination, never in Widgetic\'s: a file a   customer uploads is yours to keep, and takes none of your storage allowance. So a session with `files`   can be made only after you have set a destination (`setPartnerStorageDestination`); until then it is   refused with 409 and `PARTNER_STORAGE_REQUIRED`, and when the destination cannot be used with 503 and   `STORAGE_DESTINATION_UNAVAILABLE`. A destination you remove after the session was made stops its   uploads too (the same 409; the browser is only told that the feature is not available right now).   Sessions without `files` need no destination: hand the editors your own media library instead   (`mediaLibrary`), and make them without it. - `editor`: edit one of this user\'s compositions: read it (`getCompositionById`, its content, design,   embed settings and schemas), check a content change (`validateCompositionContent`), and change its   name, content, design and embed settings (`updateComposition`, `setDynamicContent`). It can reach   only compositions you created for this managed user (tag them with `managedUserId` when you create   them); any other composition, including another of your users\', answers 404. - `creator`: use Widgetic\'s widget creator for this user, including its AI. Draw on canvases and save   them (`getAllCanvases`, `getCanvas`, `createCanvas`, `updateCanvas`, `previewDeleteCanvas`,   `deleteCanvas`); make, change, copy and delete the widgets on them (`createWidget`, `getWidgets`,   `getWidgetsBatch`, `updateWidget`, `uploadWidgetThumbnail`, `duplicateWidget`, `deleteWidget`);   list and make the compositions of a widget it built (`getAllCompositions`, `createComposition`), which   is how it shows the widget with sample values; read and add their   components (`getComponentsByWidgetId`, `createComponent`); keep the   conversation of each widget (`getConversationsByWidgetId`, `createConversationForWidget`,   `updateConversation`, `getMessages`, `createMessage`, `updateMessage`, `restoreCheckpoint`); and read a   widget\'s schemas and give it its repository (`getWidgetContentSchema`, `getWidgetDesignSchema`,   `updateWidgetRepository`). The AI that builds a widget is part of it: list the models   (`agentModelsGet`), open the widget\'s repository (`agentRepositoriesPost`,   `agentRepositoriesRepoIdGet`), start a generation and follow or cancel it (`agentCodeGeneratePost`,   `operationsStreamGet`, `operationsIdGet`, `operationsIdCancelPost`), build and preview the result   (`agentWidgetBuilderRepoHeadWidgetIdGet`, `buildWidgetFromRepo`, `previewWidgetVersion`), publish a   version of the widget and move between its versions (`agentWidgetBuilderPublishWidgetIdPost`,   `getWidgetPublishHistory`, `setWidgetPublishHistoryLive`, `renameWidgetPublishHistoryTitle`), and   turn a stroke or a sentence into a decision (`agentShapeRecognizePost`, `agentDesignResolvePost`). It can   also offer the customer your presets as starting points: read them and ask for a copy for this customer   (`listMyPresets`, `copyMyPreset`; you choose the presets with `setPartnerPreset`).   What the session makes is filed for this managed user, and the lists it reads hold only this user\'s   canvases, widgets and compositions. It can reach only canvases, widgets, compositions, repositories,   uploaded files and operations made for this managed user (tag the canvases and widgets you create   with `managedUserId`); any other canvas, widget, composition, conversation, message, repository, file   or operation, including another of your users\', answers 404. The creator also saves the composition   it is editing (`updateComposition`, from the `editor` surface) and attaches pictures to its chat   (`uploadsPost`, from the `files` surface), and the surfaces do not imply one another: to open the   whole creator for a user, ask for `creator`, `editor` and `files` together. A generation or a build   one user starts can be followed and cancelled by that user and by you, never by another of your   users. The AI is paid for by your account, as your own calls are: its credits and allowances are   yours. A session cannot make a widget public (publishing a version does not), file one under a   project or an organization, or set anything the creator does not set: a body with another field is   refused with 403 and `EDITOR_SESSION_FIELD_NOT_ALLOWED`.  Everything else is refused with 403 and `EDITOR_SESSION_ROUTE_NOT_ALLOWED`: a session cannot read your account, make more sessions, change your presets or delete a composition, and a session without the `creator` surface cannot create or list compositions. Create the composition yourself with your API key, then open the editor on it.  A session ends at `expiresAt` (at most four hours), when you end it (`revokeManagedUserEditorSession`), or when the managed user is switched off or deleted. A managed user can have at most 100 live sessions at once (`429 EDITOR_SESSION_LIMIT_REACHED`). A session that is bound to a web page (`allowed_origin`) is refused from any other origin.  The AI the session runs is paid for with your credits. Set `max_credits` to hold the session to a number of them: once its generations have taken that many (a generation that fails is refunded and does not count), the next one is refused with 402 and `EDITOR_SESSION_CREDIT_LIMIT_REACHED`, and the browser is told only that the feature is not available right now. Without it, the credits of your account are the only ceiling. What each of your users\' sessions has spent is in `getManagedUserUsage`.  Each call makes a new session. It does not take an `Idempotency-Key`: the answer holds the token, and the token is never stored where a retry could read it back. The answer is sent with `Cache-Control: no-store`.
+     * Create an editor session for a managed user
+     */
+    createManagedUserEditorSessionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling createManagedUserEditorSession().');
+            }
+            if (requestParameters['newEditorSession'] == null) {
+                throw new runtime.RequiredError('newEditorSession', 'Required parameter "newEditorSession" was null or undefined when calling createManagedUserEditorSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/editor-sessions`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: NewEditorSessionToJSON(requestParameters['newEditorSession']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => EditorSessionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Makes a short-lived credential that lets the browser of ONE of your managed users use Widgetic\'s editor pieces, such as the File Browser and the composition editor, without your API key ever reaching that browser. Call this from your server when the page that hosts the editor opens, and hand the `token` in the answer to that page.  The token is shown once. It starts with `wgt_ses_` and the browser sends it as `Authorization: Bearer <token>`. It can do only what the `surfaces` you name allow, and only for this managed user:  - `files`: upload a file (`uploadsPost`) and list the files uploaded for this user (`uploadsGet`). Every   file is filed for this user and stored in your own storage destination, never in Widgetic\'s: a file a   customer uploads is yours to keep, and takes none of your storage allowance. So a session with `files`   can be made only after you have set a destination (`setPartnerStorageDestination`); until then it is   refused with 409 and `PARTNER_STORAGE_REQUIRED`, and when the destination cannot be used with 503 and   `STORAGE_DESTINATION_UNAVAILABLE`. A destination you remove after the session was made stops its   uploads too (the same 409; the browser is only told that the feature is not available right now).   Sessions without `files` need no destination: hand the editors your own media library instead   (`mediaLibrary`), and make them without it. - `editor`: edit one of this user\'s compositions: read it (`getCompositionById`, its content, design,   embed settings and schemas), check a content change (`validateCompositionContent`), and change its   name, content, design and embed settings (`updateComposition`, `setDynamicContent`). It can reach   only compositions you created for this managed user (tag them with `managedUserId` when you create   them); any other composition, including another of your users\', answers 404. - `creator`: use Widgetic\'s widget creator for this user, including its AI. Draw on canvases and save   them (`getAllCanvases`, `getCanvas`, `createCanvas`, `updateCanvas`, `previewDeleteCanvas`,   `deleteCanvas`); make, change, copy and delete the widgets on them (`createWidget`, `getWidgets`,   `getWidgetsBatch`, `updateWidget`, `uploadWidgetThumbnail`, `duplicateWidget`, `deleteWidget`);   list and make the compositions of a widget it built (`getAllCompositions`, `createComposition`), which   is how it shows the widget with sample values; read and add their   components (`getComponentsByWidgetId`, `createComponent`); keep the   conversation of each widget (`getConversationsByWidgetId`, `createConversationForWidget`,   `updateConversation`, `getMessages`, `createMessage`, `updateMessage`, `restoreCheckpoint`); and read a   widget\'s schemas and give it its repository (`getWidgetContentSchema`, `getWidgetDesignSchema`,   `updateWidgetRepository`). The AI that builds a widget is part of it: list the models   (`agentModelsGet`), open the widget\'s repository (`agentRepositoriesPost`,   `agentRepositoriesRepoIdGet`), start a generation and follow or cancel it (`agentCodeGeneratePost`,   `operationsStreamGet`, `operationsIdGet`, `operationsIdCancelPost`), build and preview the result   (`agentWidgetBuilderRepoHeadWidgetIdGet`, `buildWidgetFromRepo`, `previewWidgetVersion`), publish a   version of the widget and move between its versions (`agentWidgetBuilderPublishWidgetIdPost`,   `getWidgetPublishHistory`, `setWidgetPublishHistoryLive`, `renameWidgetPublishHistoryTitle`), and   turn a stroke or a sentence into a decision (`agentShapeRecognizePost`, `agentDesignResolvePost`). It can   also offer the customer your presets as starting points: read them and ask for a copy for this customer   (`listMyPresets`, `copyMyPreset`; you choose the presets with `setPartnerPreset`).   What the session makes is filed for this managed user, and the lists it reads hold only this user\'s   canvases, widgets and compositions. It can reach only canvases, widgets, compositions, repositories,   uploaded files and operations made for this managed user (tag the canvases and widgets you create   with `managedUserId`); any other canvas, widget, composition, conversation, message, repository, file   or operation, including another of your users\', answers 404. The creator also saves the composition   it is editing (`updateComposition`, from the `editor` surface) and attaches pictures to its chat   (`uploadsPost`, from the `files` surface), and the surfaces do not imply one another: to open the   whole creator for a user, ask for `creator`, `editor` and `files` together. A generation or a build   one user starts can be followed and cancelled by that user and by you, never by another of your   users. The AI is paid for by your account, as your own calls are: its credits and allowances are   yours. A session cannot make a widget public (publishing a version does not), file one under a   project or an organization, or set anything the creator does not set: a body with another field is   refused with 403 and `EDITOR_SESSION_FIELD_NOT_ALLOWED`.  Everything else is refused with 403 and `EDITOR_SESSION_ROUTE_NOT_ALLOWED`: a session cannot read your account, make more sessions, change your presets or delete a composition, and a session without the `creator` surface cannot create or list compositions. Create the composition yourself with your API key, then open the editor on it.  A session ends at `expiresAt` (at most four hours), when you end it (`revokeManagedUserEditorSession`), or when the managed user is switched off or deleted. A managed user can have at most 100 live sessions at once (`429 EDITOR_SESSION_LIMIT_REACHED`). A session that is bound to a web page (`allowed_origin`) is refused from any other origin.  The AI the session runs is paid for with your credits. Set `max_credits` to hold the session to a number of them: once its generations have taken that many (a generation that fails is refunded and does not count), the next one is refused with 402 and `EDITOR_SESSION_CREDIT_LIMIT_REACHED`, and the browser is told only that the feature is not available right now. Without it, the credits of your account are the only ceiling. What each of your users\' sessions has spent is in `getManagedUserUsage`.  Each call makes a new session. It does not take an `Idempotency-Key`: the answer holds the token, and the token is never stored where a retry could read it back. The answer is sent with `Cache-Control: no-store`.
+     * Create an editor session for a managed user
+     */
+    createManagedUserEditorSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createManagedUserEditorSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Deletes a managed user by ID. Its editor sessions end with it. What was filed under it (compositions, widgets, uploads) stays in your account, untagged.
      * Delete Managed User
      */
     deleteManagedUserRaw(requestParameters, initOverrides) {
@@ -93,7 +216,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Deletes a managed user by ID.
+     * Deletes a managed user by ID. Its editor sessions end with it. What was filed under it (compositions, widgets, uploads) stays in your account, untagged.
      * Delete Managed User
      */
     deleteManagedUser(requestParameters, initOverrides) {
@@ -102,7 +225,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieve all managed users with pagination support.
+     * Retrieve the managed users you manage, with pagination support. (Admins see every partner\'s managed users.)
      * Get Managed Users
      */
     getAllManagedUsersRaw(requestParameters, initOverrides) {
@@ -135,7 +258,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieve all managed users with pagination support.
+     * Retrieve the managed users you manage, with pagination support. (Admins see every partner\'s managed users.)
      * Get Managed Users
      */
     getAllManagedUsers() {
@@ -181,6 +304,49 @@ export class ManagedUsersApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Says how many credits the editor sessions of one of your managed users took from your account over a period, in total and for each operation. A generation costs one credit, taken from your account when it starts; one that fails is refunded and is counted as refunded, not as spent.  Only what was spent through editor sessions is here, and only since usage was first recorded: what you spend with your API key, and anything from before, is not. Use it to see which of your users spend the most, or to charge them for it. To hold one session to a number of credits, set `max_credits` when you make it (`createManagedUserEditorSession`).  The period runs from `startDate` (included) to `endDate` (not included): the 30 days before now when you give neither, and at most 366 days. A date without a time is midnight UTC at the start of that day, so for all of October give `startDate=2026-10-01` and `endDate=2026-11-01`.
+     * What a managed user\'s editor sessions spent
+     */
+    getManagedUserUsageRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getManagedUserUsage().');
+            }
+            const queryParameters = {};
+            if (requestParameters['startDate'] != null) {
+                queryParameters['startDate'] = requestParameters['startDate'];
+            }
+            if (requestParameters['endDate'] != null) {
+                queryParameters['endDate'] = requestParameters['endDate'];
+            }
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/usage`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ManagedUserUsageFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Says how many credits the editor sessions of one of your managed users took from your account over a period, in total and for each operation. A generation costs one credit, taken from your account when it starts; one that fails is refunded and is counted as refunded, not as spent.  Only what was spent through editor sessions is here, and only since usage was first recorded: what you spend with your API key, and anything from before, is not. Use it to see which of your users spend the most, or to charge them for it. To hold one session to a number of credits, set `max_credits` when you make it (`createManagedUserEditorSession`).  The period runs from `startDate` (included) to `endDate` (not included): the 30 days before now when you give neither, and at most 366 days. A date without a time is midnight UTC at the start of that day, so for all of October give `startDate=2026-10-01` and `endDate=2026-11-01`.
+     * What a managed user\'s editor sessions spent
+     */
+    getManagedUserUsage(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getManagedUserUsageRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Retrieve managed users for a specific manager with pagination support.
      * Get Managed Users By Manager
@@ -214,7 +380,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => GetAllManagedUsers200ResponseFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetManagedUsersByManagerId200ResponseFromJSON(jsonValue));
         });
     }
     /**
@@ -228,7 +394,117 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Updates an existing managed user.
+     * Lists the presets your account offers (`setPartnerPreset`), as the picker in a customer\'s widget creator shows them: a key, a title, a description and a thumbnail, in the order you gave them. It is what the widget creator module reads when it opens with nothing of the customer\'s own yet.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session acts as your account and names the one customer it is for, so a customer reads only your presets, and nothing in the request chooses whose. Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: you read your own list with `listPartnerPresets`, which also tells you the widget behind each preset.
+     * The starting points a customer\'s editor session may copy
+     */
+    listMyPresetsRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/me/presets`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ListMyPresets200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Lists the presets your account offers (`setPartnerPreset`), as the picker in a customer\'s widget creator shows them: a key, a title, a description and a thumbnail, in the order you gave them. It is what the widget creator module reads when it opens with nothing of the customer\'s own yet.  Call it with an editor session (`createManagedUserEditorSession`, surface `creator`). The session acts as your account and names the one customer it is for, so a customer reads only your presets, and nothing in the request chooses whose. Called with your API key it is refused with 403 and `EDITOR_SESSION_REQUIRED`: you read your own list with `listPartnerPresets`, which also tells you the widget behind each preset.
+     * The starting points a customer\'s editor session may copy
+     */
+    listMyPresets(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.listMyPresetsRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Ends the session at once: its token stops working on the next request (on another server of ours, within a few seconds). Ending a session that has already ended is fine.
+     * End one editor session of a managed user
+     */
+    revokeManagedUserEditorSessionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling revokeManagedUserEditorSession().');
+            }
+            if (requestParameters['sessionId'] == null) {
+                throw new runtime.RequiredError('sessionId', 'Required parameter "sessionId" was null or undefined when calling revokeManagedUserEditorSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/editor-sessions/{sessionId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))).replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Ends the session at once: its token stops working on the next request (on another server of ours, within a few seconds). Ending a session that has already ended is fine.
+     * End one editor session of a managed user
+     */
+    revokeManagedUserEditorSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.revokeManagedUserEditorSessionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Ends all of the managed user\'s live editor sessions at once, for example when the user signs out of your platform. Their tokens stop working on the next request (on another server of ours, within a few seconds). It is fine to call it for a user who has none.
+     * End every editor session of a managed user
+     */
+    revokeManagedUserEditorSessionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling revokeManagedUserEditorSessions().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/editor-sessions`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => RevokeManagedUserEditorSessions200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Ends all of the managed user\'s live editor sessions at once, for example when the user signs out of your platform. Their tokens stop working on the next request (on another server of ours, within a few seconds). It is fine to call it for a user who has none.
+     * End every editor session of a managed user
+     */
+    revokeManagedUserEditorSessions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.revokeManagedUserEditorSessionsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Updates an existing managed user. Only `external_id`, `metadata` and `is_active` can change, and `metadata` is replaced as a whole, so send all of it. `is_active: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `is_active: true`. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The `Idempotency-Key` header is required (`400` without it).
      * Update Managed User
      */
     updateManagedUserRaw(requestParameters, initOverrides) {
@@ -260,7 +536,7 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Updates an existing managed user.
+     * Updates an existing managed user. Only `external_id`, `metadata` and `is_active` can change, and `metadata` is replaced as a whole, so send all of it. `is_active: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `is_active: true`. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The `Idempotency-Key` header is required (`400` without it).
      * Update Managed User
      */
     updateManagedUser(requestParameters, initOverrides) {