api-sdk-rb 1.11.66

data/docs/ManagedUsersApi.md

@@ -0,0 +1,1239 @@
+# ApiSdkRb::ManagedUsersApi
+
+All URIs are relative to *https://api.widgetic.com/v1*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**copy_preset_for_managed_user_0**](ManagedUsersApi.md#copy_preset_for_managed_user_0) | **POST** /managed-users/{id}/presets/{key}/copy | Give a managed user a copy of one of your presets |
+| [**create_composition_from_preset_0**](ManagedUsersApi.md#create_composition_from_preset_0) | **POST** /managed-users/{id}/presets/{key}/composition | Create a composition from one of your presets in one call |
+| [**create_managed_user_0**](ManagedUsersApi.md#create_managed_user_0) | **POST** /managed-users | Create Managed User |
+| [**create_managed_user_editor_session_0**](ManagedUsersApi.md#create_managed_user_editor_session_0) | **POST** /managed-users/{id}/editor-sessions | Create an editor session for a managed user |
+| [**delete_managed_user_0**](ManagedUsersApi.md#delete_managed_user_0) | **DELETE** /managed-users/{id} | Delete Managed User |
+| [**get_all_managed_users_0**](ManagedUsersApi.md#get_all_managed_users_0) | **GET** /managed-users | Get Managed Users |
+| [**get_managed_user_by_id_0**](ManagedUsersApi.md#get_managed_user_by_id_0) | **GET** /managed-users/{id} | Get Managed User By ID |
+| [**get_managed_user_design_defaults_0**](ManagedUsersApi.md#get_managed_user_design_defaults_0) | **GET** /managed-users/{id}/design-defaults | Read design defaults for one managed user |
+| [**get_managed_user_limits_0**](ManagedUsersApi.md#get_managed_user_limits_0) | **GET** /managed-users/{id}/limits | Read monthly credit cap and usage for one managed user |
+| [**get_managed_user_storage_usage_0**](ManagedUsersApi.md#get_managed_user_storage_usage_0) | **GET** /managed-users/{id}/storage-usage | Storage used by one managed user's uploads |
+| [**get_managed_user_usage_0**](ManagedUsersApi.md#get_managed_user_usage_0) | **GET** /managed-users/{id}/usage | What a managed user's editor sessions spent |
+| [**get_managed_users_by_manager_id_0**](ManagedUsersApi.md#get_managed_users_by_manager_id_0) | **GET** /users/{managerId}/managed-users | Get Managed Users By Manager |
+| [**revoke_managed_user_editor_session_0**](ManagedUsersApi.md#revoke_managed_user_editor_session_0) | **DELETE** /managed-users/{id}/editor-sessions/{sessionId} | End one editor session of a managed user |
+| [**revoke_managed_user_editor_sessions_0**](ManagedUsersApi.md#revoke_managed_user_editor_sessions_0) | **DELETE** /managed-users/{id}/editor-sessions | End every editor session of a managed user |
+| [**set_managed_user_design_defaults_0**](ManagedUsersApi.md#set_managed_user_design_defaults_0) | **PUT** /managed-users/{id}/design-defaults | Set or clear design defaults for one managed user |
+| [**set_managed_user_limits_0**](ManagedUsersApi.md#set_managed_user_limits_0) | **PUT** /managed-users/{id}/limits | Set or clear the monthly credit cap for one managed user |
+| [**update_managed_user_0**](ManagedUsersApi.md#update_managed_user_0) | **PUT** /managed-users/{id} | Update Managed User |
+
+
+## copy_preset_for_managed_user_0
+
+> <PartnerPresetCopyResponse> copy_preset_for_managed_user_0(id, key, idempotency_key, opts)
+
+Give a managed user a copy of one of your presets
+
+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. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The managed user to give the copy to (Widgetic's id for the user)
+key = 'key_example' # String | The key of the preset to copy
+idempotency_key = '9b2d6f0a-3c41-4e5a-8d77-1f2e3a4b5c6d' # String | Required: a call without it is refused with `400`. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, `-` and `_`. Send the same key again when you retry (after a timeout, a dropped connection or a `5xx`) and the call is carried out once: the retry gets the first answer back, marked `X-Idempotency-Cached: true`. The same key with a different body is refused with `422`, and a retry that arrives while the first call is still running with `409` (see `Retry-After`).
+opts = {
+  copy_partner_preset_request: ApiSdkRb::CopyPartnerPresetRequest.new # CopyPartnerPresetRequest | 
+}
+
+begin
+  # Give a managed user a copy of one of your presets
+  result = api_instance.copy_preset_for_managed_user_0(id, key, idempotency_key, opts)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->copy_preset_for_managed_user_0: #{e}"
+end
+```
+
+#### Using the copy_preset_for_managed_user_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<PartnerPresetCopyResponse>, Integer, Hash)> copy_preset_for_managed_user_0_with_http_info(id, key, idempotency_key, opts)
+
+```ruby
+begin
+  # Give a managed user a copy of one of your presets
+  data, status_code, headers = api_instance.copy_preset_for_managed_user_0_with_http_info(id, key, idempotency_key, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <PartnerPresetCopyResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->copy_preset_for_managed_user_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | The managed user to give the copy to (Widgetic&#39;s id for the user) |  |
+| **key** | **String** | The key of the preset to copy |  |
+| **idempotency_key** | **String** | Required: a call without it is refused with &#x60;400&#x60;. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, &#x60;-&#x60; and &#x60;_&#x60;. Send the same key again when you retry (after a timeout, a dropped connection or a &#x60;5xx&#x60;) and the call is carried out once: the retry gets the first answer back, marked &#x60;X-Idempotency-Cached: true&#x60;. The same key with a different body is refused with &#x60;422&#x60;, and a retry that arrives while the first call is still running with &#x60;409&#x60; (see &#x60;Retry-After&#x60;). |  |
+| **copy_partner_preset_request** | [**CopyPartnerPresetRequest**](CopyPartnerPresetRequest.md) |  | [optional] |
+
+### Return type
+
+[**PartnerPresetCopyResponse**](PartnerPresetCopyResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## create_composition_from_preset_0
+
+> <CreateCompositionFromWidget201Response> create_composition_from_preset_0(id, key, idempotency_key, create_composition_from_preset_request)
+
+Create a composition from one of your presets in one call
+
+Validates the name, optional content, design, embed settings and locale, then creates a draft composition filed under the managed user, built on the preset's widget, in a single insert. A failure never leaves a half-made composition.  The preset's widget must be published. The managed user must be yours and active.  A widget that keeps what visitors send (a form, a vote, a rating) declares its tables in its own source (`src/lib/meta/database.json`); they are made for the composition here, in a schema of its own, as the widget was when it was last published. A widget that keeps nothing leaves the composition without tables. If the tables cannot be made just now, or the widget's file cannot be used, the composition is still created (`201`) and `meta.warnings` says why; the tables are made the next time the widget is generated.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one composition is created, not two. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+key = 'key_example' # String | 
+idempotency_key = '9b2d6f0a-3c41-4e5a-8d77-1f2e3a4b5c6d' # String | Required: a call without it is refused with `400`. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, `-` and `_`. Send the same key again when you retry (after a timeout, a dropped connection or a `5xx`) and the call is carried out once: the retry gets the first answer back, marked `X-Idempotency-Cached: true`. The same key with a different body is refused with `422`, and a retry that arrives while the first call is still running with `409` (see `Retry-After`).
+create_composition_from_preset_request = ApiSdkRb::CreateCompositionFromPresetRequest.new({name: 'name_example'}) # CreateCompositionFromPresetRequest | 
+
+begin
+  # Create a composition from one of your presets in one call
+  result = api_instance.create_composition_from_preset_0(id, key, idempotency_key, create_composition_from_preset_request)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_composition_from_preset_0: #{e}"
+end
+```
+
+#### Using the create_composition_from_preset_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CreateCompositionFromWidget201Response>, Integer, Hash)> create_composition_from_preset_0_with_http_info(id, key, idempotency_key, create_composition_from_preset_request)
+
+```ruby
+begin
+  # Create a composition from one of your presets in one call
+  data, status_code, headers = api_instance.create_composition_from_preset_0_with_http_info(id, key, idempotency_key, create_composition_from_preset_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CreateCompositionFromWidget201Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_composition_from_preset_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **key** | **String** |  |  |
+| **idempotency_key** | **String** | Required: a call without it is refused with &#x60;400&#x60;. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, &#x60;-&#x60; and &#x60;_&#x60;. Send the same key again when you retry (after a timeout, a dropped connection or a &#x60;5xx&#x60;) and the call is carried out once: the retry gets the first answer back, marked &#x60;X-Idempotency-Cached: true&#x60;. The same key with a different body is refused with &#x60;422&#x60;, and a retry that arrives while the first call is still running with &#x60;409&#x60; (see &#x60;Retry-After&#x60;). |  |
+| **create_composition_from_preset_request** | [**CreateCompositionFromPresetRequest**](CreateCompositionFromPresetRequest.md) |  |  |
+
+### Return type
+
+[**CreateCompositionFromWidget201Response**](CreateCompositionFromWidget201Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## create_managed_user_0
+
+> <ManagedUserResponse> create_managed_user_0(idempotency_key, new_managed_user)
+
+Create Managed User
+
+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. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+idempotency_key = '9b2d6f0a-3c41-4e5a-8d77-1f2e3a4b5c6d' # String | Required: a call without it is refused with `400`. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, `-` and `_`. Send the same key again when you retry (after a timeout, a dropped connection or a `5xx`) and the call is carried out once: the retry gets the first answer back, marked `X-Idempotency-Cached: true`. The same key with a different body is refused with `422`, and a retry that arrives while the first call is still running with `409` (see `Retry-After`).
+new_managed_user = ApiSdkRb::NewManagedUser.new({external_id: 'external-user-123'}) # NewManagedUser | 
+
+begin
+  # Create Managed User
+  result = api_instance.create_managed_user_0(idempotency_key, new_managed_user)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_managed_user_0: #{e}"
+end
+```
+
+#### Using the create_managed_user_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ManagedUserResponse>, Integer, Hash)> create_managed_user_0_with_http_info(idempotency_key, new_managed_user)
+
+```ruby
+begin
+  # Create Managed User
+  data, status_code, headers = api_instance.create_managed_user_0_with_http_info(idempotency_key, new_managed_user)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ManagedUserResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_managed_user_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **idempotency_key** | **String** | Required: a call without it is refused with &#x60;400&#x60;. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, &#x60;-&#x60; and &#x60;_&#x60;. Send the same key again when you retry (after a timeout, a dropped connection or a &#x60;5xx&#x60;) and the call is carried out once: the retry gets the first answer back, marked &#x60;X-Idempotency-Cached: true&#x60;. The same key with a different body is refused with &#x60;422&#x60;, and a retry that arrives while the first call is still running with &#x60;409&#x60; (see &#x60;Retry-After&#x60;). |  |
+| **new_managed_user** | [**NewManagedUser**](NewManagedUser.md) |  |  |
+
+### Return type
+
+[**ManagedUserResponse**](ManagedUserResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## create_managed_user_editor_session_0
+
+> <EditorSessionResponse> create_managed_user_editor_session_0(id, new_editor_session)
+
+Create an editor session for a managed user
+
+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. Partner storage is not   optional, so no session, whatever its surfaces, can be made until 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). To keep a customer from uploading, leave `files` out of the   session and hand the editors your own media library instead (`mediaLibrary`). - `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; 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 (`allowedOrigin`) is refused from any other origin.  The AI the session runs is paid for with your credits. Set `maxCredits` 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 limit Widgetic has set for your account applies when it has set one (the same limit for every session you make, and `maxCredits: null` asks for none), and otherwise 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`. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The managed user the session is for (Widgetic's id for the user)
+new_editor_session = ApiSdkRb::NewEditorSession.new({surfaces: ["files", "editor"]}) # NewEditorSession | 
+
+begin
+  # Create an editor session for a managed user
+  result = api_instance.create_managed_user_editor_session_0(id, new_editor_session)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_managed_user_editor_session_0: #{e}"
+end
+```
+
+#### Using the create_managed_user_editor_session_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<EditorSessionResponse>, Integer, Hash)> create_managed_user_editor_session_0_with_http_info(id, new_editor_session)
+
+```ruby
+begin
+  # Create an editor session for a managed user
+  data, status_code, headers = api_instance.create_managed_user_editor_session_0_with_http_info(id, new_editor_session)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <EditorSessionResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->create_managed_user_editor_session_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | The managed user the session is for (Widgetic&#39;s id for the user) |  |
+| **new_editor_session** | [**NewEditorSession**](NewEditorSession.md) |  |  |
+
+### Return type
+
+[**EditorSessionResponse**](EditorSessionResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## delete_managed_user_0
+
+> <DeleteManagedUser200Response> delete_managed_user_0(id)
+
+Delete Managed User
+
+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.
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | ID of the managed user to delete
+
+begin
+  # Delete Managed User
+  result = api_instance.delete_managed_user_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->delete_managed_user_0: #{e}"
+end
+```
+
+#### Using the delete_managed_user_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<DeleteManagedUser200Response>, Integer, Hash)> delete_managed_user_0_with_http_info(id)
+
+```ruby
+begin
+  # Delete Managed User
+  data, status_code, headers = api_instance.delete_managed_user_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <DeleteManagedUser200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->delete_managed_user_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | ID of the managed user to delete |  |
+
+### Return type
+
+[**DeleteManagedUser200Response**](DeleteManagedUser200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_all_managed_users_0
+
+> <GetAllManagedUsers200Response> get_all_managed_users_0(opts)
+
+Get Managed Users
+
+Retrieve the managed users you manage, with pagination support. (Admins see every partner's managed users.)
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+opts = {
+  page: 56, # Integer | Page number for pagination
+  size: 56, # Integer | Number of items per page
+  sort: 'sort_example' # String | Sort field and direction, `<field>:<asc|desc>`. The field is `createdAt`, `updatedAt` or `externalId` (the snake_case spellings `created_at`, `updated_at` and `external_id` work too); `asc` or `desc` alone sorts by `createdAt`. Any other field is a 400.
+}
+
+begin
+  # Get Managed Users
+  result = api_instance.get_all_managed_users_0(opts)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_all_managed_users_0: #{e}"
+end
+```
+
+#### Using the get_all_managed_users_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetAllManagedUsers200Response>, Integer, Hash)> get_all_managed_users_0_with_http_info(opts)
+
+```ruby
+begin
+  # Get Managed Users
+  data, status_code, headers = api_instance.get_all_managed_users_0_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetAllManagedUsers200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_all_managed_users_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **page** | **Integer** | Page number for pagination | [optional][default to 1] |
+| **size** | **Integer** | Number of items per page | [optional][default to 10] |
+| **sort** | **String** | Sort field and direction, &#x60;&lt;field&gt;:&lt;asc|desc&gt;&#x60;. The field is &#x60;createdAt&#x60;, &#x60;updatedAt&#x60; or &#x60;externalId&#x60; (the snake_case spellings &#x60;created_at&#x60;, &#x60;updated_at&#x60; and &#x60;external_id&#x60; work too); &#x60;asc&#x60; or &#x60;desc&#x60; alone sorts by &#x60;createdAt&#x60;. Any other field is a 400. | [optional][default to &#39;createdAt:desc&#39;] |
+
+### Return type
+
+[**GetAllManagedUsers200Response**](GetAllManagedUsers200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_user_by_id_0
+
+> <ManagedUserResponse> get_managed_user_by_id_0(id)
+
+Get Managed User By ID
+
+Retrieves a specific managed user by ID.
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | ID of the managed user to retrieve
+
+begin
+  # Get Managed User By ID
+  result = api_instance.get_managed_user_by_id_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_by_id_0: #{e}"
+end
+```
+
+#### Using the get_managed_user_by_id_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ManagedUserResponse>, Integer, Hash)> get_managed_user_by_id_0_with_http_info(id)
+
+```ruby
+begin
+  # Get Managed User By ID
+  data, status_code, headers = api_instance.get_managed_user_by_id_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ManagedUserResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_by_id_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | ID of the managed user to retrieve |  |
+
+### Return type
+
+[**ManagedUserResponse**](ManagedUserResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_user_design_defaults_0
+
+> <GetPartnerDesignDefaults200Response> get_managed_user_design_defaults_0(id)
+
+Read design defaults for one managed user
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+
+begin
+  # Read design defaults for one managed user
+  result = api_instance.get_managed_user_design_defaults_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_design_defaults_0: #{e}"
+end
+```
+
+#### Using the get_managed_user_design_defaults_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetPartnerDesignDefaults200Response>, Integer, Hash)> get_managed_user_design_defaults_0_with_http_info(id)
+
+```ruby
+begin
+  # Read design defaults for one managed user
+  data, status_code, headers = api_instance.get_managed_user_design_defaults_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetPartnerDesignDefaults200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_design_defaults_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**GetPartnerDesignDefaults200Response**](GetPartnerDesignDefaults200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_user_limits_0
+
+> <GetManagedUserLimits200Response> get_managed_user_limits_0(id)
+
+Read monthly credit cap and usage for one managed user
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+
+begin
+  # Read monthly credit cap and usage for one managed user
+  result = api_instance.get_managed_user_limits_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_limits_0: #{e}"
+end
+```
+
+#### Using the get_managed_user_limits_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetManagedUserLimits200Response>, Integer, Hash)> get_managed_user_limits_0_with_http_info(id)
+
+```ruby
+begin
+  # Read monthly credit cap and usage for one managed user
+  data, status_code, headers = api_instance.get_managed_user_limits_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetManagedUserLimits200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_limits_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**GetManagedUserLimits200Response**](GetManagedUserLimits200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_user_storage_usage_0
+
+> <GetManagedUserStorageUsage200Response> get_managed_user_storage_usage_0(id)
+
+Storage used by one managed user's uploads
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+
+begin
+  # Storage used by one managed user's uploads
+  result = api_instance.get_managed_user_storage_usage_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_storage_usage_0: #{e}"
+end
+```
+
+#### Using the get_managed_user_storage_usage_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetManagedUserStorageUsage200Response>, Integer, Hash)> get_managed_user_storage_usage_0_with_http_info(id)
+
+```ruby
+begin
+  # Storage used by one managed user's uploads
+  data, status_code, headers = api_instance.get_managed_user_storage_usage_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetManagedUserStorageUsage200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_storage_usage_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**GetManagedUserStorageUsage200Response**](GetManagedUserStorageUsage200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_user_usage_0
+
+> <ManagedUserUsageResponse> get_managed_user_usage_0(id, opts)
+
+What a managed user's editor sessions spent
+
+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`. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The managed user whose usage you want (Widgetic's id for the user)
+opts = {
+  start_date: 'start_date_example', # String | Start of the period, included: an ISO 8601 date (`2026-10-01`) or date-time with its offset (`2026-10-01T08:00:00Z`). Default: 30 days before `endDate`. 
+  end_date: 'end_date_example' # String | End of the period, not included, in the same forms. Default: now. It must be after `startDate`, by at most 366 days. 
+}
+
+begin
+  # What a managed user's editor sessions spent
+  result = api_instance.get_managed_user_usage_0(id, opts)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_usage_0: #{e}"
+end
+```
+
+#### Using the get_managed_user_usage_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ManagedUserUsageResponse>, Integer, Hash)> get_managed_user_usage_0_with_http_info(id, opts)
+
+```ruby
+begin
+  # What a managed user's editor sessions spent
+  data, status_code, headers = api_instance.get_managed_user_usage_0_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ManagedUserUsageResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_user_usage_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | The managed user whose usage you want (Widgetic&#39;s id for the user) |  |
+| **start_date** | **String** | Start of the period, included: an ISO 8601 date (&#x60;2026-10-01&#x60;) or date-time with its offset (&#x60;2026-10-01T08:00:00Z&#x60;). Default: 30 days before &#x60;endDate&#x60;.  | [optional] |
+| **end_date** | **String** | End of the period, not included, in the same forms. Default: now. It must be after &#x60;startDate&#x60;, by at most 366 days.  | [optional] |
+
+### Return type
+
+[**ManagedUserUsageResponse**](ManagedUserUsageResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## get_managed_users_by_manager_id_0
+
+> <GetManagedUsersByManagerIdResponse> get_managed_users_by_manager_id_0(manager_id, opts)
+
+Get Managed Users By Manager
+
+Retrieve managed users for a specific manager with pagination support.
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+manager_id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | ID of the manager
+opts = {
+  page: 56, # Integer | Page number for pagination
+  size: 56, # Integer | Number of items per page
+  sort: 'sort_example' # String | Sort field and direction, `<field>:<asc|desc>`. The field is `createdAt`, `updatedAt` or `externalId` (the snake_case spellings `created_at`, `updated_at` and `external_id` work too); `asc` or `desc` alone sorts by `createdAt`. Any other field is a 400.
+}
+
+begin
+  # Get Managed Users By Manager
+  result = api_instance.get_managed_users_by_manager_id_0(manager_id, opts)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_users_by_manager_id_0: #{e}"
+end
+```
+
+#### Using the get_managed_users_by_manager_id_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetManagedUsersByManagerIdResponse>, Integer, Hash)> get_managed_users_by_manager_id_0_with_http_info(manager_id, opts)
+
+```ruby
+begin
+  # Get Managed Users By Manager
+  data, status_code, headers = api_instance.get_managed_users_by_manager_id_0_with_http_info(manager_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetManagedUsersByManagerIdResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->get_managed_users_by_manager_id_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **manager_id** | **String** | ID of the manager |  |
+| **page** | **Integer** | Page number for pagination | [optional][default to 1] |
+| **size** | **Integer** | Number of items per page | [optional][default to 10] |
+| **sort** | **String** | Sort field and direction, &#x60;&lt;field&gt;:&lt;asc|desc&gt;&#x60;. The field is &#x60;createdAt&#x60;, &#x60;updatedAt&#x60; or &#x60;externalId&#x60; (the snake_case spellings &#x60;created_at&#x60;, &#x60;updated_at&#x60; and &#x60;external_id&#x60; work too); &#x60;asc&#x60; or &#x60;desc&#x60; alone sorts by &#x60;createdAt&#x60;. Any other field is a 400. | [optional][default to &#39;createdAt:desc&#39;] |
+
+### Return type
+
+[**GetManagedUsersByManagerIdResponse**](GetManagedUsersByManagerIdResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## revoke_managed_user_editor_session_0
+
+> <DeleteManagedUser200Response> revoke_managed_user_editor_session_0(id, session_id)
+
+End one editor session of a managed user
+
+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. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The managed user the session is for
+session_id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The `sessionId` of the session, from `createManagedUserEditorSession`
+
+begin
+  # End one editor session of a managed user
+  result = api_instance.revoke_managed_user_editor_session_0(id, session_id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->revoke_managed_user_editor_session_0: #{e}"
+end
+```
+
+#### Using the revoke_managed_user_editor_session_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<DeleteManagedUser200Response>, Integer, Hash)> revoke_managed_user_editor_session_0_with_http_info(id, session_id)
+
+```ruby
+begin
+  # End one editor session of a managed user
+  data, status_code, headers = api_instance.revoke_managed_user_editor_session_0_with_http_info(id, session_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <DeleteManagedUser200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->revoke_managed_user_editor_session_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | The managed user the session is for |  |
+| **session_id** | **String** | The &#x60;sessionId&#x60; of the session, from &#x60;createManagedUserEditorSession&#x60; |  |
+
+### Return type
+
+[**DeleteManagedUser200Response**](DeleteManagedUser200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## revoke_managed_user_editor_sessions_0
+
+> <RevokeManagedUserEditorSessionsResponse> revoke_managed_user_editor_sessions_0(id)
+
+End every editor session of a managed user
+
+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. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | The managed user whose sessions end
+
+begin
+  # End every editor session of a managed user
+  result = api_instance.revoke_managed_user_editor_sessions_0(id)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->revoke_managed_user_editor_sessions_0: #{e}"
+end
+```
+
+#### Using the revoke_managed_user_editor_sessions_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<RevokeManagedUserEditorSessionsResponse>, Integer, Hash)> revoke_managed_user_editor_sessions_0_with_http_info(id)
+
+```ruby
+begin
+  # End every editor session of a managed user
+  data, status_code, headers = api_instance.revoke_managed_user_editor_sessions_0_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <RevokeManagedUserEditorSessionsResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->revoke_managed_user_editor_sessions_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | The managed user whose sessions end |  |
+
+### Return type
+
+[**RevokeManagedUserEditorSessionsResponse**](RevokeManagedUserEditorSessionsResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## set_managed_user_design_defaults_0
+
+> <GetPartnerDesignDefaults200Response> set_managed_user_design_defaults_0(id, set_partner_design_defaults_request)
+
+Set or clear design defaults for one managed user
+
+Send `{ \"design\": { ... } }` to store a JSON object (at most 64 KB, nesting depth 32), or `{ \"design\": null }` to remove the override. New compositions for this customer merge this layer over the partner default and under the request body. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+set_partner_design_defaults_request = ApiSdkRb::SetPartnerDesignDefaultsRequest.new({design: 3.56}) # SetPartnerDesignDefaultsRequest | 
+
+begin
+  # Set or clear design defaults for one managed user
+  result = api_instance.set_managed_user_design_defaults_0(id, set_partner_design_defaults_request)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->set_managed_user_design_defaults_0: #{e}"
+end
+```
+
+#### Using the set_managed_user_design_defaults_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetPartnerDesignDefaults200Response>, Integer, Hash)> set_managed_user_design_defaults_0_with_http_info(id, set_partner_design_defaults_request)
+
+```ruby
+begin
+  # Set or clear design defaults for one managed user
+  data, status_code, headers = api_instance.set_managed_user_design_defaults_0_with_http_info(id, set_partner_design_defaults_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetPartnerDesignDefaults200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->set_managed_user_design_defaults_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **set_partner_design_defaults_request** | [**SetPartnerDesignDefaultsRequest**](SetPartnerDesignDefaultsRequest.md) |  |  |
+
+### Return type
+
+[**GetPartnerDesignDefaults200Response**](GetPartnerDesignDefaults200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## set_managed_user_limits_0
+
+> <GetManagedUserLimits200Response> set_managed_user_limits_0(id, set_managed_user_limits_request)
+
+Set or clear the monthly credit cap for one managed user
+
+Send monthlyCredits as a whole number from 0 up to 2147483647 to cap what this customer's editor sessions may spend in a UTC calendar month, or null to remove the cap. The cap counts the credits the customer's sessions spent that month (refunded credits do not count) and applies to all of the customer's sessions together, beside any `max_credits` a single session was given. A cap of 0 stops all paid work by this customer until you raise it. The cap starts counting from the first of the month (UTC); a cap set below what was already spent this month stops further work at once. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | 
+set_managed_user_limits_request = ApiSdkRb::SetManagedUserLimitsRequest.new({monthly_credits: 37}) # SetManagedUserLimitsRequest | 
+
+begin
+  # Set or clear the monthly credit cap for one managed user
+  result = api_instance.set_managed_user_limits_0(id, set_managed_user_limits_request)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->set_managed_user_limits_0: #{e}"
+end
+```
+
+#### Using the set_managed_user_limits_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<GetManagedUserLimits200Response>, Integer, Hash)> set_managed_user_limits_0_with_http_info(id, set_managed_user_limits_request)
+
+```ruby
+begin
+  # Set or clear the monthly credit cap for one managed user
+  data, status_code, headers = api_instance.set_managed_user_limits_0_with_http_info(id, set_managed_user_limits_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <GetManagedUserLimits200Response>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->set_managed_user_limits_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **set_managed_user_limits_request** | [**SetManagedUserLimitsRequest**](SetManagedUserLimitsRequest.md) |  |  |
+
+### Return type
+
+[**GetManagedUserLimits200Response**](GetManagedUserLimits200Response.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## update_managed_user_0
+
+> <ManagedUserResponse> update_managed_user_0(id, idempotency_key, update_managed_user)
+
+Update Managed User
+
+Updates an existing managed user. Only `externalId`, `metadata` and `isActive` can change, and `metadata` is replaced as a whole, so send all of it. `isActive: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `isActive: 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). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'api-sdk-rb'
+# setup authorization
+ApiSdkRb.configure do |config|
+  # Configure Bearer authorization (JWT): apiKeyAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = ApiSdkRb::ManagedUsersApi.new
+id = '38400000-8cf0-11bd-b23e-10b96e4ef00d' # String | ID of the managed user to update
+idempotency_key = '9b2d6f0a-3c41-4e5a-8d77-1f2e3a4b5c6d' # String | Required: a call without it is refused with `400`. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, `-` and `_`. Send the same key again when you retry (after a timeout, a dropped connection or a `5xx`) and the call is carried out once: the retry gets the first answer back, marked `X-Idempotency-Cached: true`. The same key with a different body is refused with `422`, and a retry that arrives while the first call is still running with `409` (see `Retry-After`).
+update_managed_user = ApiSdkRb::UpdateManagedUser.new # UpdateManagedUser | 
+
+begin
+  # Update Managed User
+  result = api_instance.update_managed_user_0(id, idempotency_key, update_managed_user)
+  p result
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->update_managed_user_0: #{e}"
+end
+```
+
+#### Using the update_managed_user_0_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ManagedUserResponse>, Integer, Hash)> update_managed_user_0_with_http_info(id, idempotency_key, update_managed_user)
+
+```ruby
+begin
+  # Update Managed User
+  data, status_code, headers = api_instance.update_managed_user_0_with_http_info(id, idempotency_key, update_managed_user)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ManagedUserResponse>
+rescue ApiSdkRb::ApiError => e
+  puts "Error when calling ManagedUsersApi->update_managed_user_0_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** | ID of the managed user to update |  |
+| **idempotency_key** | **String** | Required: a call without it is refused with &#x60;400&#x60;. A key of your own that names this one request; a UUID is ideal. It is 8 to 50 characters of letters, digits, &#x60;-&#x60; and &#x60;_&#x60;. Send the same key again when you retry (after a timeout, a dropped connection or a &#x60;5xx&#x60;) and the call is carried out once: the retry gets the first answer back, marked &#x60;X-Idempotency-Cached: true&#x60;. The same key with a different body is refused with &#x60;422&#x60;, and a retry that arrives while the first call is still running with &#x60;409&#x60; (see &#x60;Retry-After&#x60;). |  |
+| **update_managed_user** | [**UpdateManagedUser**](UpdateManagedUser.md) |  |  |
+
+### Return type
+
+[**ManagedUserResponse**](ManagedUserResponse.md)
+
+### Authorization
+
+[apiKeyAuth](../README.md#apiKeyAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+