api-sdk-rb 1.11.66

data/spec/api/partner_api_spec.rb

@@ -0,0 +1,1895 @@
+=begin
+#Widgetic API Gateway
+
+#API documentation for the Widgetic API Gateway
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.9.0
+
+=end
+
+require 'spec_helper'
+require 'json'
+
+# Unit tests for ApiSdkRb::PartnerApi
+# Automatically generated by openapi-generator (https://openapi-generator.tech)
+# Please update as you see appropriate
+describe 'PartnerApi' do
+  before do
+    # run before each test
+    @api_instance = ApiSdkRb::PartnerApi.new
+  end
+
+  after do
+    # run after each test
+  end
+
+  describe 'test an instance of PartnerApi' do
+    it 'should create an instance of PartnerApi' do
+      expect(@api_instance).to be_instance_of(ApiSdkRb::PartnerApi)
+    end
+  end
+
+  # unit tests for add_ai_answers_knowledge_document
+  # Add a document for a widget's AI to answer from
+  # Gives the widget's AI a document to answer visitors' questions from. Send the title and the plain text. The call returns once the document is ready to be used, which takes a few seconds, longer for a long text.  **How it is used.** The text is cleaned, cut into short passages and each passage is turned into numbers (an embedding) so the widget can find the passages nearest to a question. When a visitor asks, the nearest passages and the question are shown to an AI model, which writes the answer from them and from nothing else; if the documents say nothing about the question the visitor is told so, and the owner is not charged for that question. The titles of the documents an answer used are shown to the visitor as its sources.  **What leaves Widgetic.** The text of a document is sent to OpenAI to be embedded when it is added, and the passages used for a question are sent to the AI model that writes the answer. Say so in your privacy policy.  **Treat every document as public.** An answer can quote or paraphrase anything a document says, to any visitor of the widget. Do not add passwords, keys, personal data or anything that must stay private.  **Limits.** A widget holds up to 20 documents, each up to 100000 characters, and up to 400000 characters in all (`getAiAnswersKnowledge` reports the current numbers). Text only: convert PDF or Word files to text first. Adding a document costs no credits. The same text cannot be added twice to one widget (409).  The caller must be allowed to change the widget. An API key needs the `content:write` scope. Adds are limited to ten in ten minutes per person. 
+  # @param id The widget (composition) to add the document to
+  # @param add_ai_answers_knowledge_document_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [AddAiAnswersKnowledgeDocument201Response]
+  describe 'add_ai_answers_knowledge_document test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for add_personal_workspace_domain
+  # Allow a website to show your widgets
+  # Adds a website to an account's own list. Give a website name such as `example.com`, or `*.example.com` for a website and all of its subdomains. A scheme, a port, a path, capital letters and a leading `www.` are dropped, so `https://www.Example.com/shop` is kept as `example.com`, and `example.com` covers `www.example.com` too. Something that is not a website name is refused, not stored. Until the first website is added nothing is restricted, and a widget can be shown anywhere. Once the list has one, a widget of the account is shown on the listed websites (and on Widgetic's own) and nowhere else. A page on your own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed, so there is nothing to add to test locally. So is the website where a partner your account administers integrates Widgetic, with every subdomain of it (`platformDomain` in the answer of `GET /partners/mine`), so there is nothing to add for it either and a list can never lock it out. A change can take about 15 seconds to reach every server. The list is a safeguard against other websites showing your widgets in a visitor's browser. It is not access control: anyone who knows a widget's id can still fetch its published content with a plain request that names no website. There is no limit on the list of an account that administers a partner, so a partner can add the website of each of its customers as they publish on their own domain, one call each. Any other account can list at most 50 websites, and the 51st is answered with a 409 (`BUSINESS_STATE_CONFLICT`). A wildcard such as `*.example.com` counts as one website, not one per subdomain, so use it instead of listing each subdomain. A page that frames a widget can name only so many websites to the browser (about fifty of ordinary length). Past that, the browser no longer checks the list for that page; the lookup that the Embed SDK makes for the widget still refuses every website that is not on the list.
+  # @param id The account the list belongs to. For your own, your own user id
+  # @param add_domain_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PersonalWorkspaceDomainResultResponse]
+  describe 'add_personal_workspace_domain test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for call_public_composition_adapter
+  # Call a gateway operation of an adapter a published widget uses
+  # The door a widget's adapter module calls, from the visitor's browser, for the operations that cannot run in the browser: anything with a secret, a charge in credits or the owner's storage behind it. A widget that uses such an adapter is handed the address of this route as `adapters.url` in its `widgetic:host` message (see the host bridge contract) and calls `{adapters.url}/{adapterId}/{operation}`. It is not meant to be called by hand, and it takes no API key. **Address.** `https://api.widgetic.com/embed/compositions/{compositionId}/adapters/{adapterId}/{operation}`: the root of the API host, NOT under `/v1`. A client generated from this description for `https://api.widgetic.com/v1` must be given the base address `https://api.widgetic.com` for the calls of the `Public Embed` tag. **What it serves.** Only an adapter, and a version of it, that the widget's LIVE manifest (what the version that is published uses) lists, and only an operation that runs on the gateway. Anything else is one 404 `ADAPTER_NOT_AVAILABLE`, whatever the reason, so the route is no way to ask what a widget contains. An adapter an administrator stopped offering to NEW widgets keeps serving the widgets that already use it. **Who may call.** The same rule as the entry route: a permitted `Origin` header, which is the artifact origin the widget runs from or a website the owner allowed (or the owner's own platform). Page script cannot forge it. A request without a permitted `Origin` is 403 `ORIGIN_NOT_ALLOWED`. A composition that is not served (unpublished, or its owner's plan does not serve it) is 404, with the codes of the other public embed routes. When the partner of the owner signs the host context, a context that is not signed as the partner requires is refused with 403 `CONTEXT_SIGNATURE_REQUIRED`, `CONTEXT_SIGNATURE_INVALID` or `CONTEXT_SIGNATURE_EXPIRED`. **Cost and retries.** An operation priced in credits is charged to the owner of the widget (for a customer a partner manages, to the partner's administrator, within the monthly credits set for that customer), once for each `requestId`, before it runs, and given back if it does not answer. A `requestId` that was charged and not given back is 409 `REQUEST_ALREADY_USED` and the operation is NOT run a second time; one whose charge was given back may be tried again with the same `requestId`. A visitor never sees an owner's balance: a feature that cannot be used because its owner has no credits left, because the customer's monthly credits are spent, or because an administrator stopped the adapter, is the same 503 `ADAPTER_UNAVAILABLE` as every other \"not right now\". The owner is told through a notice. **Limits.** In front of everything, 120 calls a minute for each visitor address and composition and 600 a minute for a composition (429 `RATE_LIMITED`). Then, for each operation of a widget, a rate for each visitor address a minute and a cap for the widget a day: 30 and 5000 for an operation that is free, 10 and 500 for one that costs credits, unless the adapter says otherwise (never above 120 and 100000). A visitor over the rate is 429 `RATE_LIMITED`; a widget over its cap is 429 `WIDGET_LIMIT_REACHED`. Both carry a `Retry-After` header. The body is at most 64 KiB (413 `PAYLOAD_TOO_LARGE`) and JSON (415 `UNSUPPORTED_MEDIA_TYPE`); an operation has 30 seconds to answer (504 `ADAPTER_TIMEOUT`, and the charge is given back).
+  # @param composition_id 
+  # @param adapter_id The id of the adapter, the name its module is known by, for example `upload`.
+  # @param operation The name of one operation of the adapter, as its documentation gives it.
+  # @param public_adapter_call_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PublicAdapterCallResult]
+  describe 'call_public_composition_adapter test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for check_composition_access
+  # Check Composition Access
+  # Checks if the authenticated user can access a specific composition based on workspace context and permissions.
+  # @param id Composition ID
+  # @param [Hash] opts the optional parameters
+  # @return [CheckCompositionAccessResponse]
+  describe 'check_composition_access test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for copy_preset_for_managed_user
+  # 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. 
+  # @param id The managed user to give the copy to (Widgetic's id for the user)
+  # @param key The key of the preset to copy
+  # @param idempotency_key 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`).
+  # @param [Hash] opts the optional parameters
+  # @option opts [CopyPartnerPresetRequest] :copy_partner_preset_request 
+  # @return [PartnerPresetCopyResponse]
+  describe 'copy_preset_for_managed_user test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_canvas
+  # Create Canvas
+  # Creates a new canvas with the specified properties.  To make the canvas for one of your managed users, send `managedUserId` or `managedUserExternalId`. The canvas stays in your account and is yours to edit; the tag lets you list one user's canvases with `getAllCanvases`. The managed user must be yours and active: one that is not yours, or does not exist, is answered with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`. The tag is set here and does not change afterwards. Called with an editor session, the canvas is always made for the session's managed user. 
+  # @param create_canvas_request 
+  # @param [Hash] opts the optional parameters
+  # @return [CanvasResponse]
+  describe 'create_canvas test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_composition
+  # Create Composition
+  # Creates a new composition.  To make the composition for one of your managed users, send `managedUserId` or `managedUserExternalId`. The composition stays in your account and is yours to edit; the tag lets you list one user's compositions with `getAllCompositions`. The managed user must be yours and active: one that is not yours, or does not exist, is answered with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`. The tag is set here and does not change afterwards. A copy made with `duplicateComposition` keeps the tag of the original.  An editor session with the `creator` surface may call this to start a composition of a widget it built: it sends only `name`, `widgetId` (a widget made for the session's managed user) and `content`, and the composition is always made for that managed user.  Send `databaseSchema` to give the composition tables of its own for what visitors send it (the shape, the allowed types and the limits are described on the field). A `databaseSchema` that cannot be used is refused before anything is created, with `400` and `INVALID_DATABASE_SCHEMA`. If the composition is created but its tables cannot be made just now, the answer is still `201` and `meta.warnings` says so.  Leave `databaseSchema` out and the composition gets the tables its widget declares in its own source (`src/lib/meta/database.json`), if it declares any: they are made the same way, in a schema of the composition's own. A widget that keeps nothing leaves the composition without tables. If the widget's file cannot be used, or its tables cannot be made just now, the answer is still `201` and `meta.warnings` says so. The widget is read as it was when it was last published (as it is now, when it never was).  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one composition is created, not two. 
+  # @param idempotency_key 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`).
+  # @param new_composition 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [CreateCompositionFromWidget201Response]
+  describe 'create_composition test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_composition_content_item
+  # Add a content list item
+  # Creates one item in a widget content list without replacing the whole list. Item field keys are widget data (camelCase or snake_case are kept as sent). Partners use this to keep galleries in sync.
+  # @param id 
+  # @param list List name from the content schema (`contentItems`) or `items`
+  # @param idempotency_key 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`).
+  # @param create_composition_content_item_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :if_match Optional content version from ETag
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [CreateCompositionContentItem201Response]
+  describe 'create_composition_content_item test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_composition_database_record
+  # Create Record In Composition Database
+  # Creates a new record in one of the composition's tables. Only the composition's own tables (made from its `databaseSchema` or from the tables its widget declares) can be reached; any other table name answers `404`.
+  # @param id ID of the composition
+  # @param table Name of the database table
+  # @param idempotency_key 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`).
+  # @param body 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [CreateCompositionDatabaseRecord201Response]
+  describe 'create_composition_database_record test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_composition_from_preset
+  # 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. 
+  # @param id 
+  # @param key 
+  # @param idempotency_key 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`).
+  # @param create_composition_from_preset_request 
+  # @param [Hash] opts the optional parameters
+  # @return [CreateCompositionFromWidget201Response]
+  describe 'create_composition_from_preset test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_composition_from_widget
+  # Create a composition for a widget in one call
+  # After a managed user publishes a widget from the creator, call this with the widget id, the customer's managed user (when the widget is not already filed under one), and optional content, design, embed settings and locale. Every input is validated before a single insert; a failure never leaves a half-made composition.  When the widget is already tagged with a managed user, you may omit `managedUserId`. When you send it, it must match that tag.  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 widget must be published. The `Idempotency-Key` header is required. 
+  # @param id The widget id
+  # @param idempotency_key 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`).
+  # @param create_composition_from_widget_request 
+  # @param [Hash] opts the optional parameters
+  # @return [CreateCompositionFromWidget201Response]
+  describe 'create_composition_from_widget test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_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. 
+  # @param idempotency_key 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`).
+  # @param new_managed_user 
+  # @param [Hash] opts the optional parameters
+  # @return [ManagedUserResponse]
+  describe 'create_managed_user test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_managed_user_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`. 
+  # @param id The managed user the session is for (Widgetic's id for the user)
+  # @param new_editor_session 
+  # @param [Hash] opts the optional parameters
+  # @return [EditorSessionResponse]
+  describe 'create_managed_user_editor_session test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_partner_extra_credits_invoice
+  # Buy extra credits for a partner
+  # Asks Widgetic for an invoice for extra credits, on top of the credits of the contract. Name the dollars; the invoice is for the most whole credits they buy at the **list price** of a credit (the price a contract may lower belongs to the contract), so it is never for more than you asked: 12.34 buys 123 credits and the invoice says 12.30. The smallest purchase is 10 dollars and one request buys at most 100000 (ask Widgetic for an invoice for more).  Pay the invoice with the link in the answer. When it is paid the credits are added **once, for good**, to the account of the person who administers the partner, which is the account everything the partner builds is charged to (`getPartnerCreditBalance` shows it). Extra credits **do not expire**, unlike the credits of a contract period, which end with it. Nothing is added before the invoice is paid, and an unpaid invoice for extra credits never stops the partner: only an unpaid invoice of the contract does (`payment_arrears`).  Allowed whatever the partner's standing: a partner that has run out of credits, or is stopped for an unpaid contract invoice, can still buy. No contract is needed.  An `Idempotency-Key` is required, and it is what makes a retry safe: the same key with the same body returns the invoice already issued, the same key with a different body is refused with 422, and a duplicate that arrives while the first is still running is refused with 409. Use one key per purchase you mean to make, and a new key for the next one. At most 10 requests an hour.  Who may ask: the person who administers the partner, or a Widgetic administrator. A key limited to scopes needs `billing:write`. 
+  # @param partner_id Partner ID
+  # @param idempotency_key A key of your own for this purchase, so that a retry cannot make a second invoice
+  # @param request_extra_credits 
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerExtraCreditsInvoiceResponse]
+  describe 'create_partner_extra_credits_invoice test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_public_composition_entry
+  # Append a visitor entry through the gateway
+  # Public append-only write into a published composition database. No API key. The browser must send a permitted `Origin` header (the artifact iframe origin or a website the owner allowed). When the request comes from the shared artifact origin, it must also carry the per-composition write token (`X-Widgetic-Write-Token` header or `writeToken` body field, handed to the widget in `widgetic:host` as `entries.writeToken` and returned as `entryWriteToken` on `getPublicCompositionEmbed`). Host `context` is stored for partner attribution; it is not authenticated unless the partner signs it (see **Signed context**). Request bodies are limited to 16 KB before parsing. **Address.** `https://api.widgetic.com/embed/compositions/{compositionId}/entries/{table}`: the root of the API host, NOT under `/v1`. A client generated from this description for `https://api.widgetic.com/v1` must be given the base address `https://api.widgetic.com` for the calls of the `Public Embed` tag. **Signed context.** A partner that wants to trust `context` (to bill a customer by it, say) makes a signing secret (`rotatePartnerEntryContextSecret`), and its server signs the context it hands to the embed. The signature travels inside `context` as two reserved keys, `widgetic_exp` (UTC seconds, at most seven days ahead) and `widgetic_sig`. The gateway checks them after the `Origin` and before anything else is judged, stored or announced, and keeps and announces the context WITHOUT them. A context that is not signed as the partner requires is refused with 403 `CONTEXT_SIGNATURE_REQUIRED`, `CONTEXT_SIGNATURE_INVALID` or `CONTEXT_SIGNATURE_EXPIRED`; when the check cannot be made just now the answer is a retryable 503 `CONTEXT_SIGNATURE_UNAVAILABLE`, never an unchecked entry. Until a partner makes a secret nothing changes: the two keys are dropped and the rest is taken as it came. A signature is good until its `widgetic_exp` and may be used again until then, so a partner that must count each submission once keeps a unique value of its own (a `submissionId`, say) in the context. The recipe and a test vector are in the description of `rotatePartnerEntryContextSecret`.
+  # @param composition_id 
+  # @param table 
+  # @param public_composition_entry_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_widgetic_write_token Signed per-composition write token handed to the widget in `widgetic:host` as `entries.writeToken` (and returned by `GET /embed/compositions/{compositionId}` as `entryWriteToken`). Required when the request comes from the shared Widgetic artifact origin; verified whenever present.
+  # @return [PublicCompositionEntryCreated]
+  describe 'create_public_composition_entry test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_user_api_key
+  # Create an API key
+  # Makes a new API key for an account and returns its secret in `key`. That is the only time the secret is shown: Widgetic keeps a hash, so a key that was not stored cannot be recovered, only replaced. To rotate a key, make the new one, switch the integration over to it, then delete the old one. Only a person signed in on widgetic.com can make a key: a request made with an API key, or with an SDK token, is refused with 403. That way a leaked key cannot be used to make a second one that survives its revocation. Make keys from the dashboard; a key can still list, rename, switch off and delete keys. An `Idempotency-Key` header is required (8 to 50 characters: letters, digits, `-` and `_`). A retry with the same header and the same body returns the same answer instead of making a second key, and the same header with a different body is refused with 422. Make keys one at a time: two requests for the same account that run at the same moment can overwrite each other. A key can be limited to what it needs. Send a `preset` (`read_only`, `content` or `full_access`) or a list of `scopes`, never both. Send neither for a key that can do everything its owner can, as every key made before scopes existed. A limited key is refused with 403 and the code `API_KEY_SCOPE_MISSING` on anything outside its scopes, so a key held by a build server or by a partner's backend can be given only the part of the API it uses. The scopes of a key are fixed when it is made: to widen one, make a new key and delete the old one. A limited key cannot make, change or delete keys, exchange tokens or reach the administration routes. The list of scopes is in the `ApiKeyScope` schema. Accounts with API access (Solo, Teams and partner accounts) have no limit on how many keys they hold. An account on a plan without API access cannot make one (a partner account is not asked about a plan).
+  # @param id The account the key is for. For your own, your own user id
+  # @param idempotency_key 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`).
+  # @param create_user_api_key_request 
+  # @param [Hash] opts the optional parameters
+  # @return [CreatedUserApiKeyResponse]
+  describe 'create_user_api_key test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for create_widget
+  # Create Widget
+  # Creates a widget for your account: a named record with a type and some starting content, on a canvas of its own (or one of yours that you name). It costs no credits and has no code yet; the code is generated for it afterwards. The new widget is yours, and you can list it with `getWidgets`. A widget is a draft until you say otherwise (`isDraft: false`).  If a step after the widget was saved does not go through, the widget is still created, and `data.warnings` says what did not. Read it before relying on the widget.  A widget can be placed on one of your canvases (`canvasId`), in a project you can edit (`projectId`) or in an organization where you may create widgets (`organizationId`). Naming anything you cannot use is refused with 403, and the answer is the same whether it exists or not.  To make the widget for one of your managed users, send `managedUserId` or `managedUserExternalId`. The widget stays in your account and is yours to edit; the tag lets you list one user's widgets with `getWidgets`. The managed user must be yours and active: one that is not yours, or does not exist, is answered with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`. The tag is set here and does not change afterwards.  This call has a limit of its own: 120 per minute for each account (ask Widgetic if you need more). Past that the call is answered with 429 and a `Retry-After`. A widget has no database of its own: what the visitors of a composition leave is kept in the tables of that composition, made when the composition is. The `Idempotency-Key` header is required; send the same key when you retry, so one widget is created, not two. 
+  # @param idempotency_key A unique value (a UUID is fine) that makes a retry of this request safe.
+  # @param new_widget 
+  # @param [Hash] opts the optional parameters
+  # @return [CreateWidget201Response]
+  describe 'create_widget test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_canvas
+  # Delete Canvas
+  # Deletes a canvas together with every widget on it.  Called with an editor session, only a canvas whose widgets were all made for the session's managed user can be deleted; one that also holds somebody else's widgets is refused with 409 and `CANVAS_HAS_OTHER_WIDGETS`, and nothing is deleted. Delete such a canvas with your API key. 
+  # @param id ID of the canvas
+  # @param [Hash] opts the optional parameters
+  # @return [CanvasResponse]
+  describe 'delete_canvas test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_composition
+  # Delete Composition
+  # Deletes a specific composition, and the data it keeps (the tables it declared and what visitors left in them).
+  # @param id The ID of the composition to delete
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [nil]
+  describe 'delete_composition test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_composition_content_item
+  # Delete a content list item
+  # @param id 
+  # @param list 
+  # @param item_id 
+  # @param idempotency_key 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`).
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :if_match 
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [DeleteCompositionContentItemResponse]
+  describe 'delete_composition_content_item test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_composition_data_source
+  # Remove the composition data source binding
+  # Removes the binding. Asking again, or asking for a composition that had none, is not an error: the composition has no data source afterwards, and that is all `removed: true` says.
+  # @param id 
+  # @param idempotency_key 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`).
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [DeleteCompositionDataSourceResponse]
+  describe 'delete_composition_data_source test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_composition_database_record
+  # Delete Record From Composition Database
+  # Deletes a specific record from one of the composition's tables. Only the composition's own tables (made from its `databaseSchema` or from the tables its widget declares) can be reached; any other table name answers `404`.
+  # @param id ID of the composition
+  # @param table Name of the database table
+  # @param record_id ID of the record to delete
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (`POST /managed-users`). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its `externalId`), when you do not keep Widgetic's. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer's work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user's compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers `404` (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers `404` with `MANAGED_USER_NOT_FOUND`. An empty, repeated or malformed header is `400` with `MANAGED_USER_SCOPE_INVALID`; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with `403` and `MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE`: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer's browser holds, use an editor session. An `Idempotency-Key` is kept apart for each managed user.
+  # @return [CreateCompositionDatabaseRecord201Response]
+  describe 'delete_composition_database_record test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_composition_entry_items
+  # Delete composition entry items by id or host context
+  # Delete by comma-separated ids (1–100) or by context filters (not both). Rate limit 30 requests per minute.
+  # @param id 
+  # @param table 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :ids 
+  # @option opts [Hash<String, String>] :context Host context filters as &#x60;context[key]&#x3D;value&#x60; (max 5 keys, counting dotted &#x60;context.key&#x60; too). Use &#x60;column.&lt;name&gt;&#x3D;value&#x60; for columns whose names collide with reserved parameters.
+  # @option opts [Hash<String, String>] :filter Column filters as &#x60;filter[columnName]&#x3D;value&#x60; (same meaning as bare &#x60;columnName&#x3D;value&#x60; or &#x60;column.columnName&#x3D;value&#x60;; max 10 column filters counting all spellings). A plain &#x60;filter&#x3D;value&#x60; still filters a column named &#x60;filter&#x60;.
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionEntryDeleteSuccess]
+  describe 'delete_composition_entry_items test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_managed_user
+  # 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.
+  # @param id ID of the managed user to delete
+  # @param [Hash] opts the optional parameters
+  # @return [DeleteManagedUser200Response]
+  describe 'delete_managed_user test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_personal_workspace_domain
+  # Stop allowing a website to show your widgets
+  # Removes one entry from an account&#39;s own list. When it was the last one, nothing is restricted any more and a widget can be shown anywhere again. A change can take about 15 seconds to reach every server.
+  # @param id The account the list belongs to. For your own, your own user id
+  # @param domain_id The &#x60;id&#x60; of the entry, as the list shows it
+  # @param [Hash] opts the optional parameters
+  # @return [DeletePersonalWorkspaceDomainResponse]
+  describe 'delete_personal_workspace_domain test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for delete_user_api_key
+  # Delete an API key
+  # Deletes a key and the record of what it was used for. The key stops working at once on the server that took the request and within a minute on the others, and cannot be brought back: make a new one instead. To stop a key without losing it, switch it off with &#x60;updateUserApiKey&#x60;.
+  # @param id The account the key belongs to
+  # @param key_id The &#x60;keyId&#x60; of the key, as the list shows it
+  # @param [Hash] opts the optional parameters
+  # @return [DeleteUserApiKeyResponse]
+  describe 'delete_user_api_key test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for describe_composition_entries
+  # Describe What a Composition Keeps
+  # Names the tables a composition&#39;s widget keeps entries in (the votes, ratings, answers or sign-ups its visitors left), their columns, and how many entries each holds. Call it first to learn the table and column names that &#x60;readCompositionEntries&#x60; takes.  A widget that only shows content keeps nothing of its own: the answer is &#x60;hasData: false&#x60; with no tables, and that is not an error. A table that could not be counted has &#x60;rows: null&#x60;, which is not zero.  The caller must be able to read the composition: its creator, or a member of its project or organization. An editor session cannot call this route. 
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionEntriesDescriptionResponse]
+  describe 'describe_composition_entries test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for duplicate_composition
+  # Duplicate Composition
+  # Creates a duplicate of an existing composition for the authenticated user.  The duplicate is made after the answer: the call returns &#x60;202&#x60; with an &#x60;operationId&#x60;. Ask &#x60;GET /operations/{id}&#x60; for that operation until its &#x60;status&#x60; is &#x60;completed&#x60;; the new composition is named in &#x60;metadata.newCompositionId&#x60;. A problem with the duplicate&#39;s database (for example, tables that could not be made just now) is listed in &#x60;metadata.warnings&#x60;, which is absent when there is none.  The &#x60;Idempotency-Key&#x60; header is required (&#x60;400&#x60; without it). Send the same key when you retry, so one duplicate is made, not two. 
+  # @param id ID of the composition to duplicate
+  # @param idempotency_key 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;).
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [DuplicateCompositionRequest] :duplicate_composition_request 
+  # @return [DuplicateComposition202Response]
+  describe 'duplicate_composition test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for export_composition_entry_items
+  # Export composition entry items
+  # Streams up to 50,000 matching rows in batches of 1,000. Tables without cursor paging export at most one batch; when more rows exist the response sets &#x60;X-Widgetic-Export-Truncated: true&#x60;. Rate limit 20 requests per minute.
+  # @param id 
+  # @param table 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :format 
+  # @option opts [String] :order &#x60;desc&#x60; (the default) lists the newest entry first, &#x60;asc&#x60; the oldest. Entries are sorted by their time, then by their id (compared as text, byte by byte) in the same direction, so the order of two entries made at the same instant is always the same; an entry with no time counts as the oldest. A table with no time column is sorted by its id. The managed-user feed sorts by time, then by composition id, table and id. 
+  # @option opts [Time] :since Only entries made at this time or later: &#x60;since&#x60; is INCLUSIVE (an entry made at exactly &#x60;since&#x60; is returned). A date and time with an offset, such as &#x60;2026-10-01T00:00:00Z&#x60;; anything else answers 400 &#x60;INVALID_SINCE&#x60;. An entry with no time never matches, and a table with no time column answers 400 &#x60;ENTRY_TABLE_HAS_NO_TIME&#x60;. 
+  # @option opts [Time] :_until Only entries made before this time: &#x60;until&#x60; is EXCLUSIVE (an entry made at exactly &#x60;until&#x60; is NOT returned), so &#x60;since&#x3D;A&amp;until&#x3D;B&#x60; followed by &#x60;since&#x3D;B&amp;until&#x3D;C&#x60; counts every entry once. Same form and same refusals as &#x60;since&#x60; (400 &#x60;INVALID_UNTIL&#x60;). 
+  # @option opts [Hash<String, String>] :context Host context filters as &#x60;context[key]&#x3D;value&#x60; (max 5 keys, counting dotted &#x60;context.key&#x60; too). Use &#x60;column.&lt;name&gt;&#x3D;value&#x60; for columns whose names collide with reserved parameters.
+  # @option opts [Hash<String, String>] :filter Column filters as &#x60;filter[columnName]&#x3D;value&#x60; (same meaning as bare &#x60;columnName&#x3D;value&#x60; or &#x60;column.columnName&#x3D;value&#x60;; max 10 column filters counting all spellings). A plain &#x60;filter&#x3D;value&#x60; still filters a column named &#x60;filter&#x60;.
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [String]
+  describe 'export_composition_entry_items test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_ai_answers_knowledge
+  # See the documents a widget&#39;s AI answers from
+  # The &#x60;ai-answers&#x60; adapter lets a widget answer a visitor&#39;s question with text an AI model writes from documents the widget&#39;s owner provides. This lists those documents, and how much room is left for more: &#x60;totals&#x60; carries the widget&#39;s limits next to what it uses.  The list never contains what a document says, only which documents there are: their title, size and state. A &#x60;processing&#x60; document is not used to answer questions yet (or an add of it was interrupted: remove it and add it again).  Add a document with &#x60;addAiAnswersKnowledgeDocument&#x60;; remove one with &#x60;removeAiAnswersKnowledgeDocument&#x60;.  The caller must be allowed to see the widget: its owner, a partner for a customer it manages, or a Widgetic administrator. An API key needs the &#x60;content:read&#x60; scope. 
+  # @param id The widget (composition) whose documents to list
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetAiAnswersKnowledge200Response]
+  describe 'get_ai_answers_knowledge test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_all_canvases
+  # Get All Canvases
+  # Retrieves all canvases with pagination support and filtering options.  Pass &#x60;managedUserId&#x60; (Widgetic&#39;s id for one of your managed users) or &#x60;managedUserExternalId&#x60; (your own identifier for the user) to list only the canvases made for that managed user. The canvases of your other managed users, and your own, are left out. A managed user that is not yours, or does not exist, is answered with 404 and &#x60;MANAGED_USER_NOT_FOUND&#x60;. Called with an editor session, the list is always the session&#39;s managed user&#39;s. 
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :page Page number for pagination
+  # @option opts [Integer] :size Number of items per page
+  # @option opts [String] :sort Sort field and direction (e.g., \&quot;created_at:desc\&quot;)
+  # @option opts [Time] :created_after Filter canvases created after the specified date (ISO 8601 format)
+  # @option opts [Time] :created_before Filter canvases created before the specified date (ISO 8601 format)
+  # @option opts [Time] :updated_after Filter canvases updated after the specified date (ISO 8601 format)
+  # @option opts [Time] :updated_before Filter canvases updated before the specified date (ISO 8601 format)
+  # @option opts [String] :managed_user_id List only the canvases made for this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id List only the canvases made for the managed user you registered with this &#x60;externalId&#x60; (your own identifier for the user). Send this or &#x60;managedUserId&#x60;, not both.
+  # @return [GetAllCanvasesResponse]
+  describe 'get_all_canvases test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_all_compositions
+  # Get All Compositions
+  # Retrieves all compositions with pagination support.  Pass &#x60;managedUserId&#x60; (Widgetic&#39;s id for one of your managed users) or &#x60;managedUserExternalId&#x60; (your own identifier for the user) to list only the compositions made for that managed user. The compositions of your other managed users, and your own, are left out. It combines with the other filters and with paging. A managed user that is not yours, or does not exist, is answered with 404 and &#x60;MANAGED_USER_NOT_FOUND&#x60;.  An editor session with the &#x60;creator&#x60; surface may call this to list the compositions of ONE widget it built: it must send &#x60;widgetId&#x60;, and the answer holds only the compositions made for the session&#39;s managed user. 
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :page Page number for pagination
+  # @option opts [Integer] :size Number of items per page
+  # @option opts [String] :sort The order of the list, as &#x60;&lt;field&gt;:&lt;asc|desc&gt;&#x60;. The field is &#x60;createdAt&#x60;, &#x60;updatedAt&#x60;, &#x60;name&#x60; or &#x60;status&#x60; (the snake_case spelling, such as &#x60;created_at&#x60;, is read too). &#x60;asc&#x60; or &#x60;desc&#x60; alone orders by &#x60;createdAt&#x60;. Default: &#x60;createdAt:desc&#x60;. Any other field is a 400. 
+  # @option opts [String] :widget_id Filter compositions by widget ID
+  # @option opts [String] :workspace Filter by workspace
+  # @option opts [String] :project_folder Only the compositions in this project (the project&#39;s id).
+  # @option opts [String] :status Only the compositions in this status. Without it, every status is listed.
+  # @option opts [String] :managed_user_id List only the compositions made for this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both. Send it as &#x60;managedUserId&#x60;; the snake_case spelling &#x60;managed_user_id&#x60; is refused with a 400, not ignored.
+  # @option opts [String] :managed_user_external_id List only the compositions made for the managed user you registered with this &#x60;externalId&#x60; (your own identifier for the user). Send this or &#x60;managedUserId&#x60;, not both.
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetAllCompositions200Response]
+  describe 'get_all_compositions test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_all_managed_users
+  # Get Managed Users
+  # Retrieve the managed users you manage, with pagination support. (Admins see every partner&#39;s managed users.)
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :page Page number for pagination
+  # @option opts [Integer] :size Number of items per page
+  # @option opts [String] :sort 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.
+  # @return [GetAllManagedUsers200Response]
+  describe 'get_all_managed_users test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_canvas
+  # Get Canvas
+  # Retrieves a specific canvas by ID.
+  # @param id ID of the canvas
+  # @param [Hash] opts the optional parameters
+  # @return [CanvasResponse]
+  describe 'get_canvas test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_by_id
+  # Get Composition
+  # Retrieves a specific composition by its ID.  The answer carries &#x60;direct&#x60;, which says whether the widget the composition is made from is drawn straight into your page (&#x60;true&#x60;) or inside a frame (&#x60;false&#x60;), or &#x60;null&#x60; while the widget has no published version. Read it before you go live: a widget drawn without a frame writes its entries from your own page, so the public entry route accepts them only from a website on the composition&#39;s allowed list, and refuses them while that list is empty (the public JSON of the composition stays open to every website). A widget in a frame writes from Widgetic&#39;s own frame and is accepted whatever the list says. 
+  # @param id Composition ID
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CreateCompositionFromWidget201Response]
+  describe 'get_composition_by_id test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_content
+  # Get Current Content
+  # Retrieves the current content of a composition
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionContentResponse]
+  describe 'get_composition_content test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_content_schema
+  # Get Content Schema
+  # Retrieves the content schema for a composition based on its widget type
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionContentSchemaResponse]
+  describe 'get_composition_content_schema test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_data_source
+  # Read the composition data source binding
+  # The data source that is bound to the composition: &#x60;url&#x60; and &#x60;refreshSeconds&#x60;. The answer&#39;s &#x60;data&#x60; is &#x60;null&#x60; when none is bound, and also when what is stored does not pass the rule for a public https address (a binding written by another path, such as the general embed-settings update, is never shown to a page unless it passes the same checks as this route).
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionDataSourceResponse]
+  describe 'get_composition_data_source test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_database_record
+  # Get Record From Composition Database
+  # Retrieves a specific record from one of the composition&#39;s tables. Only the composition&#39;s own tables (made from its &#x60;databaseSchema&#x60; or from the tables its widget declares) can be reached; any other table name answers &#x60;404&#x60;.
+  # @param id ID of the composition
+  # @param table Name of the database table
+  # @param record_id ID of the record to retrieve
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CreateCompositionDatabaseRecord201Response]
+  describe 'get_composition_database_record test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_database_records
+  # Get All Records From Composition Database Table
+  # Retrieves all records from one of the composition&#39;s tables. Only the composition&#39;s own tables (made from its &#x60;databaseSchema&#x60; or from the tables its widget declares) can be reached; any other table name answers &#x60;404&#x60;.
+  # @param id ID of the composition
+  # @param table Name of the database table
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionDatabaseRecords200Response]
+  describe 'get_composition_database_records test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_design
+  # Get Composition Design
+  # Retrieves only the design field from a composition.
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionDesignResponse]
+  describe 'get_composition_design test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_design_schema
+  # Get Design Schema
+  # Retrieves the design schema for a composition based on its widget type
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionDesignSchemaResponse]
+  describe 'get_composition_design_schema test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_embed_schema
+  # Get Embed Schema
+  # Retrieves the definition of the composition&#39;s Embed tab: which settings exist, what each one holds, what it defaults to, and when its control is shown. It is the third tab beside &#x60;schema/content&#x60; and &#x60;schema/design&#x60;, in the same format (&#x60;componentGroups&#x60; → &#x60;components&#x60; → &#x60;propertyGroups&#x60; → &#x60;properties&#x60;, each property with a &#x60;type&#x60;, a &#x60;defaultValue&#x60; and an &#x60;inputController&#x60;), so a client that draws those two tabs draws this one with the same code.  The schema is the same for every composition (it is the one Widgetic&#39;s own Embed Editor draws). The composition id decides who may ask: the caller must be able to read the composition.  Reading and saving the values: - &#x60;GET /compositions/{id}/embed-settings&#x60; returns what the composition saved. A composition whose Embed tab   was never saved has nothing to return; seed the form from &#x60;defaults&#x60;, which holds the &#x60;defaultValue&#x60; of   every setting that declares one. - &#x60;PUT /compositions/{id}&#x60; with &#x60;embedSettings&#x60; saves them. The gateway stores &#x60;embedSettings&#x60; as given and   does not check it against this schema; the schema is how a client knows what to put there.  A property&#39;s &#x60;visibilityCondition&#x60; says when its control is shown: &#x60;condition&#x60; is a comparison of the current values of the properties named in &#x60;dependsOn&#x60; (&#x60;useIframe &#x3D;&#x3D;&#x3D; false&#x60;, &#x60;embedTarget &#x3D;&#x3D;&#x3D; &#39;mixed&#39; &amp;&amp; keepDimensions &#x3D;&#x3D;&#x3D; false&#x60;). While it is false the Embed Editor does not show the control.  A colour picker with &#x60;showOpacityControls&#x60; saves its opacity next to the colour, under the key &#x60;&lt;name&gt;_opacity&#x60; as a number from 0 to 1 (&#x60;overlayBackgroundColor&#x60; → &#x60;overlayBackgroundColor_opacity&#x60;). Its &#x60;defaultTransparency&#x60; is a percentage and the saved value a fraction (50 → 0.5). 
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionEmbedSchemaResponse]
+  describe 'get_composition_embed_schema test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_embed_settings
+  # Get Composition Embed Settings
+  # Retrieves only the embedSettings field from a composition.
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionEmbedSettingsResponse]
+  describe 'get_composition_embed_settings test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_preview
+  # Get Composition Preview
+  # Returns the address of the page an editor shows the composition in: the page of the widget&#39;s published version on the CDN, with the widget and version it is. Load it in a frame, then send the frame what to show (the content, design and embed settings you read from the composition, and every change the user makes) with &#x60;postMessage&#x60;: &#x60;{ type: &#39;widgetic:update&#39;, design }&#x60;, &#x60;{ type: &#39;widgetic:update&#39;, content }&#x60; or &#x60;{ type: &#39;widgetic:update&#39;, contentItems }&#x60;.  The version is the one embeds show, so the editor previews what a visitor gets. The address does not carry the composition id: an embed uses the id to fetch the saved composition itself, while an editor sends the current state (unsaved changes included).  A widget that has never been published has no page to show: the answer is 409 &#x60;WIDGET_NOT_PUBLISHED&#x60;. 
+  # @param id ID of the composition
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionPreviewResponse]
+  describe 'get_composition_preview test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_composition_versions
+  # Get Composition Versions
+  # Retrieves version history for a specific composition.
+  # @param id Composition ID
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [GetCompositionVersions200Response]
+  describe 'get_composition_versions test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_compositions_batch
+  # Get Compositions Batch
+  # Retrieves multiple compositions by their IDs in a single request. This endpoint includes domain validation for embed contexts and is used by the embed SDK.  Each composition is checked on its own. If its owner listed the websites it may appear on (the workspace&#39;s domain list, or the &#x60;allowedDomains&#x60; of a partner the owner administers) and the request comes from another website (the &#x60;Origin&#x60; header, or the host of &#x60;Referer&#x60; when there is no &#x60;Origin&#x60;), that composition is left out of &#x60;compositions&#x60; and reported in &#x60;errors&#x60; as &#x60;Domain access denied: &lt;reason&gt;&#x60;; the others are still returned. A request that names no website, and an owner who listed nothing, are not restricted, and a page on the visitor&#39;s own machine (&#x60;localhost&#x60;, &#x60;127.0.0.1&#x60; or &#x60;[::1]&#x60;, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (&#x60;platformDomain&#x60; in the answer of &#x60;GET /partners/mine&#x60;), for the compositions of that partner: a partner&#39;s list never has to name it. 
+  # @param get_compositions_batch_request 
+  # @param [Hash] opts the optional parameters
+  # @return [GetCompositionsBatchResponse]
+  describe 'get_compositions_batch test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_invoices_by_partner_id
+  # List a partner&#39;s invoices
+  # Lists the invoices issued to a partner, newest first. Each carries the price (&#x60;subtotal&#x60;), the tax on it (&#x60;taxAmount&#x60;) and what is paid (&#x60;total&#x60;), its status as the payment provider reports it, why the last payment failed (&#x60;failureReason&#x60;), and the page where it is paid (&#x60;hostedInvoiceUrl&#x60;).  A partner reads its own: the caller must be the person who administers the partner (an API key of that account works), and anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can read any partner&#39;s and see exactly what the partner sees; the full records, with the internal fields, are &#x60;getAllInvoices&#x60; filtered by partner.  The page is always bounded: &#x60;limit&#x60; defaults to 50 and is capped at 100, &#x60;offset&#x60; defaults to 0. 
+  # @param partner_id The partner whose invoices to list
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :status Only invoices with this status
+  # @option opts [Integer] :limit Maximum number of invoices to return
+  # @option opts [Integer] :offset Number of invoices to skip
+  # @return [GetInvoicesByPartnerId200Response]
+  describe 'get_invoices_by_partner_id test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_by_id
+  # Get Managed User By ID
+  # Retrieves a specific managed user by ID.
+  # @param id ID of the managed user to retrieve
+  # @param [Hash] opts the optional parameters
+  # @return [ManagedUserResponse]
+  describe 'get_managed_user_by_id test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_design_defaults
+  # Read design defaults for one managed user
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @return [GetPartnerDesignDefaults200Response]
+  describe 'get_managed_user_design_defaults test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_entitlements
+  # Get managed user entitlements
+  # Retrieves all entitlements for a managed user (admin or partner access).
+  # @param managed_user_id Managed user ID
+  # @param [Hash] opts the optional parameters
+  # @option opts [Boolean] :include_expired Include expired entitlements in results
+  # @option opts [String] :feature Filter by specific feature
+  # @option opts [String] :source Filter by entitlement source
+  # @return [GetManagedUserEntitlementsResponse]
+  describe 'get_managed_user_entitlements test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_limits
+  # Read monthly credit cap and usage for one managed user
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @return [GetManagedUserLimits200Response]
+  describe 'get_managed_user_limits test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_storage_usage
+  # Storage used by one managed user&#39;s uploads
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @return [GetManagedUserStorageUsage200Response]
+  describe 'get_managed_user_storage_usage test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_user_usage
+  # What a managed user&#39;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 &#x60;max_credits&#x60; when you make it (&#x60;createManagedUserEditorSession&#x60;).  The period runs from &#x60;startDate&#x60; (included) to &#x60;endDate&#x60; (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 &#x60;startDate&#x3D;2026-10-01&#x60; and &#x60;endDate&#x3D;2026-11-01&#x60;. 
+  # @param id The managed user whose usage you want (Widgetic&#39;s id for the user)
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :start_date 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;. 
+  # @option opts [String] :end_date End of the period, not included, in the same forms. Default: now. It must be after &#x60;startDate&#x60;, by at most 366 days. 
+  # @return [ManagedUserUsageResponse]
+  describe 'get_managed_user_usage test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_managed_users_by_manager_id
+  # Get Managed Users By Manager
+  # Retrieve managed users for a specific manager with pagination support.
+  # @param manager_id ID of the manager
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :page Page number for pagination
+  # @option opts [Integer] :size Number of items per page
+  # @option opts [String] :sort 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.
+  # @return [GetManagedUsersByManagerIdResponse]
+  describe 'get_managed_users_by_manager_id test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_my_partners
+  # Find the partner you administer
+  # Returns the partner (nearly always one) that the signed-in account administers, with the id every other partner route asks for and the standing it is in: &#x60;active&#x60;, &#x60;inactive&#x60; (not activated yet), &#x60;suspended&#x60; (paused, with the reason Widgetic gave) or &#x60;payment_arrears&#x60; (a contract invoice is past its due date and unpaid, since &#x60;overdueSince&#x60;; the partner is stopped until it is paid). A partner API key is that account&#39;s key, so it reads its own partner here.  An account that administers no partner is not refused: it gets &#x60;standing: not_a_partner&#x60; and an empty list, so a dashboard can tell \&quot;this is not a partner account\&quot; from \&quot;something failed\&quot;.  The call stays open while the partner is paused, not yet active or in payment arrears: that is when its dashboard has to say why. 
+  # @param [Hash] opts the optional parameters
+  # @return [MyPartnersResponse]
+  describe 'get_my_partners test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_adapter_connections
+  # See which adapter keys a partner has connected
+  # Widget adapters are capabilities a widget can use, and some of them act through a service the account that made the widget has with a provider: an adapter that sends email needs an email provider key, one that sends texts needs an SMS provider key. For the widgets of the customers a partner manages, those keys are the partner&#39;s. This lists every key an adapter takes from a partner and whether the partner has connected it.  An empty list means no adapter takes a key from a partner at the moment. The list never contains a key: only whether one is connected and when it was last set.  Connect a key with &#x60;setPartnerAdapterConnection&#x60;; take it away with &#x60;removePartnerAdapterConnection&#x60;. A managed customer never holds a key: the widgets of a managed customer use the partner&#39;s, and never the personal key of the person who administers the partner.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose adapter keys to list
+  # @param [Hash] opts the optional parameters
+  # @return [GetUserAdapterConnections200Response]
+  describe 'get_partner_adapter_connections test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_analytics_by_managed_user
+  # What each managed user&#39;s widgets did
+  # Lists every one of your managed users with what their widgets and compositions did in a period: views, interactions and visitors, and how many widgets and compositions they have made. A managed user whose widgets were not viewed is listed too, with zeros. The most viewed come first, and &#x60;page.hasMore&#x60; says whether more follow.  Only the compositions made for a managed user count for it: file them under the user when you create them (&#x60;managedUserId&#x60; on &#x60;createComposition&#x60;), or let the user&#39;s editor session do it, which files everything under its user. What a visitor did with a composition that is not filed under anyone is in the summary of the whole account (&#x60;getPartnerAnalyticsSummary&#x60;) and in no managed user&#39;s row.  The period works as it does for &#x60;getPartnerAnalyticsSummary&#x60;. The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose managed users to report on
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :start_date Start of the period, included. An ISO 8601 date (&#x60;2026-10-01&#x60;) or date-time with its offset. Default 30 days before &#x60;endDate&#x60;. 
+  # @option opts [String] :end_date End of the period, not included, in the same forms. Default now. At most 366 days after &#x60;startDate&#x60;.
+  # @option opts [Integer] :limit How many managed users to list at most
+  # @option opts [Integer] :offset How many managed users to skip
+  # @return [PartnerAnalyticsByManagedUserResponse]
+  describe 'get_partner_analytics_by_managed_user test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_analytics_summary
+  # What was done with a partner&#39;s published widgets
+  # Counts what the visitors of the compositions made through your account did in a period: how many times a composition was **viewed**, how many times a visitor **interacted** with one, and how many different visitors there were. It covers every composition of your account, your own and the ones made for your managed users; narrow it to one managed user with &#x60;managedUserId&#x60; or &#x60;managedUserExternalId&#x60; (not both).  The numbers come from the events the embedded widgets send while they are shown (the Widgetic embed SDK sends them by itself), counted when you ask. Only views and interactions are counted; the events that describe a visit (its start, its end, the device and the referrer) are not.  The period runs from &#x60;startDate&#x60; (included) to &#x60;endDate&#x60; (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 &#x60;startDate&#x3D;2026-10-01&#x60; and &#x60;endDate&#x3D;2026-11-01&#x60;.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose widgets to report on
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :start_date 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;. 
+  # @option opts [String] :end_date End of the period, not included, in the same forms. Default now. It must be after &#x60;startDate&#x60;, by at most 366 days. 
+  # @option opts [String] :managed_user_id Report only on this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id Report only on the managed user you registered with this &#x60;externalId&#x60; (your own identifier for the user). Send this or &#x60;managedUserId&#x60;, not both.
+  # @return [PartnerAnalyticsSummaryResponse]
+  describe 'get_partner_analytics_summary test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_analytics_timeline
+  # What was done with a partner&#39;s widgets, day by day
+  # Counts views, interactions and visitors for each day of a period (UTC days), oldest first, for a chart. Every day of the period is in the list, also one on which nothing happened (all zeros), so the list can be drawn as it is. Narrow it to one managed user with &#x60;managedUserId&#x60; or &#x60;managedUserExternalId&#x60; (not both).  The period works as it does for &#x60;getPartnerAnalyticsSummary&#x60;; &#x60;startDate&#x60; and &#x60;endDate&#x60; are best given as dates, so that the first and the last day are whole days. The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose widgets to report on
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :start_date Start of the period, included. An ISO 8601 date (&#x60;2026-10-01&#x60;) or date-time with its offset. Default 30 days before &#x60;endDate&#x60;. 
+  # @option opts [String] :end_date End of the period, not included, in the same forms. Default now. At most 366 days after &#x60;startDate&#x60;.
+  # @option opts [String] :managed_user_id Report only on this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id Report only on the managed user you registered with this &#x60;externalId&#x60;. Send this or &#x60;managedUserId&#x60;, not both.
+  # @return [PartnerAnalyticsTimelineResponse]
+  describe 'get_partner_analytics_timeline test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_analytics_top_widgets
+  # Which widgets were viewed the most
+  # Lists the widgets whose compositions were viewed the most in a period, with their views, interactions, visitors and how many of their compositions were viewed. A widget that nobody viewed or used is not listed. The most viewed come first (then the most used), and at most &#x60;limit&#x60; are listed. Narrow it to one managed user with &#x60;managedUserId&#x60; or &#x60;managedUserExternalId&#x60; (not both).  The period works as it does for &#x60;getPartnerAnalyticsSummary&#x60;. The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose widgets to report on
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :start_date Start of the period, included. An ISO 8601 date (&#x60;2026-10-01&#x60;) or date-time with its offset. Default 30 days before &#x60;endDate&#x60;. 
+  # @option opts [String] :end_date End of the period, not included, in the same forms. Default now. At most 366 days after &#x60;startDate&#x60;.
+  # @option opts [String] :managed_user_id Report only on this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id Report only on the managed user you registered with this &#x60;externalId&#x60;. Send this or &#x60;managedUserId&#x60;, not both.
+  # @option opts [Integer] :limit How many widgets to list at most
+  # @return [PartnerAnalyticsTopWidgetsResponse]
+  describe 'get_partner_analytics_top_widgets test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_billing_overview
+  # Get comprehensive partner billing overview
+  # Retrieves the partner&#39;s credits (&#x60;operationalCredits&#x60;), the partner&#39;s contract terms (&#x60;partnerCustomization&#x60;, the same fields as &#x60;getPartnerContract&#x60;) and billing integration status. Internal negotiation notes are not part of it. &#x60;operationalCredits&#x60; is the one account a partner has for its credits: the account of the person who administers it. It holds &#x60;balance&#x60; (the same balance &#x60;getPartnerCreditBalance&#x60; reads), &#x60;reservedBalance&#x60;, &#x60;availableBalance&#x60; (what a new operation can use) and &#x60;recentTransactions&#x60; (the ten newest entries of the ledger &#x60;getPartnerCreditTransactions&#x60; lists). A partner with no administrator has no account, and reads 0 and an empty list. 
+  # @param partner_id Partner ID
+  # @param [Hash] opts the optional parameters
+  # @return [GetPartnerBillingOverview200Response]
+  describe 'get_partner_billing_overview test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_contract
+  # Get a partner&#39;s contract
+  # Returns the commercial terms agreed with the partner: price, included credits and storage, billing cycle, commitment, support level, and the dates the contract runs between.  A partner reads its own: the caller must be the person who administers the partner (an API key of that account works), and anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can read any partner&#39;s. Responds 404 while no contract has been recorded for the partner, which is the case until Widgetic sets its terms. 
+  # @param partner_id The partner whose contract to read
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerContractResponse]
+  describe 'get_partner_contract test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_credit_balance
+  # Get partner credit balance
+  # Returns the credits the partner has, and how much of that is reserved by operations that are still running. A partner has ONE account for its credits: the account of the person who administers it, the same account its API key acts as. There is nothing else to create or to fund. What its customers&#39; editor sessions and its own API calls spend comes out of that account, and the credits a paid invoice carries are added to it, so this is the same balance &#x60;getUserCreditBalance&#x60; reads for that person.  A partner with no administrator has no account to hold credits, and reads a balance of 0.  Access: the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id Partner ID
+  # @param [Hash] opts the optional parameters
+  # @return [AccountCreditBalanceResponse]
+  describe 'get_partner_credit_balance test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_credit_transactions
+  # Get partner credit transaction history
+  # Lists what happened to the partner&#39;s credits, newest first: the entries of the credit ledger of the account of the person who administers it, the one account a partner has for its credits. Every operation that spends credits is a &#x60;debit&#x60; entry, and the credits an invoice carried arrive as &#x60;credit&#x60; entries when the invoice is paid, so this is also how the partner&#39;s usage is read. It is the same ledger &#x60;getUserCreditTransactions&#x60; reads for that person.  A partner with no administrator has no account, and an empty ledger.  The page is always bounded: &#x60;limit&#x60; defaults to 20 and is capped at 100, &#x60;offset&#x60; defaults to 0.  Access: the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id Partner ID
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit Number of transactions to return
+  # @option opts [Integer] :offset Number of transactions to skip
+  # @option opts [String] :type Only entries of this type, for instance &#x60;debit&#x60; for the credits spent. The types are listed on &#x60;AccountCreditTransaction&#x60;. 
+  # @return [GetPartnerCreditTransactions200Response]
+  describe 'get_partner_credit_transactions test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_data_database
+  # See the Neon database a partner keeps the data of its compositions in
+  # Returns the database set with &#x60;setPartnerDataDatabase&#x60;, without its password: the host, the database and the role, when it last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no database of its own, which means the data of its compositions is kept by Widgetic.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose database to read
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerDataDatabaseResponse]
+  describe 'get_partner_data_database test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_design_defaults
+  # Read partner-wide design defaults
+  # @param partner_id 
+  # @param [Hash] opts the optional parameters
+  # @return [GetPartnerDesignDefaults200Response]
+  describe 'get_partner_design_defaults test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_entitlements
+  # Get partner entitlements
+  # Retrieves all entitlements for a partner (admin or partner access).
+  # @param partner_id Partner ID
+  # @param [Hash] opts the optional parameters
+  # @option opts [Boolean] :include_expired Include expired entitlements in results
+  # @option opts [String] :feature Filter by specific feature
+  # @option opts [String] :source Filter by entitlement source
+  # @return [GetPartnerEntitlementsResponse]
+  describe 'get_partner_entitlements test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_entry_context_signing
+  # See how the context of your embeds is signed
+  # Says whether you have a secret to sign the &#x60;context&#x60; of your embeds with, when it was made, whether the secret it replaced is still accepted, and whether an entry without a valid signature is refused (&#x60;required&#x60;). The secret itself is never part of the answer: it is shown once, when it is made (&#x60;rotatePartnerEntryContextSecret&#x60;, which also explains what signing is for and how to sign).  Signing covers the entries written through the gateway into the compositions of your managed users and into those of your own account. The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose context signing to read
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerEntryContextSigningResponse]
+  describe 'get_partner_entry_context_signing test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_notification_settings
+  # Where your notifications go
+  # Returns who gets the emails, which events you want by email and by webhook, the address of your webhook, and whether it has a secret to sign with. The secret itself is never returned: it is shown once, when it is made. &#x60;events&#x60; lists every kind of event there is, for a settings screen.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose notification settings to read
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerNotificationSettingsResponse]
+  describe 'get_partner_notification_settings test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_storage_destination
+  # Get where a partner&#39;s uploaded files are stored
+  # Returns the partner&#39;s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means the partner cannot be activated, its uploads are refused, and no editor session is made for its customers until a destination is set.  The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose storage destination to read
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerStorageDestinationResponse]
+  describe 'get_partner_storage_destination test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_partner_storage_usage
+  # What a partner&#39;s customers store
+  # Says how many files, and how many bytes, your account keeps, in total and for each of your managed users, and how much of it is in Widgetic&#39;s storage and how much in your own storage destination (&#x60;setPartnerStorageDestination&#x60;). Use it to see which customers store the most, or to charge them for it.  A file is counted for a managed user when it was filed under that user: by naming &#x60;managed_user_id&#x60; or &#x60;managed_user_external_id&#x60; when you upload it (&#x60;uploadsPost&#x60;, or the metadata of a resumable upload), or because it was uploaded through that user&#39;s editor session, which files everything under its user. The files that are not filed under anyone (your own, and the ones uploaded without naming a managed user) are the row whose &#x60;managedUserId&#x60; is null. Deleted files are not counted. To list the files of one managed user, use the &#x60;managed_user_id&#x60; filter of &#x60;uploadsGet&#x60;.  The answer is counted when you ask, so it is always current. The groups are ordered by size, the heaviest first, and &#x60;page.hasMore&#x60; says whether more follow.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose storage to report on
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit How many managed users to list at most
+  # @option opts [Integer] :offset How many managed users to skip
+  # @return [PartnerStorageUsageResponse]
+  describe 'get_partner_storage_usage test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_personal_workspace_domains
+  # List the websites allowed to show your widgets
+  # Lists the websites on an account&#39;s own list, newest first. It is the list Widgetic checks when a widget of the account is embedded: when it holds at least one website, the widget is shown on those websites (and on Widgetic&#39;s own) and nowhere else; when it is empty, the widget can be shown anywhere. If the account administers a partner, the websites set on the partner record by Widgetic are added to them. Widgets that belong to an organization use the organization&#39;s list instead. The answer holds the whole list, however long it is: a partner&#39;s list has no limit.
+  # @param id The account the list belongs to. For your own, your own user id
+  # @param [Hash] opts the optional parameters
+  # @return [GetPersonalWorkspaceDomains200Response]
+  describe 'get_personal_workspace_domains test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_public_composition_embed
+  # Resolve a composition UUID to a published widget URL
+  # Public customer embed lookup. No API key. Used by embed-sdk.js on third-party sites. If the composition&#39;s owner listed the websites it may appear on (the workspace&#39;s domain list, or the &#x60;allowedDomains&#x60; of a partner the owner administers), a request from any other website is refused with 403 &#x60;DOMAIN_NOT_ALLOWED&#x60;. The website is read from the &#x60;Origin&#x60; header, or the host of &#x60;Referer&#x60; when there is no &#x60;Origin&#x60;; a request that names neither (a server, a tool) is not refused. An owner who listed nothing is not restricted, and a page on the visitor&#39;s own machine (&#x60;localhost&#x60;, &#x60;127.0.0.1&#x60; or &#x60;[::1]&#x60;, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (&#x60;platformDomain&#x60; in the answer of &#x60;GET /partners/mine&#x60;), for the widgets of that partner: a partner&#39;s list never has to name it. The list stops other websites from showing the embed in a visitor&#39;s browser; it does not hide the published content from someone who holds the composition ID. **Address.** &#x60;https://api.widgetic.com/embed/compositions/{compositionId}&#x60;: the root of the API host, NOT under &#x60;/v1&#x60;. A client generated from this description for &#x60;https://api.widgetic.com/v1&#x60; must be given the base address &#x60;https://api.widgetic.com&#x60; for the calls of the &#x60;Public Embed&#x60; tag. **Limit.** 500 calls for each visitor address and browser in one counting window, shared with the frame and the status routes. Over it the answer is 429 &#x60;RATE_LIMITED&#x60; with a &#x60;Retry-After&#x60; header. 
+  # @param composition_id 
+  # @param [Hash] opts the optional parameters
+  # @return [GetPublicCompositionEmbed200Response]
+  describe 'get_public_composition_embed test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_public_composition_iframe
+  # Embed a published composition with its saved values
+  # Public HTML wrapper with an inner published artifact iframe. No API key or SDK required. If the composition&#39;s owner listed the websites it may appear on, the page is sent with &#x60;Content-Security-Policy: frame-ancestors&#x60; naming those websites (and Widgetic&#39;s own, and the website where the partner the owner administers integrates Widgetic, with its subdomains), so a browser refuses to show it inside any other website whatever &#x60;Referer&#x60; policy that website uses. Opening the address directly still works. An owner who listed nothing is not restricted. **Address.** &#x60;https://api.widgetic.com/embed/compositions/{compositionId}/frame&#x60;: the root of the API host, NOT under &#x60;/v1&#x60;. A client generated from this description for &#x60;https://api.widgetic.com/v1&#x60; must be given the base address &#x60;https://api.widgetic.com&#x60; for the calls of the &#x60;Public Embed&#x60; tag. 
+  # @param composition_id 
+  # @param [Hash] opts the optional parameters
+  # @return [String]
+  describe 'get_public_composition_iframe test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_user_adapter_connections
+  # See which adapter keys an account has connected
+  # Widget adapters are capabilities a widget can use, and some of them act through a service the owner has an account with: an adapter that sends email needs the owner&#39;s email provider key, one that sends texts needs the owner&#39;s SMS provider key. This lists every key an adapter takes from an owner and whether this account has connected it, so a settings page can show what is missing.  An empty list means no adapter takes a key from an owner at the moment. The list never contains a key: only whether one is connected and when it was last set.  Connect a key with &#x60;setUserAdapterConnection&#x60;; take it away with &#x60;removeUserAdapterConnection&#x60;. The widgets of customers a partner manages use the partner&#39;s keys instead (&#x60;getPartnerAdapterConnections&#x60;).  The caller must be the account itself (an API key of that account works, with the &#x60;account:read&#x60; scope), or a Widgetic administrator. 
+  # @param user_id The account whose adapter keys to list. For your own, your own user id
+  # @param [Hash] opts the optional parameters
+  # @return [GetUserAdapterConnections200Response]
+  describe 'get_user_adapter_connections test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_user_api_key_usage_logs
+  # Read what an API key was used for
+  # Lists the calls made with one key, newest first: when, which path and method, and the status each ended with. Use it to see whether a key is still in use before deleting it, or to see what a key that should not be in use has been doing.
+  # @param id The account the key belongs to
+  # @param key_id The &#x60;keyId&#x60; of the key, as the list shows it
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit How many calls to return, newest first
+  # @return [GetUserApiKeyUsageLogsResponse]
+  describe 'get_user_api_key_usage_logs test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_user_api_keys
+  # List the API keys of an account
+  # Lists the API keys of an account, in the order they were made: name, the first characters of the key, when it was made, when it expires, when it was last used, whether it is switched on and what it is limited to (&#x60;scopes&#x60; and &#x60;preset&#x60;). The secret of a key is never part of the list. A caller can list its own account&#39;s keys; Widgetic staff can list any account&#39;s.
+  # @param id The account the keys belong to. For your own keys, your own user id
+  # @param [Hash] opts the optional parameters
+  # @return [GetUserApiKeys200Response]
+  describe 'get_user_api_keys test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_user_credit_balance
+  # Get an account&#39;s credit balance
+  # Returns the credits an account holds: the balance, and how much of it is reserved by operations that are still running.  An account reads its own balance; with a partner&#39;s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account&#39;s. An account that has never held credits reads a balance of 0. &#x60;getPartnerCreditBalance&#x60; reads this same balance by partner id. 
+  # @param user_id The account whose balance to read
+  # @param [Hash] opts the optional parameters
+  # @return [AccountCreditBalanceResponse]
+  describe 'get_user_credit_balance test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_user_credit_transactions
+  # List an account&#39;s credit ledger
+  # Lists the entries of an account&#39;s credit ledger, newest first. This is also how an account&#39;s usage is read: every operation that spends credits is a &#x60;debit&#x60; entry, so summing the &#x60;debit&#x60; entries over a period gives the credits consumed in it, and the other types give what was added.  An account reads its own ledger; with a partner&#39;s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account&#39;s. &#x60;getPartnerCreditTransactions&#x60; reads this same ledger by partner id.  The page is always bounded: &#x60;limit&#x60; defaults to 100 and is capped at 500, &#x60;offset&#x60; defaults to 0. 
+  # @param user_id The account whose ledger to read
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :transaction_type Only entries of this type, for instance &#x60;debit&#x60; for the credits spent. The types are listed on &#x60;AccountCreditTransaction&#x60;. 
+  # @option opts [Integer] :limit Maximum number of entries to return
+  # @option opts [Integer] :offset Number of entries to skip
+  # @return [GetPartnerCreditTransactions200Response]
+  describe 'get_user_credit_transactions test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_widgets
+  # List Widgets
+  # Lists the widgets your account owns, newest first. A widget is the reusable piece a composition is made from; this is your own library, not a catalogue of Widgetic&#39;s widgets.  Pass &#x60;page&#x60; (counting from 1) and &#x60;size&#x60; (1 to 100, 20 when left out) to read the list one page at a time. &#x60;meta&#x60; then carries &#x60;total&#x60;, &#x60;hasNextPage&#x60; and &#x60;hasPreviousPage&#x60;, so a client can walk the list to its end. A page past the end is an empty list. Without &#x60;page&#x60; and &#x60;size&#x60; the call returns the whole list in one response, which only suits an account with a few widgets.  Pass &#x60;canvasId&#x60; to list only the widgets on one of your canvases. That list is always returned whole, whatever &#x60;page&#x60; and &#x60;size&#x60; say.  Pass &#x60;managedUserId&#x60; (Widgetic&#39;s id for one of your managed users) or &#x60;managedUserExternalId&#x60; (your own identifier for the user) to list only the widgets made for that managed user. The widgets of your other managed users, and your own, are left out. It combines with &#x60;page&#x60;, &#x60;size&#x60; and &#x60;canvasId&#x60;. A managed user that is not yours, or does not exist, is answered with 404 and &#x60;MANAGED_USER_NOT_FOUND&#x60;. 
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :page Page to return, counting from 1. Giving &#x60;page&#x60; or &#x60;size&#x60; turns paging on.
+  # @option opts [Integer] :size How many widgets a page holds (20 when &#x60;page&#x60; is given without it). Giving &#x60;page&#x60; or &#x60;size&#x60; turns paging on.
+  # @option opts [String] :canvas_id List only the widgets on this canvas. The list is returned whole.
+  # @option opts [String] :managed_user_id List only the widgets made for this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id List only the widgets made for the managed user you registered with this &#x60;externalId&#x60; (your own identifier for the user). Send this or &#x60;managedUserId&#x60;, not both.
+  # @return [GetWidgets200Response]
+  describe 'get_widgets test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for get_widgets_batch
+  # Get Widgets Batch
+  # Retrieves multiple widgets by their IDs in a single request. An id that is not found, or that is not yours, is reported in &#x60;errors&#x60; exactly like one that does not exist. Called with an editor session, only the widgets made for the session&#39;s managed user are returned.
+  # @param get_widgets_batch_request 
+  # @param [Hash] opts the optional parameters
+  # @return [GetWidgetsBatchResponse]
+  describe 'get_widgets_batch test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for list_composition_entry_items
+  # List composition entry items with paging and filters
+  # Reads one widget table with cursor paging (time then id in byte order), optional since/until on the time column, and up to five context filters plus ten column filters. Rate limit 120 requests per minute. Each read batch uses a 5 s statement timeout.
+  # @param id 
+  # @param table 
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit 
+  # @option opts [String] :order &#x60;desc&#x60; (the default) lists the newest entry first, &#x60;asc&#x60; the oldest. Entries are sorted by their time, then by their id (compared as text, byte by byte) in the same direction, so the order of two entries made at the same instant is always the same; an entry with no time counts as the oldest. A table with no time column is sorted by its id. The managed-user feed sorts by time, then by composition id, table and id. 
+  # @option opts [Time] :since Only entries made at this time or later: &#x60;since&#x60; is INCLUSIVE (an entry made at exactly &#x60;since&#x60; is returned). A date and time with an offset, such as &#x60;2026-10-01T00:00:00Z&#x60;; anything else answers 400 &#x60;INVALID_SINCE&#x60;. An entry with no time never matches, and a table with no time column answers 400 &#x60;ENTRY_TABLE_HAS_NO_TIME&#x60;. 
+  # @option opts [Time] :_until Only entries made before this time: &#x60;until&#x60; is EXCLUSIVE (an entry made at exactly &#x60;until&#x60; is NOT returned), so &#x60;since&#x3D;A&amp;until&#x3D;B&#x60; followed by &#x60;since&#x3D;B&amp;until&#x3D;C&#x60; counts every entry once. Same form and same refusals as &#x60;since&#x60; (400 &#x60;INVALID_UNTIL&#x60;). 
+  # @option opts [String] :cursor 
+  # @option opts [Hash<String, String>] :context Host context filters as &#x60;context[key]&#x3D;value&#x60; (max 5 keys, counting dotted &#x60;context.key&#x60; too). Use &#x60;column.&lt;name&gt;&#x3D;value&#x60; for columns whose names collide with reserved parameters.
+  # @option opts [Hash<String, String>] :filter Column filters as &#x60;filter[columnName]&#x3D;value&#x60; (same meaning as bare &#x60;columnName&#x3D;value&#x60; or &#x60;column.columnName&#x3D;value&#x60;; max 10 column filters counting all spellings). A plain &#x60;filter&#x3D;value&#x60; still filters a column named &#x60;filter&#x60;.
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionEntryItemsPageSuccess]
+  describe 'list_composition_entry_items test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for list_managed_user_entries
+  # List entries across a managed user&#39;s compositions
+  # Merges eligible tables (time and id columns) across the managed user&#39;s compositions in global time order, then compositionId, table, and id (byte order). Only tables with both a time and an id column take part. Rate limit 30 requests per minute.
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :composition_id 
+  # @option opts [String] :table 
+  # @option opts [Integer] :limit 
+  # @option opts [String] :order &#x60;desc&#x60; (the default) lists the newest entry first, &#x60;asc&#x60; the oldest. Entries are sorted by their time, then by their id (compared as text, byte by byte) in the same direction, so the order of two entries made at the same instant is always the same; an entry with no time counts as the oldest. A table with no time column is sorted by its id. The managed-user feed sorts by time, then by composition id, table and id. 
+  # @option opts [Time] :since Only entries made at this time or later: &#x60;since&#x60; is INCLUSIVE (an entry made at exactly &#x60;since&#x60; is returned). A date and time with an offset, such as &#x60;2026-10-01T00:00:00Z&#x60;; anything else answers 400 &#x60;INVALID_SINCE&#x60;. An entry with no time never matches, and a table with no time column answers 400 &#x60;ENTRY_TABLE_HAS_NO_TIME&#x60;. 
+  # @option opts [Time] :_until Only entries made before this time: &#x60;until&#x60; is EXCLUSIVE (an entry made at exactly &#x60;until&#x60; is NOT returned), so &#x60;since&#x3D;A&amp;until&#x3D;B&#x60; followed by &#x60;since&#x3D;B&amp;until&#x3D;C&#x60; counts every entry once. Same form and same refusals as &#x60;since&#x60; (400 &#x60;INVALID_UNTIL&#x60;). 
+  # @option opts [String] :cursor 
+  # @option opts [Hash<String, String>] :context Host context filters as &#x60;context[key]&#x3D;value&#x60; (max 5 keys, counting dotted &#x60;context.key&#x60; too). Use &#x60;column.&lt;name&gt;&#x3D;value&#x60; for columns whose names collide with reserved parameters.
+  # @option opts [Hash<String, String>] :filter Column filters as &#x60;filter[columnName]&#x3D;value&#x60; (same meaning as bare &#x60;columnName&#x3D;value&#x60; or &#x60;column.columnName&#x3D;value&#x60;; max 10 column filters counting all spellings). A plain &#x60;filter&#x3D;value&#x60; still filters a column named &#x60;filter&#x60;.
+  # @return [ManagedUserEntriesPageSuccess]
+  describe 'list_managed_user_entries test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for list_partner_notification_deliveries
+  # How your notifications reached you
+  # Lists the sends of your notifications, the newest first: each email to one address and each call to your webhook, with whether it was delivered, when it is tried again if not, how many attempts it had, and why the last one failed. Use it to find out why a webhook of yours did not receive an event.  An email counts as delivered when it was handed to the mail service; a call to your webhook counts as delivered when your endpoint answered with a 2xx status. Anything else is tried again, after 1 minute, then 5 minutes, 30 minutes, 2 hours, 6 hours, 12 hours and a day, eight attempts in all, because your address is read again at each attempt and you may have mended it. Two answers end the delivery at once: &#x60;410 Gone&#x60; and &#x60;413 Payload Too Large&#x60;.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose deliveries to list
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit How many deliveries to list at most
+  # @return [PartnerNotificationDeliveryLogResponse]
+  describe 'list_partner_notification_deliveries test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for list_partner_notifications
+  # What your partner account was told
+  # Lists the notifications of a partner, the newest first: the invoices Widgetic issued and their payments, the reminders to pay them, a warning when your credits run low, and the changes to the standing of the account (activated, paused, resumed). It is the same list your dashboard shows, and each entry is what your webhook receives as &#x60;data&#x60; when you have one (&#x60;updatePartnerNotificationSettings&#x60;).  A page holds &#x60;limit&#x60; notifications (20 by default, at most 100). When there are older ones &#x60;nextBefore&#x60; is set: ask again with it as &#x60;before&#x60; to get the next page.  The caller must be the person who administers the partner (an API key of that account works, with the &#x60;partner:read&#x60; scope), or a Widgetic administrator. 
+  # @param partner_id The partner whose notifications to list
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit How many notifications to list at most
+  # @option opts [Time] :before Only the notifications made before this moment. Give the &#x60;nextBefore&#x60; of the previous page.
+  # @return [PartnerNotificationPageResponse]
+  describe 'list_partner_notifications test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for list_partner_presets
+  # List the widgets a partner offers as presets
+  # Returns the partner&#39;s presets, ordered by &#x60;position&#x60; and then by &#x60;key&#x60;: the widgets it offers its managed users as starting points. The list is the same for every managed user.  Use a preset in one of two ways: - **Make a composition of it** (the content and design editor): call &#x60;createComposition&#x60; with the preset&#39;s   &#x60;widgetId&#x60; and the managed user. The widget itself stays yours; a composition is the user&#39;s own content. - **Give the user a copy to build on** (the widget creator): call &#x60;copyPresetForManagedUser&#x60;. The user gets   a widget and a canvas of their own.  Presets are not the same as the widgets Widgetic puts on every new Widgetic account. Those are chosen by Widgetic and are copied at sign-up. A preset here is yours, and is copied only when you ask.  The caller must be the person who administers the partner (an API key of that account works), or a Widgetic administrator. 
+  # @param partner_id The partner whose presets to list
+  # @param [Hash] opts the optional parameters
+  # @return [ListPartnerPresets200Response]
+  describe 'list_partner_presets test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for operations_id_get
+  # Get operation status
+  # Follows work that carries on after the response that started it. Duplicating a composition, for one, answers 202 with an &#x60;operationId&#x60;: ask for that operation until its &#x60;status&#x60; is &#x60;completed&#x60; (or &#x60;failed&#x60;, with the reason in &#x60;error&#x60;). A finished duplication names the new composition in &#x60;metadata.newCompositionId&#x60;.  An operation belongs to the user who started it. Asking for somebody else&#39;s operation answers 404, exactly as for one that does not exist. Administrators may read any operation. 
+  # @param id Operation identifier returned when the job was created.
+  # @param [Hash] opts the optional parameters
+  # @return [OperationsIdGetResponse]
+  describe 'operations_id_get test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for patch_composition_content_item
+  # Update a content list item
+  # @param id 
+  # @param list 
+  # @param item_id 
+  # @param idempotency_key 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;).
+  # @param request_body 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :if_match 
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CreateCompositionContentItem201Response]
+  describe 'patch_composition_content_item test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for post_public_composition_embed_status
+  # Batch-check whether compositions are currently served for embed
+  # Public batch health check for embed-sdk.js. No API key. Uses the same serving gate and domain policy as &#x60;GET /embed/compositions/{compositionId}&#x60;: the caller&#39;s website is read from &#x60;Origin&#x60;, or the host of &#x60;Referer&#x60; when there is no &#x60;Origin&#x60;. A request that names neither (a server or tool) is not refused for domain reasons. **Address.** &#x60;https://api.widgetic.com/embed/compositions/status&#x60;: the root of the API host, NOT under &#x60;/v1&#x60;. A client generated from this description for &#x60;https://api.widgetic.com/v1&#x60; must be given the base address &#x60;https://api.widgetic.com&#x60; for the calls of the &#x60;Public Embed&#x60; tag. **Limit.** The route counts against the same limit as the lookup and the frame routes: 500 calls for each visitor address and browser in one counting window. A call is ONE hit whatever the number of &#x60;ids&#x60; it carries (up to 100), so a server that checks many compositions spends one call for each hundred of them. A visitor who is over the limit gets 429 &#x60;RATE_LIMITED&#x60; for the WHOLE call, with a &#x60;Retry-After&#x60; header and no state for any id: there is no per-composition rate-limit state in the answer.
+  # @param post_public_composition_embed_status_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PostPublicCompositionEmbedStatus200Response]
+  describe 'post_public_composition_embed_status test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for read_composition_entries
+  # Read the Entries of a Composition&#39;s Table
+  # Counts the entries visitors left in one table, tallies them per value of a column on request, and returns the newest entries only when asked to. To show the results of a rating widget, tally by its rating column (&#x60;groupBy&#x60;): each group is a rating and how many visitors gave it. The average is then &#x60;sum(value * count) / sum(count)&#x60; over the tallies (all of them, when &#x60;moreGroups&#x60; is false).  - **&#x60;totalRows&#x60;** is how many entries the table holds in all. - **&#x60;groupBy&#x60;** names a column (as &#x60;describeCompositionEntries&#x60; lists it). &#x60;tallies&#x60; then lists up to 20   values of it, the largest group first; &#x60;moreGroups&#x60; is true when there are more. - **&#x60;rows&#x60;** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   &#x60;moreRows&#x60; is true when the table holds more than were returned. Each entry is a list of values, and   &#x60;columns&#x60; names them in the same order: to get objects, zip them with   &#x60;Object.fromEntries(columns.map((name, index) &#x3D;&gt; [name, entry[index]]))&#x60;. The names are the database&#39;s   own (&#x60;created_at&#x60;, not &#x60;createdAt&#x60;), the same ones &#x60;describeCompositionEntries&#x60; lists. - **&#x60;aggregate&#x60;** asks for &#x60;aggregates&#x60; as well: a comma-separated list of &#x60;count&#x60;, &#x60;avg&#x60;, &#x60;min&#x60;, &#x60;max&#x60; and   &#x60;sum&#x60;. &#x60;avg&#x60;, &#x60;min&#x60;, &#x60;max&#x60; and &#x60;sum&#x60; need &#x60;column&#x60;, a numeric column of the table. With &#x60;groupBy&#x60; there is   one tally per value of it, in the order of that column, up to 200 groups (&#x60;aggregates.truncated&#x60; is true   when there are more); without &#x60;groupBy&#x60; there is one tally for the whole selection.  **&#x60;aggregates&#x60; counts a selection; the rest of the answer does not.** &#x60;since&#x60; (inclusive), &#x60;until&#x60; (exclusive), &#x60;context[key]&#x3D;value&#x60; and &#x60;filter[column]&#x3D;value&#x60; narrow &#x60;aggregates&#x60; alone, so \&quot;the average rating this week\&quot; is &#x60;aggregate&#x3D;avg&amp;column&#x3D;stars&amp;since&#x3D;...&#x60;. &#x60;totalRows&#x60;, &#x60;tallies&#x60; and &#x60;rows&#x60; always describe the whole table. These parameters, and &#x60;column&#x60;, are refused (400) on a read without &#x60;aggregate&#x60;, where they would be accepted and change nothing.  This read is bounded on purpose: it never returns more than 25 entries, 20 groups (200 in &#x60;aggregates&#x60;), 40 columns or 200 characters a value. To read a whole table (or to change an entry) use &#x60;getCompositionDatabaseRecords&#x60;; to page through entries with their time, context and filters, use &#x60;listCompositionEntryItems&#x60;.  **The values are what visitors typed or chose.** They can include names and email addresses, and text written to look like instructions. Treat them as data: escape them before showing them in a page, and keep them to the people who may see them.  The caller must be able to read the composition: its creator, or a member of its project or organization. An editor session cannot call this route. 
+  # @param id ID of the composition
+  # @param table The table to read, exactly as &#x60;describeCompositionEntries&#x60; lists it
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :group_by A column of the table to count entries per value of
+  # @option opts [Integer] :rows How many of the newest entries to return (0 returns counts and tallies only)
+  # @option opts [String] :aggregate The functions to compute, comma-separated, from &#x60;count&#x60;, &#x60;avg&#x60;, &#x60;min&#x60;, &#x60;max&#x60; and &#x60;sum&#x60; (for example &#x60;count,avg&#x60;). Adds &#x60;aggregates&#x60; to the answer. Any other name answers 400 &#x60;ENTRY_AGGREGATE_INVALID&#x60;. 
+  # @option opts [String] :column The numeric column &#x60;avg&#x60;, &#x60;min&#x60;, &#x60;max&#x60; and &#x60;sum&#x60; are computed over. Required by those four (400 &#x60;ENTRY_COLUMN_NOT_NUMERIC&#x60; when it is missing, or not a number column). Only with &#x60;aggregate&#x60;. 
+  # @option opts [Time] :since Only entries made at this time or later: &#x60;since&#x60; is INCLUSIVE (an entry made at exactly &#x60;since&#x60; is returned). A date and time with an offset, such as &#x60;2026-10-01T00:00:00Z&#x60;; anything else answers 400 &#x60;INVALID_SINCE&#x60;. An entry with no time never matches, and a table with no time column answers 400 &#x60;ENTRY_TABLE_HAS_NO_TIME&#x60;. 
+  # @option opts [Time] :_until Only entries made before this time: &#x60;until&#x60; is EXCLUSIVE (an entry made at exactly &#x60;until&#x60; is NOT returned), so &#x60;since&#x3D;A&amp;until&#x3D;B&#x60; followed by &#x60;since&#x3D;B&amp;until&#x3D;C&#x60; counts every entry once. Same form and same refusals as &#x60;since&#x60; (400 &#x60;INVALID_UNTIL&#x60;). 
+  # @option opts [Hash<String, String>] :context Host context filters as &#x60;context[key]&#x3D;value&#x60; (max 5 keys, counting dotted &#x60;context.key&#x60; too). Use &#x60;column.&lt;name&gt;&#x3D;value&#x60; for columns whose names collide with reserved parameters.
+  # @option opts [Hash<String, String>] :filter Column filters as &#x60;filter[columnName]&#x3D;value&#x60; (same meaning as bare &#x60;columnName&#x3D;value&#x60; or &#x60;column.columnName&#x3D;value&#x60;; max 10 column filters counting all spellings). A plain &#x60;filter&#x3D;value&#x60; still filters a column named &#x60;filter&#x60;.
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionEntriesReadingResponse]
+  describe 'read_composition_entries test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_ai_answers_knowledge_document
+  # Remove a document from a widget&#39;s knowledge base
+  # Removes one document and its passages: the widget&#39;s AI stops answering from it at once. Take the &#x60;documentId&#x60; from &#x60;getAiAnswersKnowledge&#x60;.  The caller must be allowed to change the widget. An API key needs the &#x60;content:write&#x60; scope. 
+  # @param id The widget (composition) the document is in
+  # @param document_id The document to remove
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [RemoveAiAnswersKnowledgeDocument200Response]
+  describe 'remove_ai_answers_knowledge_document test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_partner_adapter_connection
+  # Remove an adapter key from a partner
+  # Removes a key an adapter was given. The adapter stops working for the widgets of the partner&#39;s customers that need it: their visitors are told the feature is unavailable. Nothing else of the widgets changes, and connecting a key again brings them back.  Removing a key that is not connected answers 200 with &#x60;removed: false&#x60;: the state asked for is the state it is in. A key of an adapter that has since been retired from the catalog can still be removed.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner that keeps the key
+  # @param adapter_id The adapter the key is for
+  # @param credential_key The key&#39;s name within the adapter
+  # @param [Hash] opts the optional parameters
+  # @return [RemoveUserAdapterConnection200Response]
+  describe 'remove_partner_adapter_connection test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_partner_data_database
+  # Stop keeping the data of a partner&#39;s compositions in its own database
+  # Removes the partner&#39;s database from Widgetic: Widgetic forgets the connection string, and from then on the data of the partner&#39;s compositions is kept in Widgetic&#39;s database again. Nothing in your database is deleted.  Removing is refused with 409 &#x60;PARTNER_DATABASE_HOLDS_DATA&#x60; while any composition of the partner keeps its data in your database: it would read as empty from then on, and what it holds would stay where nothing reads it. Delete the compositions you no longer need, or keep the database. If Widgetic cannot check what your database holds (it cannot be reached) the answer is 503 &#x60;PARTNER_DATABASE_UNAVAILABLE&#x60;; check it with &#x60;verifyPartnerDataDatabase&#x60;, or set the same database again to repair its connection.  Removing a database the partner does not have is not an error: the answer is &#x60;removed: false&#x60;.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose database to remove
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerDataDatabaseRemovalResponse]
+  describe 'remove_partner_data_database test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_partner_preset
+  # Take a widget off the partner&#39;s presets
+  # Removes the preset under &#x60;key&#x60;. The widget itself is not touched, and neither are the copies and the compositions already made from it.  Removing a preset the partner does not have is not an error: the answer is &#x60;removed: false&#x60;. 
+  # @param partner_id The partner whose preset to remove
+  # @param key The key of the preset to remove
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerPresetRemovalResponse]
+  describe 'remove_partner_preset test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_partner_storage_destination
+  # Stop storing a partner&#39;s uploaded files in its own bucket
+  # Removes the partner&#39;s storage destination. Partner storage is not optional, so after this every upload of the account, on any route, and the uploads of your customers&#39; editor sessions are refused (409 &#x60;PARTNER_STORAGE_REQUIRED&#x60;) until a destination is set again, and no editor session can be made. Files already in the partner&#39;s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is &#x60;removed: false&#x60;.  The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose storage destination to remove
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerStorageRemovalResponse]
+  describe 'remove_partner_storage_destination test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for remove_user_adapter_connection
+  # Remove an adapter key from an account
+  # Removes a key an adapter was given. The adapter stops working for the widgets that need it: their visitors are told the feature is unavailable. Nothing else of the widgets changes, and connecting a key again brings them back.  Removing a key that is not connected answers 200 with &#x60;removed: false&#x60;: the state asked for is the state it is in. A key of an adapter that has since been retired from the catalog can still be removed.  This needs an API key with full access. The caller must be the account itself or a Widgetic administrator. 
+  # @param user_id The account that keeps the key. For your own, your own user id
+  # @param adapter_id The adapter the key is for
+  # @param credential_key The key&#39;s name within the adapter
+  # @param [Hash] opts the optional parameters
+  # @return [RemoveUserAdapterConnection200Response]
+  describe 'remove_user_adapter_connection test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for replay_partner_notification_delivery
+  # Send a webhook delivery again
+  # Sends one earlier **webhook** delivery again to your **current** webhook address, with the same event &#x60;id&#x60; (&#x60;webhook-id&#x60;) as the original notification so a receiver that remembers ids can ignore a duplicate, and a new &#x60;createdAt&#x60; and signature made with your current secret. The attempt is recorded in the delivery log as a new row that points at the delivery you replayed.  Set a webhook address (and secret) under notification settings before you replay. Changing the settings needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose delivery to replay
+  # @param delivery_id The delivery to send again (must be a webhook delivery of this partner)
+  # @param idempotency_key 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;).
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerNotificationDeliveryResponse]
+  describe 'replay_partner_notification_delivery test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for revoke_managed_user_editor_session
+  # 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. 
+  # @param id The managed user the session is for
+  # @param session_id The &#x60;sessionId&#x60; of the session, from &#x60;createManagedUserEditorSession&#x60;
+  # @param [Hash] opts the optional parameters
+  # @return [DeleteManagedUser200Response]
+  describe 'revoke_managed_user_editor_session test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for revoke_managed_user_editor_sessions
+  # End every editor session of a managed user
+  # Ends all of the managed user&#39;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. 
+  # @param id The managed user whose sessions end
+  # @param [Hash] opts the optional parameters
+  # @return [RevokeManagedUserEditorSessionsResponse]
+  describe 'revoke_managed_user_editor_sessions test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for rotate_partner_entry_context_secret
+  # Make a secret to sign the context of your embeds
+  # Makes a secret to sign the &#x60;context&#x60; of your embeds with, and returns it in &#x60;secret&#x60;: **keep it now, it is shown once** and cannot be read again. Keep it on your server only: whoever holds it can write contexts your compositions accept. Call this again to make a new secret; the one it replaces is still accepted for a day, so that your server can switch without an entry being refused (making another within that day ends the overlap with the first).  **What signing is for.** &#x60;&lt;widgetic composition-id&#x3D;\&quot;...\&quot; context&#x3D;&#39;{\&quot;customerId\&quot;:\&quot;c_42\&quot;}&#39;&gt;&#x60; hands attribution to a widget, which sends it with every entry it saves. The page is yours but the browser is the visitor&#39;s: anybody can change that attribute and file an entry under another customer&#39;s id. When your server signs the context, the gateway refuses an entry whose context was changed, and the entries you keep hold attribution your server wrote.  **How to sign** (on your server, for each page you render):  1. Take the context to give the widget. It may hold text and whole numbers only (within ±2^53, written without    a fraction or an exponent). 2. Choose when the signature stops being good: &#x60;widgetic_exp&#x60;, in seconds since 1970 (UTC), no more than    seven days from now. A minute of difference between clocks is forgiven. 3. Write the text to sign, with no spaces except those inside values:    &#x60;widgetic-context.v1.&lt;compositionId&gt;.&lt;widgetic_exp&gt;.&lt;json&gt;&#x60;. &#x60;&lt;compositionId&gt;&#x60; is the id of the composition    in lower case. &#x60;&lt;json&gt;&#x60; is the context as JSON with the keys in character-code order (so &#x60;Z&#x60; comes before    &#x60;a&#x60;, and &#x60;10&#x60; before &#x60;9&#x60;), no spaces, strings escaped as JSON escapes them, and the two keys of the    signature left out. 4. Sign that text: HMAC-SHA256 with the 32 bytes the secret stands for (the base64 text after &#x60;ctxsec_&#x60;), and    write the result as base64url without padding. 5. Give the widget the context with two keys added: &#x60;widgetic_exp&#x60; and &#x60;widgetic_sig&#x60; (the signature). The whole    attribute, the two keys included, stays within the limits of any context: at most 20 keys, 2048 bytes of    JSON, strings up to 500 characters. The two keys take two of the 20 keys and 87 bytes of the 2048.  A test vector, to check your code against before you rely on it. Secret &#x60;ctxsec_AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8&#x3D;&#x60; (the bytes 0 to 31), composition &#x60;7c9e6679-7425-40de-944b-e07fc1f90ae7&#x60;, &#x60;widgetic_exp&#x60; 1792000000 and context &#x60;{\&quot;customerId\&quot;:\&quot;c_42\&quot;,\&quot;plan\&quot;:\&quot;pro\&quot;,\&quot;seats\&quot;:3}&#x60; sign the text &#x60;widgetic-context.v1.7c9e6679-7425-40de-944b-e07fc1f90ae7.1792000000.{\&quot;customerId\&quot;:\&quot;c_42\&quot;,\&quot;plan\&quot;:\&quot;pro\&quot;,\&quot;seats\&quot;:3}&#x60; and give the signature &#x60;j6g7151F54tl9C8oEY9levaYSppHME4fAPZ7WPwL8C8&#x60;. (The secret is the example&#39;s, not a real one.)  **What the gateway does with an entry.** When you have a secret, an entry whose context carries a signature is checked: a signature that does not match is refused with 403 &#x60;CONTEXT_SIGNATURE_INVALID&#x60;, and one that is past &#x60;widgetic_exp&#x60; with 403 &#x60;CONTEXT_SIGNATURE_EXPIRED&#x60;. When you also require signatures (&#x60;updatePartnerEntryContextSigning&#x60;) an entry whose context carries none is refused with 403 &#x60;CONTEXT_SIGNATURE_REQUIRED&#x60;. The two keys are taken out before the entry is stored or announced: your entries and your &#x60;entry.created&#x60; events hold the context you wrote. A change you make reaches every part of the gateway within a minute.  **What it does not do.** A signed context that has been seen (a page&#39;s source is public) can be sent again by anyone until &#x60;widgetic_exp&#x60;; when you must not accept the same context twice, put a value that is new for each page view in it (a &#x60;submissionId&#x60; you made up) and keep the ones you have seen. The signature covers the entries that reach Widgetic&#39;s gateway: a row that gets into a table another way (your own code writing straight into a database you brought, or the record calls of the composition&#39;s owner) does not pass through it, and carries no context.  Retry this call with the same &#x60;Idempotency-Key&#x60; if its answer was lost: the answer, secret included, is then given again, and no second secret is made. This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose secret to make
+  # @param idempotency_key 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;).
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerEntryContextSecretResponse]
+  describe 'rotate_partner_entry_context_secret test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for rotate_partner_webhook_secret
+  # Make a new secret for your webhook
+  # Makes a new secret to sign your webhook with, and returns it in &#x60;webhookSecret&#x60;: **keep it now, it is shown once** and cannot be read again. Use it when the secret was lost, or may have leaked.  The secret you had keeps signing beside the new one for a day, so that your receiver can switch without a call being rejected: during that day each call carries two signatures (see &#x60;updatePartnerNotificationSettings&#x60; for how they are verified). Rotating again within the day ends the overlap with the first secret.  Retry this call with the same &#x60;Idempotency-Key&#x60; if its answer was lost: the answer, secret included, is then given again, and no second secret is made.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose webhook secret to replace
+  # @param idempotency_key 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;).
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerNotificationSettingsChangeResponse]
+  describe 'rotate_partner_webhook_secret test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for send_partner_notification_test_event
+  # Send a test event to your webhook
+  # Sends ONE signed call, right now, to the webhook address you saved under notification settings, with a sample of what an event of the type you name carries, and answers how it went: whether your receiver answered with a 2xx status, which status, how long it took, and why not when it did not arrive. Use it to write and try your receiver (above all the signature check) before a real event happens.  The call is made like every other: it is signed with your current secret (and the previous one while a rotation overlaps), it carries the headers &#x60;webhook-id&#x60;, &#x60;webhook-timestamp&#x60;, &#x60;webhook-signature&#x60; and &#x60;x-widgetic-event&#x60; (the event type), and its body is &#x60;{ \&quot;id\&quot;, \&quot;type\&quot;, \&quot;createdAt\&quot;, \&quot;partnerId\&quot;, \&quot;data\&quot; }&#x60;. Three things differ. &#x60;id&#x60; starts with &#x60;evt_test_&#x60; and is new every time, so a receiver that remembers ids can tell a test from an event and drop it. &#x60;data&#x60; holds made-up values of the shape a real event of that type carries (&#x60;PartnerNotification&#x60; describes each), never anything about your account. And the call is made once: it is not tried again, nothing is stored, and it appears neither in the delivery log nor in the notification list.  It is sent whatever &#x60;webhookEvents&#x60; says: a test is not filtered by what you subscribed to. The answer is 200 whether or not your receiver took the call (read &#x60;delivered&#x60;); a call that gets no answer within ten seconds is given up and reported as a &#x60;timeout&#x60;.  A webhook address and a signing secret must be saved first (&#x60;updatePartnerNotificationSettings&#x60;); until then the answer is 409. This needs an API key with full access, and &#x60;Idempotency-Key&#x60; is required: a retry with the same key gets the first answer back and no second call is made. The caller must be the person who administers the partner, or a Widgetic administrator. Five tests a minute. 
+  # @param partner_id The partner whose webhook to try
+  # @param idempotency_key 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;).
+  # @param partner_notification_test_event_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerNotificationTestEventResultResponse]
+  describe 'send_partner_notification_test_event test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_composition_data_source
+  # Bind a public JSON data source for embed refresh
+  # Stores an https URL the widget runtime may read on load and every &#x60;refreshSeconds&#x60;. The URL must name a public host (no loopback, link-local or metadata addresses). A composition has one binding: saving another replaces it. The answer is the binding as it was saved (&#x60;url&#x60;, &#x60;refreshSeconds&#x60;).
+  # @param id 
+  # @param idempotency_key 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;).
+  # @param set_composition_data_source_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionDataSourceResponse]
+  describe 'set_composition_data_source test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_dynamic_content
+  # Set Dynamic Content
+  # Updates the content of a composition dynamically with optional schema validation.  An editor session (see &#x60;createManagedUserEditorSession&#x60;) can send only &#x60;content&#x60;, &#x60;validate&#x60; and &#x60;partial&#x60;, and only for a composition made for its managed user. A body that names &#x60;version&#x60;, &#x60;source&#x60; or any other field is refused with &#x60;403&#x60; and &#x60;EDITOR_SESSION_FIELD_NOT_ALLOWED&#x60;. 
+  # @param id ID of the composition
+  # @param idempotency_key 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;).
+  # @param set_dynamic_content_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :if_match Optional content version from ETag (&#x60;\&quot;3\&quot;&#x60;, &#x60;3&#x60;, or &#x60;*&#x60;)
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [SetDynamicContentResponse]
+  describe 'set_dynamic_content test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_managed_user_design_defaults
+  # Set or clear design defaults for one managed user
+  # Send &#x60;{ \&quot;design\&quot;: { ... } }&#x60; to store a JSON object (at most 64 KB, nesting depth 32), or &#x60;{ \&quot;design\&quot;: null }&#x60; to remove the override. New compositions for this customer merge this layer over the partner default and under the request body. 
+  # @param id 
+  # @param set_partner_design_defaults_request 
+  # @param [Hash] opts the optional parameters
+  # @return [GetPartnerDesignDefaults200Response]
+  describe 'set_managed_user_design_defaults test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_managed_user_limits
+  # 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&#39;s editor sessions may spend in a UTC calendar month, or null to remove the cap. The cap counts the credits the customer&#39;s sessions spent that month (refunded credits do not count) and applies to all of the customer&#39;s sessions together, beside any &#x60;max_credits&#x60; 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. 
+  # @param id 
+  # @param set_managed_user_limits_request 
+  # @param [Hash] opts the optional parameters
+  # @return [GetManagedUserLimits200Response]
+  describe 'set_managed_user_limits test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_partner_adapter_connection
+  # Connect an adapter key to a partner
+  # Gives an adapter the key it needs to act through a service the partner has an account with, for the widgets of the customers the partner manages. Take the &#x60;adapterId&#x60; and &#x60;credentialKey&#x60; from &#x60;getPartnerAdapterConnections&#x60;. Saving a key that is already connected replaces it.  **What Widgetic does with it.** The key is stored encrypted, bound to this partner, this adapter and this credential, so that a stored value cannot be moved to another. It is never returned, never logged and never shown to a visitor of a widget or to your customers. A server of Widgetic opens it for the one call a widget makes through the adapter, uses it to call the provider on the partner&#39;s behalf, and discards it. To cut that off, remove the key here, or revoke it with the provider.  **What is checked.** That the adapter exists and takes this credential, that a partner may keep it (some are for an owner only) and that the text is one line of at most 2048 characters. Whether the provider accepts the key is not checked here: it shows the first time a widget uses it.  A widget whose adapter has no key connected is not charged and does not run that adapter: its visitors are told the feature is unavailable, and the partner is told once a day what to connect.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. A retry is harmless: saving the same key twice only refreshes when it was set. 
+  # @param partner_id The partner that keeps the key
+  # @param adapter_id The adapter the key is for
+  # @param credential_key The key&#39;s name within the adapter
+  # @param set_adapter_connection_request 
+  # @param [Hash] opts the optional parameters
+  # @return [SetUserAdapterConnection200Response]
+  describe 'set_partner_adapter_connection test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_partner_data_database
+  # Keep the data of a partner&#39;s compositions in a Neon database of its own
+  # Points the partner at a Neon database of its own. From then on, what visitors leave in the compositions of the partner&#39;s managed users, and of the compositions made in the partner&#39;s own account (the votes, ratings, answers and form submissions of the widgets that collect them), is stored in that database and nowhere else. Widgetic&#39;s own database is not used for them any more, and nothing of it is copied there.  **What to give.** The connection string of a Neon database and a role made for this, as Neon shows it under *Connect* (&#x60;postgresql://&lt;role&gt;:&lt;password&gt;@ep-&lt;name&gt;.&lt;region&gt;.aws.neon.tech/&lt;database&gt;&#x60;). Only Neon databases are accepted; a string for any other host is refused with 400. What the database needs: - an empty database of its own, so that nothing else of yours shares it. Widgetic makes one schema in it for   each composition (named &#x60;comp_&#x60; followed by the composition&#39;s id). In that schema go the tables the widget   declares for what its visitors leave, and two small tables of Widgetic&#39;s own, whose names start with   &#x60;_widgetic_&#x60;: the context a host page sent with an entry, and how far Widgetic has read the entries to tell   you about new ones. It touches nothing else; - a role that may create schemas and tables in it (the CREATE privilege on the database). The role Neon makes   with a project has it. A role made in the Neon console can also read and write every other database of the   same project, so if you keep other data in Neon give Widgetic a project of its own, or make the role with   SQL (&#x60;CREATE ROLE ... LOGIN PASSWORD ...&#x60;) and grant it only the CREATE privilege on this database; - connections from anywhere: Widgetic&#39;s addresses are not fixed, so a Neon project that only accepts   connections from an allow list of addresses cannot be used. A suspended compute is fine: it wakes on the   first request.  **It is checked before it is saved.** Widgetic makes a schema in your database, creates a table in it, writes a row, reads it back, and removes the schema again, all in one step, so that nothing is left if anything fails. If it cannot be done nothing is saved and the answer is 422 &#x60;PARTNER_DATABASE_UNVERIFIED&#x60;: &#x60;details.reason&#x60; says why (&#x60;INVALID_CREDENTIALS&#x60;, &#x60;DATABASE_NOT_FOUND&#x60;, &#x60;ACCESS_DENIED&#x60;, &#x60;ACCESS_BLOCKED&#x60;, &#x60;ENDPOINT_NOT_FOUND&#x60;, &#x60;ENDPOINT_UNREACHABLE&#x60;, &#x60;TIMEOUT&#x60;, &#x60;READ_ONLY&#x60;, &#x60;RATE_LIMITED&#x60;, &#x60;DATABASE_UNAVAILABLE&#x60;, &#x60;PROBE_MISMATCH&#x60; or &#x60;DATABASE_ERROR&#x60;) and &#x60;message&#x60; says what to do.  **Existing data does not move.** The data of a composition lives in one database. If any composition of the partner already keeps data somewhere else (in Widgetic&#39;s database, or in the database you had set), and the new database does not hold it, the change is refused with 409 &#x60;PARTNER_DATABASE_HOLDS_DATA&#x60; and nothing is changed: those compositions would read as empty from then on. &#x60;details.compositionsWithData&#x60; says how many. Set your database before your customers collect data, or delete the compositions you no longer need. Saving the same database again (a new password) moves nothing and is never refused.  **It is never a fallback.** Once a database is set, a request that needs it while it cannot be used (the password was changed, the project was deleted) is refused with 503 &#x60;PARTNER_DATABASE_UNAVAILABLE&#x60;. What the visitor sent is not stored with Widgetic instead. Fix the connection and set the database again, or check it with &#x60;verifyPartnerDataDatabase&#x60;.  **When it takes effect.** A change reaches every part of Widgetic within about a minute.  **What Widgetic keeps.** The connection string is stored encrypted and is never returned or logged; a response shows the host, the database and the role, never the password. Widgetic&#39;s servers open it to read and write the data of your compositions while they handle a request for it. To cut that off, change the role&#39;s password in Neon: the compositions stop saving until you set the new string.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. A retry is harmless: saving the same database twice only refreshes when it was checked and saved. 
+  # @param partner_id The partner whose database to set
+  # @param set_partner_data_database_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerDataDatabaseResponse]
+  describe 'set_partner_data_database test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_partner_design_defaults
+  # Set or clear partner-wide design defaults
+  # Send &#x60;{ \&quot;design\&quot;: { ... } }&#x60; or &#x60;{ \&quot;design\&quot;: null }&#x60; to remove. New compositions merge this layer over the widget base and under each managed user&#39;s default and the request body. 
+  # @param partner_id 
+  # @param set_partner_design_defaults_request 
+  # @param [Hash] opts the optional parameters
+  # @return [GetPartnerDesignDefaults200Response]
+  describe 'set_partner_design_defaults test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_partner_preset
+  # Make a widget a preset, or replace a preset
+  # Offers one of the partner&#39;s own widgets as a preset under &#x60;key&#x60;. If the partner already has a preset under that key it is replaced, so sending the same request twice is safe. Saving replaces the whole preset: a &#x60;title&#x60;, &#x60;description&#x60; or &#x60;position&#x60; you leave out goes back to its default.  Keys are 1 to 64 characters: lowercase letters, digits, hyphens and underscores, the first a letter or a digit (&#x60;rating&#x60;, &#x60;quiz-3&#x60;).  The widget must belong to the partner&#39;s account; a widget that does not exist and one that belongs to somebody else are refused in the same way (404 &#x60;PRESET_WIDGET_NOT_FOUND&#x60;). A widget is a preset under at most one key (409 &#x60;PRESET_WIDGET_ALREADY_USED&#x60;; &#x60;details.key&#x60; says which), and an account can have at most 100 presets (409 &#x60;PRESET_LIMIT_REACHED&#x60;).  Later changes to the widget reach new copies and new compositions; copies made earlier are not touched. Deleting the widget removes its preset. 
+  # @param partner_id The partner whose preset to set
+  # @param key The name your code uses for the preset
+  # @param set_partner_preset_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerPresetResponse]
+  describe 'set_partner_preset test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_partner_storage_destination
+  # Set where a partner&#39;s uploaded files are stored
+  # Points the partner at a bucket of its own on an S3-compatible service (Cloudflare R2, Amazon S3, Wasabi, MinIO and the like). From then on, every file the account that administers the partner stores is kept in that bucket instead of with Widgetic, whichever way it arrives: a file sent with &#x60;uploadsPost&#x60; (with an API key, an SDK token, an editor session or from the Widgetic website), a resumable upload, the media library, and the files the agent tools and the MCP server save. It takes none of the account&#39;s storage allowance, and its &#x60;url&#x60; is served from &#x60;publicBaseUrl&#x60;. The chunks of a resumable upload wait in Widgetic&#39;s temporary staging area until it is completed and are removed then: the finished file is stored in your bucket and nowhere else.  A destination is required. Partner storage is not optional: your customers&#39; files, and your own however they arrive, are kept in this destination and nowhere else. An editor session (&#x60;createManagedUserEditorSession&#x60;) of any surface cannot be made until a destination is set (409 &#x60;PARTNER_STORAGE_REQUIRED&#x60;), a destination removed later stops the uploads of the sessions already made (the same 409), and your own upload with no destination (on any route, including a resumable upload, which is refused when it is started) is refused in the same way instead of being stored with Widgetic. A partner cannot be activated until it has a destination that works.  The destination is checked before it is saved. Widgetic writes a small test file under &#x60;&lt;keyPrefix&gt;widgetic-check/&#x60;, reads it back from &#x60;&lt;publicBaseUrl&gt;/&lt;its key&gt;&#x60;, and deletes it. If any step fails nothing is saved and the answer is 422 &#x60;STORAGE_DESTINATION_UNVERIFIED&#x60;: &#x60;details.step&#x60; says where (&#x60;endpoint&#x60;, &#x60;write&#x60; or &#x60;public_read&#x60;), &#x60;details.reason&#x60; says why, and &#x60;param&#x60; names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at &#x60;publicBaseUrl&#x60;, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (&#x60;accessKeyHint&#x60;). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 &#x60;STORAGE_DESTINATION_UNAVAILABLE&#x60;, and when the bucket rejects the file with 502 &#x60;STORAGE_DESTINATION_WRITE_FAILED&#x60;.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner&#39;s. 
+  # @param partner_id The partner whose storage destination to set
+  # @param set_partner_storage_destination_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerStorageDestinationResponse]
+  describe 'set_partner_storage_destination test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for set_user_adapter_connection
+  # Connect an adapter key to an account
+  # Gives an adapter the key it needs to act through a service you have an account with, for the widgets you made. Take the &#x60;adapterId&#x60; and &#x60;credentialKey&#x60; from &#x60;getUserAdapterConnections&#x60;. Saving a key that is already connected replaces it.  **What Widgetic does with it.** The key is stored encrypted, bound to this account, this adapter and this credential, so that a stored value cannot be moved to another. It is never returned, never logged and never shown to a visitor of a widget. A server of Widgetic opens it for the one call a widget makes through the adapter, uses it to call the provider on your behalf, and discards it. To cut that off, remove the key here, or revoke it with the provider.  **What is checked.** That the adapter exists and takes this credential, that an owner may keep it (some are for a partner only) and that the text is one line of at most 2048 characters. Whether the provider accepts the key is not checked here: it shows the first time a widget uses it, and the widget tells its owner.  A widget whose adapter has no key connected is not charged and does not run that adapter: its visitors are told the feature is unavailable, and the owner is told once a day what to connect.  This needs an API key with full access. The caller must be the account itself or a Widgetic administrator. A retry is harmless: saving the same key twice only refreshes when it was set. 
+  # @param user_id The account that keeps the key. For your own, your own user id
+  # @param adapter_id The adapter the key is for
+  # @param credential_key The key&#39;s name within the adapter
+  # @param set_adapter_connection_request 
+  # @param [Hash] opts the optional parameters
+  # @return [SetUserAdapterConnection200Response]
+  describe 'set_user_adapter_connection test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_canvas
+  # Update Canvas
+  # Updates an existing canvas with the specified properties.
+  # @param id ID of the canvas to update
+  # @param update_canvas_request 
+  # @param [Hash] opts the optional parameters
+  # @return [CanvasResponse]
+  describe 'update_canvas test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_composition
+  # Update Composition
+  # Updates a specific composition.  The &#x60;Idempotency-Key&#x60; header is required (&#x60;400&#x60; without it). Send the same key when you retry.  An editor session (see &#x60;createManagedUserEditorSession&#x60;) can send only &#x60;name&#x60;, &#x60;content&#x60;, &#x60;design&#x60; and &#x60;embedSettings&#x60;, and only for a composition made for its managed user. A body that names any other field is refused with &#x60;403&#x60; and &#x60;EDITOR_SESSION_FIELD_NOT_ALLOWED&#x60;.  Send &#x60;databaseSchema&#x60; to add tables to the composition: the tables that are missing are made, and the ones that exist are left as they are. A &#x60;databaseSchema&#x60; that cannot be used is refused before anything is saved, with &#x60;400&#x60; and &#x60;INVALID_DATABASE_SCHEMA&#x60;. If the composition is saved but its tables cannot be made just now, the answer is still &#x60;200&#x60; and &#x60;meta.warnings&#x60; says so. 
+  # @param id Composition ID
+  # @param idempotency_key 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;).
+  # @param update_composition 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CreateCompositionFromWidget201Response]
+  describe 'update_composition test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_composition_database_record
+  # Update Record In Composition Database
+  # Updates a specific record in one of the composition&#39;s tables. Only the composition&#39;s own tables (made from its &#x60;databaseSchema&#x60; or from the tables its widget declares) can be reached; any other table name answers &#x60;404&#x60;.
+  # @param id ID of the composition
+  # @param table Name of the database table
+  # @param record_id ID of the record to update
+  # @param idempotency_key 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;).
+  # @param body 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CreateCompositionDatabaseRecord201Response]
+  describe 'update_composition_database_record test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_composition_status
+  # Update Composition Status
+  # Updates the status of a specific composition.  The &#x60;Idempotency-Key&#x60; header is required (&#x60;400&#x60; without it). Send the same key when you retry. 
+  # @param id Composition ID
+  # @param idempotency_key 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;).
+  # @param update_composition_status_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [CompositionResponse]
+  describe 'update_composition_status test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_managed_user
+  # Update Managed User
+  # Updates an existing managed user. Only &#x60;externalId&#x60;, &#x60;metadata&#x60; and &#x60;isActive&#x60; can change, and &#x60;metadata&#x60; is replaced as a whole, so send all of it. &#x60;isActive: false&#x60; switches the managed user off: what it already has stays, and nothing new can be filed under it until you send &#x60;isActive: true&#x60;. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The &#x60;Idempotency-Key&#x60; header is required (&#x60;400&#x60; without it). 
+  # @param id ID of the managed user to update
+  # @param idempotency_key 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;).
+  # @param update_managed_user 
+  # @param [Hash] opts the optional parameters
+  # @return [ManagedUserResponse]
+  describe 'update_managed_user test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_partner_entry_context_signing
+  # Require a signed context, or stop requiring it
+  # Chooses what the gateway does with an entry whose &#x60;context&#x60; carries no valid signature.  With &#x60;required: false&#x60; (the default) an entry that carries a signature is checked and refused when the signature is wrong or out of date, and an entry that carries none is accepted, as it always was. With &#x60;required: true&#x60; an entry without a valid signature is refused with 403 &#x60;CONTEXT_SIGNATURE_REQUIRED&#x60;: use it once every page of yours that embeds a composition signs its context.  Signatures cannot be required before you have made a secret (&#x60;rotatePartnerEntryContextSecret&#x60;): the answer is 409, so that you cannot lock your own compositions out of taking entries. The change reaches every part of the gateway within a minute.  Saving the same choice twice leaves the same state, so a retry is harmless and &#x60;Idempotency-Key&#x60; is optional. This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose context signing to change
+  # @param update_partner_entry_context_signing_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :idempotency_key Optional: without it the call is carried out every time it is sent. 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;).
+  # @return [PartnerEntryContextSigningResponse]
+  describe 'update_partner_entry_context_signing test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_partner_notification_settings
+  # Choose where your notifications go
+  # Changes who gets the emails, which events you want by email and by webhook, and the address of your webhook. A key you leave out of the body is left as it was; send only what changes.  **Email.** &#x60;emailRecipients&#x60; is the list of addresses (at most five). While it is empty the emails about invoices go to the billing emails of your billing profile (your contact email when there are none), and the others to your contact email. The events about money and about the standing of your account are always emailed, whatever &#x60;emailEvents&#x60; says; it narrows the others.  **Webhook.** &#x60;webhookUrl&#x60; is where Widgetic sends a signed &#x60;POST&#x60; for each event, so that your own system can act on it (mark an invoice paid, warn your team that credits are low). The address must be &#x60;https&#x60; on the standard port, on a public site, and must not redirect. Setting an address when you have no secret yet makes one, and the answer carries it as &#x60;webhookSecret&#x60;: **keep it now, it is shown once**. &#x60;webhookEvents&#x60; narrows what is sent.  Each call has a JSON body, &#x60;{ \&quot;id\&quot;: \&quot;evt_...\&quot;, \&quot;type\&quot;: \&quot;invoice.paid\&quot;, \&quot;createdAt\&quot;: \&quot;...\&quot;, \&quot;partnerId\&quot;: \&quot;...\&quot;, \&quot;data\&quot;: { ... } }&#x60; (&#x60;data&#x60; is the &#x60;data&#x60; of &#x60;PartnerNotification&#x60;), and these headers: &#x60;webhook-id&#x60; (the same as &#x60;id&#x60;, and the same on every retry), &#x60;webhook-timestamp&#x60; (seconds since 1970) and &#x60;webhook-signature&#x60; (&#x60;v1,&#x60; and a base64 HMAC-SHA256). It is the Standard Webhooks scheme, so any of its libraries verifies it. By hand: take your secret without the &#x60;whsec_&#x60; prefix, decode it from base64, and sign the text &#x60;&lt;webhook-id&gt;.&lt;webhook-timestamp&gt;.&lt;the raw body&gt;&#x60; with it; the header holds &#x60;v1,&lt;base64 of the result&gt;&#x60; (two signatures separated by a space while a rotated secret overlaps). Reject a &#x60;webhook-timestamp&#x60; that is more than five minutes old.  Answer with a 2xx status within ten seconds. Anything else is tried again, eight attempts in all over about two days (&#x60;listPartnerNotificationDeliveries&#x60; shows each). Delivery is at least once: if your answer was lost the same event arrives again with the same &#x60;id&#x60;, so drop what you have already handled by it.  Changing the settings needs an API key with full access: they decide where your notifications go. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose notification settings to change
+  # @param update_partner_notification_settings_request 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :idempotency_key Optional: without it the call is carried out every time it is sent. 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;).
+  # @return [PartnerNotificationSettingsChangeResponse]
+  describe 'update_partner_notification_settings test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_personal_workspace_domain
+  # Change a website on your list
+  # Replaces the website of one entry on an account&#39;s own list. The same rules apply as when adding one (&#x60;addPersonalWorkspaceDomain&#x60;): a website name such as &#x60;example.com&#x60; or &#x60;*.example.com&#x60;, kept in its cleaned form, and refused when it is not a website name or is already on the list.
+  # @param id The account the list belongs to. For your own, your own user id
+  # @param domain_id The &#x60;id&#x60; of the entry, as the list shows it
+  # @param update_domain_request 
+  # @param [Hash] opts the optional parameters
+  # @return [PersonalWorkspaceDomainResultResponse]
+  describe 'update_personal_workspace_domain test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for update_user_api_key
+  # Rename an API key, or switch it off or on
+  # Renames a key, or switches it off (&#x60;isActive: false&#x60;) or back on. A key that is switched off is refused at once by the server that took the request and within a minute by the others, and can be switched on again; deleting is for a key that is not coming back. The secret, the expiry and the scopes of a key cannot be changed. Only a key with full access can make these requests: a key limited to some scopes is refused with 403 and the code &#x60;API_KEY_SCOPE_MISSING&#x60;. Renaming and switching off can be done with an API key. Switching a key on needs a person signed in on widgetic.com: a request that asks for it with an API key or an SDK token is refused with 403, so a leaked key cannot bring a dormant key back to life.
+  # @param id The account the key belongs to
+  # @param key_id The &#x60;keyId&#x60; of the key, as the list shows it
+  # @param update_user_api_key_request 
+  # @param [Hash] opts the optional parameters
+  # @return [UserApiKeyResponse]
+  describe 'update_user_api_key test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for upload_public_composition_adapter_file
+  # Send the file a visitor chose through the upload adapter of a published widget
+  # The second of the two calls the &#x60;upload&#x60; adapter&#39;s module makes from the visitor&#39;s browser (the first, the &#x60;begin-upload&#x60; operation of &#x60;callPublicCompositionAdapter&#x60;, answers with the ticket this route takes). The module sends the file itself, as the body, with its media type as the &#x60;Content-Type&#x60;. It is not meant to be called by hand, and it takes no API key. **Address.** &#x60;https://api.widgetic.com/embed/compositions/{compositionId}/adapters/upload/files/{ticket}&#x60;: the root of the API host, NOT under &#x60;/v1&#x60;. A client generated from this description for &#x60;https://api.widgetic.com/v1&#x60; must be given the base address &#x60;https://api.widgetic.com&#x60; for the calls of the &#x60;Public Embed&#x60; tag. **The ticket.** Single-use and valid for ten minutes, given for one file: its name, its media type and its exact size are what the visitor said when the ticket was asked for, after the widget&#39;s owner&#39;s settings (the kinds of file they take, the largest size) were applied. The &#x60;Content-Type&#x60; and the &#x60;Content-Length&#x60; of this request must be those, and the body must be exactly that many bytes (400 &#x60;UPLOAD_FILE_CHANGED&#x60; otherwise). The gateway never believes the type it was told: the first bytes of the file must be a file of that type and one the owner accepts (422 otherwise). A ticket whose file was stored and is sent again is answered with the same file, so a visitor whose connection dropped after the file landed does not store it twice; a ticket whose attempt failed is spent, and the module asks for a new one. **What it stores.** The file goes to the widget owner&#39;s storage: Widgetic&#39;s, or the partner&#39;s own bucket for a widget of a customer a partner manages. It counts against the owner&#39;s storage allowance and is filed in the folder the owner chose, as a file sent by a visitor, which the owner&#39;s own file list leaves out. A full allowance, a partner&#39;s storage that cannot be used and a stopped feature are all the same 503 &#x60;UPLOAD_UNAVAILABLE&#x60; to a visitor, and the owner is told through a notice. **Who may call.** The same rule as the entry route: a permitted &#x60;Origin&#x60; header, which is the artifact origin the widget runs from or a website the owner allowed (or the owner&#39;s own platform). A request without a permitted &#x60;Origin&#x60; is 403 &#x60;ORIGIN_NOT_ALLOWED&#x60;. A composition that is not served (unpublished, or its owner&#39;s plan does not serve it) is 404, with the codes of the other public embed routes. **Limits.** 30 requests a minute for each visitor address and composition and 240 a minute for a composition (429 &#x60;RATE_LIMITED&#x60;, with a &#x60;Retry-After&#x60; header); at most 10 MB for a file, and only so many files held in memory at once on each gateway process (503 &#x60;UPLOAD_BUSY&#x60;, with a &#x60;Retry-After&#x60;). A file that does not arrive within two minutes is 408 &#x60;UPLOAD_TIMEOUT&#x60;. Every answer but a success closes the connection, so a client that is refused before it has sent the file reads the answer and stops.
+  # @param composition_id 
+  # @param ticket The ticket the &#x60;begin-upload&#x60; operation answered with.
+  # @param body 
+  # @param [Hash] opts the optional parameters
+  # @return [PublicAdapterFileResult]
+  describe 'upload_public_composition_adapter_file test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for uploads_get
+  # List the account&#39;s uploads
+  # The files the account has uploaded, newest first. Deleted files are not listed. Returns at most &#x60;limit&#x60; files and has no further pages: a client that needs more narrows the list instead, for example to one managed user&#39;s files with &#x60;managedUserId&#x60; or &#x60;managedUserExternalId&#x60;. The files that visitors sent through a widget&#39;s upload adapter (&#x60;source&#x60; is &#x60;widget-visitor-upload&#x60;) are not part of this list, so that a popular widget does not push the account&#39;s own files out of it; naming one widget with &#x60;widgetId&#x60; lists what visitors sent to that widget as well. 
+  # @param [Hash] opts the optional parameters
+  # @option opts [Integer] :limit Maximum number of files to return
+  # @option opts [String] :managed_user_id List only the files uploaded for this managed user (Widgetic&#39;s id for the user). Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id List only the files uploaded for the managed user you registered with this &#x60;externalId&#x60; (your own identifier for the user). Send this or &#x60;managedUserId&#x60;, not both.
+  # @return [UploadsGet200Response]
+  describe 'uploads_get test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for uploads_id_delete
+  # Delete an upload
+  # Removes the stored file and the upload row. A file in Widgetic&#39;s own storage gives back the space it took from your storage allowance; a file in your own bucket is removed from your bucket. Deleting an upload that is already gone succeeds the same way as the first delete. An upload that belongs to another account is not found. If the storage cannot be reached the call fails and nothing is marked deleted, so it can be repeated. 
+  # @param id 
+  # @param [Hash] opts the optional parameters
+  # @return [UploadsIdDelete200Response]
+  describe 'uploads_id_delete test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for uploads_id_get
+  # Get an upload by id
+  # The details of one of the account&#39;s uploads. An upload that belongs to another account is not found.
+  # @param id The upload to read
+  # @param [Hash] opts the optional parameters
+  # @return [UploadResponse]
+  describe 'uploads_id_get test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for uploads_limits_get
+  # Upload size limits and accepted file types
+  # The size limit and the accepted file types of the upload endpoints. Read them from here rather than hard-coding thresholds: they are configuration and can change. The limits are the same for every account, whatever its plan: &#x60;multipart_max_bytes&#x60; for a file sent in one request (10 MB) and &#x60;tus_max_bytes&#x60; for a resumable upload (250 MB). 
+  # @param [Hash] opts the optional parameters
+  # @return [UploadLimitsResponse]
+  describe 'uploads_limits_get test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for uploads_post
+  # Upload a file
+  # Stores one file for the account and returns its public address. This is how a user&#39;s own images, video and PDFs reach a widget&#39;s content.  Send a &#x60;multipart/form-data&#x60; request with the file in the field named &#x60;file&#x60;. The file counts against the storage of the workspace it is uploaded in, and a full workspace is refused with 413 and &#x60;QUOTA_STORAGE_EXCEEDED&#x60;. For a person signed in on widgetic.com that is the workspace they are currently working in: inside a team, the team&#39;s shared storage; inside their own workspace, their own allowance. An organization API key, and a Shopify store&#39;s session, always work in that team&#39;s shared storage. A personal API key or an SDK token always uses the account&#39;s own allowance. The two never add up and one never lends room to the other. A file over the size limit is refused with 413 and &#x60;UPLOAD_TOO_LARGE&#x60;, and a type that is not accepted with 415 and &#x60;UPLOAD_UNSUPPORTED_TYPE&#x60;; &#x60;uploadsLimitsGet&#x60; lists the size limit and the accepted types.  A file is judged by what is in it, not by the type it is sent as. A file that is not the type it claims (a web page sent as &#x60;image/png&#x60;) is refused with 415 and &#x60;UPLOAD_UNSUPPORTED_TYPE&#x60;, and a picture sent under the wrong picture type is stored under the type it really is, which &#x60;mime_type&#x60; in the answer says. An SVG is rewritten as it is stored: script, &#x60;foreignObject&#x60;, animation and references to other addresses are taken out, it must be UTF-8 and at most 2 MB, and the stored file can be larger or smaller than the one sent. Anything that is not an image, audio or video (a PDF, for example) is served as a download rather than shown in a page.  When the full storage is a Shopify store&#39;s team&#39;s, extra storage cannot be added through Shopify yet, so the message ends by saying so and what to do instead: delete files, or contact support. On a Solo plan it names the Teams plan (which holds more) and &#x60;error.details.planPageUrl&#x60; is the address of the plan page on Shopify. &#x60;error.suggestedAction&#x60; says the same in a few words, instead of the usual \&quot;upgrade your storage plan\&quot;. Any other team, and a person&#39;s own workspace, get the shorter message.  To upload the file for one of your managed users, send &#x60;managedUserId&#x60; (Widgetic&#39;s id for the user) or &#x60;managedUserExternalId&#x60; (your own identifier for the user), not both. The file stays in your account and counts against its allowance; the tag lets you list one user&#39;s files with &#x60;uploadsGet&#x60;. The managed user must be yours and active: one that is not yours, or does not exist, is refused with 404 and &#x60;MANAGED_USER_NOT_FOUND&#x60;, and one that is switched off with 409 and &#x60;MANAGED_USER_INACTIVE&#x60;, before the file is stored. The tag is set here and does not change afterwards.  Called with an editor session (&#x60;createManagedUserEditorSession&#x60;), the file is always filed for the session&#39;s own managed user and is always media for widget content: naming another managed user is refused with 403 and &#x60;MANAGED_USER_SESSION_MISMATCH&#x60;, and &#x60;contextType&#x60;, &#x60;source&#x60;, &#x60;widgetId&#x60; and &#x60;conversationId&#x60; are ignored. A full storage allowance is refused with the same 413 and &#x60;QUOTA_STORAGE_EXCEEDED&#x60;, but the message only says that it is not available right now (not how much is stored: that is the partner&#39;s business) and &#x60;error.details.limit&#x60; is &#x60;storage&#x60;.  An account that administers a partner with a storage destination (&#x60;setPartnerStorageDestination&#x60;) has its files stored in the partner&#39;s own bucket instead. Such a file takes none of the allowance, its &#x60;url&#x60; is served from the partner&#39;s public address, and its &#x60;storage_key&#x60; is the key in the partner&#39;s bucket. The file is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 and &#x60;STORAGE_DESTINATION_UNAVAILABLE&#x60;, and when the partner&#39;s storage rejects the file with 502 and &#x60;STORAGE_DESTINATION_WRITE_FAILED&#x60;.  Partner storage is not optional, and it does not depend on how the file arrives. A partner&#39;s own uploads (with its API key, an SDK token, or from the Widgetic website, the resumable route and the media library alike) and the uploads of its customers&#39; editor sessions are kept in the partner&#39;s own storage or not at all, so a partner with no destination (or one that removed it after the session was made) has them refused with 409 and &#x60;PARTNER_STORAGE_REQUIRED&#x60;; they are never stored with Widgetic. An editor session&#39;s browser is only told that the feature is not available right now. 
+  # @param file The file to store
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :context_type What the file is for. Send &#x60;content-property&#x60; for media that becomes widget content (images, video and PDF); the other values are used by Widgetic&#39;s own editor. 
+  # @option opts [String] :source Which part of the product, or which client, the file comes from
+  # @option opts [String] :managed_user_id Upload the file for one of your managed users, by Widgetic&#39;s id for the user. Send this or &#x60;managedUserExternalId&#x60;, not both.
+  # @option opts [String] :managed_user_external_id The same, by your own identifier for the user, the &#x60;externalId&#x60; you gave when you created the managed user. Send this or &#x60;managedUserId&#x60;, not both.
+  # @option opts [String] :purpose Where in your product you use the file. It is kept with the file, so that a customer&#39;s storage can be counted by purpose (&#x60;getManagedUserStorageUsage&#x60;). Optional; any other value is refused with 400 and &#x60;UPLOAD_INVALID_PURPOSE&#x60;.
+  # @return [UploadResponse]
+  describe 'uploads_post test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for validate_composition_content
+  # Validate Content
+  # Checks content against the composition&#39;s widget schema without saving it. Send what a content update (&#x60;PUT /compositions/{id}/content&#x60;) would store, &#x60;{ \&quot;design\&quot;: {...}, \&quot;content\&quot;: {...} }&#x60;, or the widget&#39;s values alone. Each value is checked by the kind of field the widget declares for it: text, a number within the limits of its slider, true or false, one of the choices of a dropdown, a color, a font, the address of an image, a date. The items of the widget&#39;s list are checked the same way, and their number against the limits of the list. A value that cannot be what the field holds, or a number outside its range, is an error and &#x60;valid&#x60; is false. Text longer than the field takes, a number or true/false sent as text, and a name the widget has no field for are warnings, and &#x60;valid&#x60; stays true. The design is not checked here. Nothing is saved and nothing in the body is changed.
+  # @param id ID of the composition
+  # @param idempotency_key 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;).
+  # @param request_body 
+  # @param [Hash] opts the optional parameters
+  # @option opts [String] :x_managed_user_id The id Widgetic gave the managed user (&#x60;POST /managed-users&#x60;). Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @option opts [String] :x_managed_user_external_id Your own id for the managed user (its &#x60;externalId&#x60;), when you do not keep Widgetic&#39;s. Makes this call for one of your managed users, so that a mistake in your own code cannot reach another customer&#39;s work. Send this header, or the other one, never both. Left out, the call works on your whole account, as it always has. With it, the call reaches only that user&#39;s compositions: a list shows only theirs, a composition the call makes is filed under them, and a composition of another user, or one that does not exist, answers &#x60;404&#x60; (the same answer, so the call cannot be used to find out what another customer has). A managed user that is not yours answers &#x60;404&#x60; with &#x60;MANAGED_USER_NOT_FOUND&#x60;. An empty, repeated or malformed header is &#x60;400&#x60; with &#x60;MANAGED_USER_SCOPE_INVALID&#x60;; an empty header is never read as no header. A call that is about the whole account, such as the list of your managed users, is refused with &#x60;403&#x60; and &#x60;MANAGED_USER_SCOPE_ROUTE_NOT_AVAILABLE&#x60;: send it without the header. Only your API key can send it. The header is a limit the call asks for: whoever holds the key can leave it out, so for a credential that a customer&#39;s browser holds, use an editor session. An &#x60;Idempotency-Key&#x60; is kept apart for each managed user.
+  # @return [ValidateCompositionContentResponse]
+  describe 'validate_composition_content test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for validate_token
+  # Validate current authentication token
+  # @param [Hash] opts the optional parameters
+  # @return [ValidateToken200Response]
+  describe 'validate_token test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for verify_partner_data_database
+  # Check that a partner&#39;s own database still works
+  # Runs the same check as &#x60;setPartnerDataDatabase&#x60; against the database already saved: a schema is made in it, a table created, a row written and read back, and the schema removed again. Use it after changing the role&#39;s password or the project&#39;s settings in Neon, or when saving is failing with 503 &#x60;PARTNER_DATABASE_UNAVAILABLE&#x60;.  The result is recorded either way. A pass refreshes &#x60;verifiedAt&#x60; and clears &#x60;lastVerificationError&#x60;; a failure answers 422 &#x60;PARTNER_DATABASE_UNVERIFIED&#x60; and is recorded in &#x60;lastVerificationError&#x60; and &#x60;lastVerificationFailedAt&#x60;, so the database shows what went wrong the next time it is read. A failed check does not remove the database. &#x60;details.reason&#x60; is one of the reasons &#x60;setPartnerDataDatabase&#x60; lists, or &#x60;STORED_STRING_UNREADABLE&#x60; when the connection string Widgetic stored can no longer be read: set the database again, with its connection string.  This needs an API key with full access. The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose database to check
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerDataDatabaseResponse]
+  describe 'verify_partner_data_database test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+  # unit tests for verify_partner_storage_destination
+  # Check that a partner&#39;s storage destination still works
+  # Runs the same check as &#x60;setPartnerStorageDestination&#x60; against the destination already saved: a test file is written, read back from the public address and deleted. Use it after rotating a key or changing a bucket policy, or when uploads are failing with 502 or 503.  The result is recorded either way. A pass refreshes &#x60;verifiedAt&#x60; and clears &#x60;lastVerificationError&#x60;; a failure answers 422 &#x60;STORAGE_DESTINATION_UNVERIFIED&#x60; and is recorded in &#x60;lastVerificationError&#x60; and &#x60;lastVerificationFailedAt&#x60;, so the destination shows what went wrong the next time it is read. A failed check does not remove the destination or stop uploads from using it.  The caller must be the person who administers the partner, or a Widgetic administrator. 
+  # @param partner_id The partner whose storage destination to check
+  # @param [Hash] opts the optional parameters
+  # @return [PartnerStorageDestinationResponse]
+  describe 'verify_partner_storage_destination test' do
+    it 'should work' do
+      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    end
+  end
+
+end