api-sdk-rb 1.11.66 → 1.11.133

data/lib/api-sdk-rb/api/public_embed_api.rb

@@ -20,63 +20,63 @@ module ApiSdkRb
       @api_client = api_client
     end
     # 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).
+    # 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 any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic's own sites, the visitor's own machine 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 [String] 
     # @param adapter_id [String] The id of the adapter, the name its module is known by, for example `upload`.
     # @param operation [String] The name of one operation of the adapter, as its documentation gives it.
     # @param public_adapter_call_request [PublicAdapterCallRequest] 
     # @param [Hash] opts the optional parameters
     # @return [PublicAdapterCallResult]
-    def call_public_composition_adapter_0(composition_id, adapter_id, operation, public_adapter_call_request, opts = {})
-      data, _status_code, _headers = call_public_composition_adapter_0_with_http_info(composition_id, adapter_id, operation, public_adapter_call_request, opts)
+    def call_public_composition_adapter(composition_id, adapter_id, operation, public_adapter_call_request, opts = {})
+      data, _status_code, _headers = call_public_composition_adapter_with_http_info(composition_id, adapter_id, operation, public_adapter_call_request, opts)
       data
     end
 
     # 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).
+    # 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 any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic's own sites, the visitor's own machine 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 [String] 
     # @param adapter_id [String] The id of the adapter, the name its module is known by, for example `upload`.
     # @param operation [String] The name of one operation of the adapter, as its documentation gives it.
     # @param public_adapter_call_request [PublicAdapterCallRequest] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(PublicAdapterCallResult, Integer, Hash)>] PublicAdapterCallResult data, response status code and response headers
-    def call_public_composition_adapter_0_with_http_info(composition_id, adapter_id, operation, public_adapter_call_request, opts = {})
+    def call_public_composition_adapter_with_http_info(composition_id, adapter_id, operation, public_adapter_call_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.call_public_composition_adapter_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.call_public_composition_adapter ...'
       end
       # verify the required parameter 'composition_id' is set
       if @api_client.config.client_side_validation && composition_id.nil?
-        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.call_public_composition_adapter_0"
+        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.call_public_composition_adapter"
       end
       # verify the required parameter 'adapter_id' is set
       if @api_client.config.client_side_validation && adapter_id.nil?
-        fail ArgumentError, "Missing the required parameter 'adapter_id' when calling PublicEmbedApi.call_public_composition_adapter_0"
+        fail ArgumentError, "Missing the required parameter 'adapter_id' when calling PublicEmbedApi.call_public_composition_adapter"
       end
       if @api_client.config.client_side_validation && adapter_id.to_s.length > 40
-        fail ArgumentError, 'invalid value for "adapter_id" when calling PublicEmbedApi.call_public_composition_adapter_0, the character length must be smaller than or equal to 40.'
+        fail ArgumentError, 'invalid value for "adapter_id" when calling PublicEmbedApi.call_public_composition_adapter, the character length must be smaller than or equal to 40.'
       end
 
       pattern = Regexp.new(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/)
       if @api_client.config.client_side_validation && adapter_id !~ pattern
-        fail ArgumentError, "invalid value for 'adapter_id' when calling PublicEmbedApi.call_public_composition_adapter_0, must conform to the pattern #{pattern}."
+        fail ArgumentError, "invalid value for 'adapter_id' when calling PublicEmbedApi.call_public_composition_adapter, must conform to the pattern #{pattern}."
       end
 
       # verify the required parameter 'operation' is set
       if @api_client.config.client_side_validation && operation.nil?
-        fail ArgumentError, "Missing the required parameter 'operation' when calling PublicEmbedApi.call_public_composition_adapter_0"
+        fail ArgumentError, "Missing the required parameter 'operation' when calling PublicEmbedApi.call_public_composition_adapter"
       end
       if @api_client.config.client_side_validation && operation.to_s.length > 40
-        fail ArgumentError, 'invalid value for "operation" when calling PublicEmbedApi.call_public_composition_adapter_0, the character length must be smaller than or equal to 40.'
+        fail ArgumentError, 'invalid value for "operation" when calling PublicEmbedApi.call_public_composition_adapter, the character length must be smaller than or equal to 40.'
       end
 
       pattern = Regexp.new(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/)
       if @api_client.config.client_side_validation && operation !~ pattern
-        fail ArgumentError, "invalid value for 'operation' when calling PublicEmbedApi.call_public_composition_adapter_0, must conform to the pattern #{pattern}."
+        fail ArgumentError, "invalid value for 'operation' when calling PublicEmbedApi.call_public_composition_adapter, must conform to the pattern #{pattern}."
       end
 
       # verify the required parameter 'public_adapter_call_request' is set
       if @api_client.config.client_side_validation && public_adapter_call_request.nil?
-        fail ArgumentError, "Missing the required parameter 'public_adapter_call_request' when calling PublicEmbedApi.call_public_composition_adapter_0"
+        fail ArgumentError, "Missing the required parameter 'public_adapter_call_request' when calling PublicEmbedApi.call_public_composition_adapter"
       end
       # resource path
       local_var_path = '/embed/compositions/{compositionId}/adapters/{adapterId}/{operation}'.sub('{' + 'compositionId' + '}', CGI.escape(composition_id.to_s)).sub('{' + 'adapterId' + '}', CGI.escape(adapter_id.to_s)).sub('{' + 'operation' + '}', CGI.escape(operation.to_s))
@@ -107,7 +107,7 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.call_public_composition_adapter_0",
+        :operation => :"PublicEmbedApi.call_public_composition_adapter",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -118,48 +118,55 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#call_public_composition_adapter_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#call_public_composition_adapter\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
     # 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`.
+    # 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 any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic's own sites, the visitor's own machine or the owner's own platform). 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 [String] 
     # @param table [String] 
     # @param public_composition_entry_request [PublicCompositionEntryRequest] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_widgetic_write_token Signed per-composition write token handed to the widget in &#x60;widgetic:host&#x60; as &#x60;entries.writeToken&#x60; (and returned by &#x60;GET /embed/compositions/{compositionId}&#x60; as &#x60;entryWriteToken&#x60;). Required when the request comes from the shared Widgetic artifact origin; verified whenever present.
+    # @option opts [String] :x_widgetic_visitor_id A random id the widget&#39;s browser makes once and keeps (16 to 64 characters of &#x60;A-Za-z0-9_-&#x60;), sent so a table&#39;s per-visitor &#x60;limit&#x60; (declared in the widget database file) can count this browser. Not an identity and not a secret. Without it, or with a malformed value, the limit counts only by network address.
     # @return [PublicCompositionEntryCreated]
-    def create_public_composition_entry_0(composition_id, table, public_composition_entry_request, opts = {})
-      data, _status_code, _headers = create_public_composition_entry_0_with_http_info(composition_id, table, public_composition_entry_request, opts)
+    def create_public_composition_entry(composition_id, table, public_composition_entry_request, opts = {})
+      data, _status_code, _headers = create_public_composition_entry_with_http_info(composition_id, table, public_composition_entry_request, opts)
       data
     end
 
     # 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 &#x60;Origin&#x60; 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 (&#x60;X-Widgetic-Write-Token&#x60; header or &#x60;writeToken&#x60; body field, handed to the widget in &#x60;widgetic:host&#x60; as &#x60;entries.writeToken&#x60; and returned as &#x60;entryWriteToken&#x60; on &#x60;getPublicCompositionEmbed&#x60;). Host &#x60;context&#x60; 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.** &#x60;https://api.widgetic.com/embed/compositions/{compositionId}/entries/{table}&#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. **Signed context.** A partner that wants to trust &#x60;context&#x60; (to bill a customer by it, say) makes a signing secret (&#x60;rotatePartnerEntryContextSecret&#x60;), and its server signs the context it hands to the embed. The signature travels inside &#x60;context&#x60; as two reserved keys, &#x60;widgetic_exp&#x60; (UTC seconds, at most seven days ahead) and &#x60;widgetic_sig&#x60;. The gateway checks them after the &#x60;Origin&#x60; 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 &#x60;CONTEXT_SIGNATURE_REQUIRED&#x60;, &#x60;CONTEXT_SIGNATURE_INVALID&#x60; or &#x60;CONTEXT_SIGNATURE_EXPIRED&#x60;; when the check cannot be made just now the answer is a retryable 503 &#x60;CONTEXT_SIGNATURE_UNAVAILABLE&#x60;, 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 &#x60;widgetic_exp&#x60; and may be used again until then, so a partner that must count each submission once keeps a unique value of its own (a &#x60;submissionId&#x60;, say) in the context. The recipe and a test vector are in the description of &#x60;rotatePartnerEntryContextSecret&#x60;.
+    # Public append-only write into a published composition database. No API key. The browser must send a permitted &#x60;Origin&#x60; header: the artifact iframe origin, or any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic&#39;s own sites, the visitor&#39;s own machine or the owner&#39;s own platform). When the request comes from the shared artifact origin, it must also carry the per-composition write token (&#x60;X-Widgetic-Write-Token&#x60; header or &#x60;writeToken&#x60; body field, handed to the widget in &#x60;widgetic:host&#x60; as &#x60;entries.writeToken&#x60; and returned as &#x60;entryWriteToken&#x60; on &#x60;getPublicCompositionEmbed&#x60;). Host &#x60;context&#x60; 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.** &#x60;https://api.widgetic.com/embed/compositions/{compositionId}/entries/{table}&#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. **Signed context.** A partner that wants to trust &#x60;context&#x60; (to bill a customer by it, say) makes a signing secret (&#x60;rotatePartnerEntryContextSecret&#x60;), and its server signs the context it hands to the embed. The signature travels inside &#x60;context&#x60; as two reserved keys, &#x60;widgetic_exp&#x60; (UTC seconds, at most seven days ahead) and &#x60;widgetic_sig&#x60;. The gateway checks them after the &#x60;Origin&#x60; 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 &#x60;CONTEXT_SIGNATURE_REQUIRED&#x60;, &#x60;CONTEXT_SIGNATURE_INVALID&#x60; or &#x60;CONTEXT_SIGNATURE_EXPIRED&#x60;; when the check cannot be made just now the answer is a retryable 503 &#x60;CONTEXT_SIGNATURE_UNAVAILABLE&#x60;, 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 &#x60;widgetic_exp&#x60; and may be used again until then, so a partner that must count each submission once keeps a unique value of its own (a &#x60;submissionId&#x60;, say) in the context. The recipe and a test vector are in the description of &#x60;rotatePartnerEntryContextSecret&#x60;.
     # @param composition_id [String] 
     # @param table [String] 
     # @param public_composition_entry_request [PublicCompositionEntryRequest] 
     # @param [Hash] opts the optional parameters
     # @option opts [String] :x_widgetic_write_token Signed per-composition write token handed to the widget in &#x60;widgetic:host&#x60; as &#x60;entries.writeToken&#x60; (and returned by &#x60;GET /embed/compositions/{compositionId}&#x60; as &#x60;entryWriteToken&#x60;). Required when the request comes from the shared Widgetic artifact origin; verified whenever present.
+    # @option opts [String] :x_widgetic_visitor_id A random id the widget&#39;s browser makes once and keeps (16 to 64 characters of &#x60;A-Za-z0-9_-&#x60;), sent so a table&#39;s per-visitor &#x60;limit&#x60; (declared in the widget database file) can count this browser. Not an identity and not a secret. Without it, or with a malformed value, the limit counts only by network address.
     # @return [Array<(PublicCompositionEntryCreated, Integer, Hash)>] PublicCompositionEntryCreated data, response status code and response headers
-    def create_public_composition_entry_0_with_http_info(composition_id, table, public_composition_entry_request, opts = {})
+    def create_public_composition_entry_with_http_info(composition_id, table, public_composition_entry_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.create_public_composition_entry_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.create_public_composition_entry ...'
       end
       # verify the required parameter 'composition_id' is set
       if @api_client.config.client_side_validation && composition_id.nil?
-        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.create_public_composition_entry_0"
+        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.create_public_composition_entry"
       end
       # verify the required parameter 'table' is set
       if @api_client.config.client_side_validation && table.nil?
-        fail ArgumentError, "Missing the required parameter 'table' when calling PublicEmbedApi.create_public_composition_entry_0"
+        fail ArgumentError, "Missing the required parameter 'table' when calling PublicEmbedApi.create_public_composition_entry"
       end
       # verify the required parameter 'public_composition_entry_request' is set
       if @api_client.config.client_side_validation && public_composition_entry_request.nil?
-        fail ArgumentError, "Missing the required parameter 'public_composition_entry_request' when calling PublicEmbedApi.create_public_composition_entry_0"
+        fail ArgumentError, "Missing the required parameter 'public_composition_entry_request' when calling PublicEmbedApi.create_public_composition_entry"
       end
+      pattern = Regexp.new(/^[A-Za-z0-9_-]{16,64}$/)
+      if @api_client.config.client_side_validation && !opts[:'x_widgetic_visitor_id'].nil? && opts[:'x_widgetic_visitor_id'] !~ pattern
+        fail ArgumentError, "invalid value for 'opts[:\"x_widgetic_visitor_id\"]' when calling PublicEmbedApi.create_public_composition_entry, must conform to the pattern #{pattern}."
+      end
+
       # resource path
       local_var_path = '/embed/compositions/{compositionId}/entries/{table}'.sub('{' + 'compositionId' + '}', CGI.escape(composition_id.to_s)).sub('{' + 'table' + '}', CGI.escape(table.to_s))
 
@@ -176,6 +183,7 @@ module ApiSdkRb
           header_params['Content-Type'] = content_type
       end
       header_params[:'X-Widgetic-Write-Token'] = opts[:'x_widgetic_write_token'] if !opts[:'x_widgetic_write_token'].nil?
+      header_params[:'X-Widgetic-Visitor-Id'] = opts[:'x_widgetic_visitor_id'] if !opts[:'x_widgetic_visitor_id'].nil?
 
       # form parameters
       form_params = opts[:form_params] || {}
@@ -190,7 +198,7 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.create_public_composition_entry_0",
+        :operation => :"PublicEmbedApi.create_public_composition_entry",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -201,7 +209,7 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#create_public_composition_entry_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#create_public_composition_entry\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -211,8 +219,8 @@ module ApiSdkRb
     # @param composition_id [String] 
     # @param [Hash] opts the optional parameters
     # @return [GetPublicCompositionEmbed200Response]
-    def get_public_composition_embed_0(composition_id, opts = {})
-      data, _status_code, _headers = get_public_composition_embed_0_with_http_info(composition_id, opts)
+    def get_public_composition_embed(composition_id, opts = {})
+      data, _status_code, _headers = get_public_composition_embed_with_http_info(composition_id, opts)
       data
     end
 
@@ -221,13 +229,13 @@ module ApiSdkRb
     # @param composition_id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(GetPublicCompositionEmbed200Response, Integer, Hash)>] GetPublicCompositionEmbed200Response data, response status code and response headers
-    def get_public_composition_embed_0_with_http_info(composition_id, opts = {})
+    def get_public_composition_embed_with_http_info(composition_id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_composition_embed_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_composition_embed ...'
       end
       # verify the required parameter 'composition_id' is set
       if @api_client.config.client_side_validation && composition_id.nil?
-        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.get_public_composition_embed_0"
+        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.get_public_composition_embed"
       end
       # resource path
       local_var_path = '/embed/compositions/{compositionId}'.sub('{' + 'compositionId' + '}', CGI.escape(composition_id.to_s))
@@ -253,7 +261,7 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.get_public_composition_embed_0",
+        :operation => :"PublicEmbedApi.get_public_composition_embed",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -264,7 +272,7 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_composition_embed_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_composition_embed\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -274,8 +282,8 @@ module ApiSdkRb
     # @param composition_id [String] 
     # @param [Hash] opts the optional parameters
     # @return [String]
-    def get_public_composition_iframe_0(composition_id, opts = {})
-      data, _status_code, _headers = get_public_composition_iframe_0_with_http_info(composition_id, opts)
+    def get_public_composition_iframe(composition_id, opts = {})
+      data, _status_code, _headers = get_public_composition_iframe_with_http_info(composition_id, opts)
       data
     end
 
@@ -284,13 +292,13 @@ module ApiSdkRb
     # @param composition_id [String] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(String, Integer, Hash)>] String data, response status code and response headers
-    def get_public_composition_iframe_0_with_http_info(composition_id, opts = {})
+    def get_public_composition_iframe_with_http_info(composition_id, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_composition_iframe_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_composition_iframe ...'
       end
       # verify the required parameter 'composition_id' is set
       if @api_client.config.client_side_validation && composition_id.nil?
-        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.get_public_composition_iframe_0"
+        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.get_public_composition_iframe"
       end
       # resource path
       local_var_path = '/embed/compositions/{compositionId}/frame'.sub('{' + 'compositionId' + '}', CGI.escape(composition_id.to_s))
@@ -316,7 +324,133 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.get_public_composition_iframe_0",
+        :operation => :"PublicEmbedApi.get_public_composition_iframe",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_composition_iframe\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Read the published Workflow of an embed
+    # Public read of a workflow for the embed that carries `workflow-id`. No API key. The answer is the live version (its graph, the composition a new visitor starts on, the time zone, the languages its compositions can be shown in, and the token that lets the browser report counts), or `status: paused` with nothing else, in which case the embed shows only its first composition. A workflow that is a draft, archived or unknown answers 404, and the embed then behaves as a plain embed of its `composition-id`. So does a workflow whose owner is not being served (a plan that lapsed, a partner whose agreement is not in force): the answer is the one the compositions of that owner give. **Address.** `https://api.widgetic.com/embed/workflows/{workflowId}`: 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. The answer may be reused for a few seconds (`Cache-Control: public, max-age=15`), so a publish or a pause reaches visitors within moments. The graph is readable by anyone who has the workflow's id: its rules run in the visitor's browser, so a rule must never hold a secret.
+    # @param workflow_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [PublicWorkflowResponse]
+    def get_public_workflow(workflow_id, opts = {})
+      data, _status_code, _headers = get_public_workflow_with_http_info(workflow_id, opts)
+      data
+    end
+
+    # Read the published Workflow of an embed
+    # Public read of a workflow for the embed that carries &#x60;workflow-id&#x60;. No API key. The answer is the live version (its graph, the composition a new visitor starts on, the time zone, the languages its compositions can be shown in, and the token that lets the browser report counts), or &#x60;status: paused&#x60; with nothing else, in which case the embed shows only its first composition. A workflow that is a draft, archived or unknown answers 404, and the embed then behaves as a plain embed of its &#x60;composition-id&#x60;. So does a workflow whose owner is not being served (a plan that lapsed, a partner whose agreement is not in force): the answer is the one the compositions of that owner give. **Address.** &#x60;https://api.widgetic.com/embed/workflows/{workflowId}&#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 answer may be reused for a few seconds (&#x60;Cache-Control: public, max-age&#x3D;15&#x60;), so a publish or a pause reaches visitors within moments. The graph is readable by anyone who has the workflow&#39;s id: its rules run in the visitor&#39;s browser, so a rule must never hold a secret.
+    # @param workflow_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(PublicWorkflowResponse, Integer, Hash)>] PublicWorkflowResponse data, response status code and response headers
+    def get_public_workflow_with_http_info(workflow_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_workflow ...'
+      end
+      # verify the required parameter 'workflow_id' is set
+      if @api_client.config.client_side_validation && workflow_id.nil?
+        fail ArgumentError, "Missing the required parameter 'workflow_id' when calling PublicEmbedApi.get_public_workflow"
+      end
+      # resource path
+      local_var_path = '/embed/workflows/{workflowId}'.sub('{' + 'workflowId' + '}', CGI.escape(workflow_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PublicWorkflowResponse'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"PublicEmbedApi.get_public_workflow",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_workflow\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Show a published Workflow in a page of its own
+    # A page that runs a published workflow, for a place that can only be given an address or an iframe: a chat messenger, a link page, a site builder, a blog that follows oEmbed. No API key, no SDK to add. The page holds the Embed SDK and the same tag a website carries (`<widgetic workflow-id composition-id>`), so a visitor moves from one composition to the next in place, by the same rules, exactly as on a website. A paused workflow shows its first composition alone, as its embeds do. **What the frame can count.** Only what happens inside it: entries, a widget's goals and actions, and waits. The page events a website can send to a workflow (`widgetic:workflow-event`) are events of the page around the embed, and they do not cross an iframe, so a connection that waits for one never fires from a frame. A workflow that is a draft, is archived, or does not exist, and one whose owner is not being served, answers 404 with a short page that gives no reason. If the owner of the workflow's first composition listed the websites it may appear on, the page is sent with `Content-Security-Policy: frame-ancestors` naming those websites (and Widgetic'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. Opening the address directly still works. An owner who listed nothing is not restricted. The page links its oEmbed card, so a site that follows oEmbed turns the address of the frame into an embed. **Address.** `https://api.widgetic.com/embed/workflows/{workflowId}/frame`: 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.
+    # @param workflow_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [String]
+    def get_public_workflow_frame(workflow_id, opts = {})
+      data, _status_code, _headers = get_public_workflow_frame_with_http_info(workflow_id, opts)
+      data
+    end
+
+    # Show a published Workflow in a page of its own
+    # A page that runs a published workflow, for a place that can only be given an address or an iframe: a chat messenger, a link page, a site builder, a blog that follows oEmbed. No API key, no SDK to add. The page holds the Embed SDK and the same tag a website carries (&#x60;&lt;widgetic workflow-id composition-id&gt;&#x60;), so a visitor moves from one composition to the next in place, by the same rules, exactly as on a website. A paused workflow shows its first composition alone, as its embeds do. **What the frame can count.** Only what happens inside it: entries, a widget&#39;s goals and actions, and waits. The page events a website can send to a workflow (&#x60;widgetic:workflow-event&#x60;) are events of the page around the embed, and they do not cross an iframe, so a connection that waits for one never fires from a frame. A workflow that is a draft, is archived, or does not exist, and one whose owner is not being served, answers 404 with a short page that gives no reason. If the owner of the workflow&#39;s first composition 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. Opening the address directly still works. An owner who listed nothing is not restricted. The page links its oEmbed card, so a site that follows oEmbed turns the address of the frame into an embed. **Address.** &#x60;https://api.widgetic.com/embed/workflows/{workflowId}/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 workflow_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(String, Integer, Hash)>] String data, response status code and response headers
+    def get_public_workflow_frame_with_http_info(workflow_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_workflow_frame ...'
+      end
+      # verify the required parameter 'workflow_id' is set
+      if @api_client.config.client_side_validation && workflow_id.nil?
+        fail ArgumentError, "Missing the required parameter 'workflow_id' when calling PublicEmbedApi.get_public_workflow_frame"
+      end
+      # resource path
+      local_var_path = '/embed/workflows/{workflowId}/frame'.sub('{' + 'workflowId' + '}', CGI.escape(workflow_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['text/html', 'application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'String'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"PublicEmbedApi.get_public_workflow_frame",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -327,7 +461,76 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_composition_iframe_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_workflow_frame\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Read one published version of a Workflow
+    # Public read of one version of a workflow, for a visitor who started on it before a newer one was published: they finish on the version they started on (for up to 30 days; after that they get the latest). The graph of a version never changes once published; the languages its compositions can be shown in (`translations`) are read each time, as for the live version. Like the read of the live version, it answers `status: paused` with nothing else while the workflow is paused, and 404 when the workflow is a draft or archived, or has no such version. **Address.** `https://api.widgetic.com/embed/workflows/{workflowId}/versions/{versionId}`: 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.
+    # @param workflow_id [String] 
+    # @param version_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [PublicWorkflowResponse]
+    def get_public_workflow_version(workflow_id, version_id, opts = {})
+      data, _status_code, _headers = get_public_workflow_version_with_http_info(workflow_id, version_id, opts)
+      data
+    end
+
+    # Read one published version of a Workflow
+    # Public read of one version of a workflow, for a visitor who started on it before a newer one was published: they finish on the version they started on (for up to 30 days; after that they get the latest). The graph of a version never changes once published; the languages its compositions can be shown in (&#x60;translations&#x60;) are read each time, as for the live version. Like the read of the live version, it answers &#x60;status: paused&#x60; with nothing else while the workflow is paused, and 404 when the workflow is a draft or archived, or has no such version. **Address.** &#x60;https://api.widgetic.com/embed/workflows/{workflowId}/versions/{versionId}&#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 workflow_id [String] 
+    # @param version_id [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(PublicWorkflowResponse, Integer, Hash)>] PublicWorkflowResponse data, response status code and response headers
+    def get_public_workflow_version_with_http_info(workflow_id, version_id, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.get_public_workflow_version ...'
+      end
+      # verify the required parameter 'workflow_id' is set
+      if @api_client.config.client_side_validation && workflow_id.nil?
+        fail ArgumentError, "Missing the required parameter 'workflow_id' when calling PublicEmbedApi.get_public_workflow_version"
+      end
+      # verify the required parameter 'version_id' is set
+      if @api_client.config.client_side_validation && version_id.nil?
+        fail ArgumentError, "Missing the required parameter 'version_id' when calling PublicEmbedApi.get_public_workflow_version"
+      end
+      # resource path
+      local_var_path = '/embed/workflows/{workflowId}/versions/{versionId}'.sub('{' + 'workflowId' + '}', CGI.escape(workflow_id.to_s)).sub('{' + 'versionId' + '}', CGI.escape(version_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'PublicWorkflowResponse'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"PublicEmbedApi.get_public_workflow_version",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PublicEmbedApi#get_public_workflow_version\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
@@ -337,8 +540,8 @@ module ApiSdkRb
     # @param post_public_composition_embed_status_request [PostPublicCompositionEmbedStatusRequest] 
     # @param [Hash] opts the optional parameters
     # @return [PostPublicCompositionEmbedStatus200Response]
-    def post_public_composition_embed_status_0(post_public_composition_embed_status_request, opts = {})
-      data, _status_code, _headers = post_public_composition_embed_status_0_with_http_info(post_public_composition_embed_status_request, opts)
+    def post_public_composition_embed_status(post_public_composition_embed_status_request, opts = {})
+      data, _status_code, _headers = post_public_composition_embed_status_with_http_info(post_public_composition_embed_status_request, opts)
       data
     end
 
@@ -347,13 +550,13 @@ module ApiSdkRb
     # @param post_public_composition_embed_status_request [PostPublicCompositionEmbedStatusRequest] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(PostPublicCompositionEmbedStatus200Response, Integer, Hash)>] PostPublicCompositionEmbedStatus200Response data, response status code and response headers
-    def post_public_composition_embed_status_0_with_http_info(post_public_composition_embed_status_request, opts = {})
+    def post_public_composition_embed_status_with_http_info(post_public_composition_embed_status_request, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.post_public_composition_embed_status_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.post_public_composition_embed_status ...'
       end
       # verify the required parameter 'post_public_composition_embed_status_request' is set
       if @api_client.config.client_side_validation && post_public_composition_embed_status_request.nil?
-        fail ArgumentError, "Missing the required parameter 'post_public_composition_embed_status_request' when calling PublicEmbedApi.post_public_composition_embed_status_0"
+        fail ArgumentError, "Missing the required parameter 'post_public_composition_embed_status_request' when calling PublicEmbedApi.post_public_composition_embed_status"
       end
       # resource path
       local_var_path = '/embed/compositions/status'
@@ -384,7 +587,81 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.post_public_composition_embed_status_0",
+        :operation => :"PublicEmbedApi.post_public_composition_embed_status",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: PublicEmbedApi#post_public_composition_embed_status\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers
+    end
+
+    # Report what visitors did in a Workflow, as counts
+    # Public report of counts for a workflow, sent by the embed. No API key. Each event is one id and a number: a visitor reached a block (`n`), took a connection (`e`), or could not be moved on (`f`). Nothing else is kept: no visitor, no value a visitor typed, no address. A batch carries at most 100 events and 16 KB. The same report may carry `heights`: how tall a step settled at in the browser, which the embed code of the workflow uses to start its box at a real height (a composition, a whole number of pixels, nothing about the visitor). A report is accepted only with the `token` the workflow's own read handed out for that `versionId`, so a page that never read the workflow cannot raise its numbers. An expired token (`EVENT_TOKEN_EXPIRED`) is refused with 401: read the workflow again for a new one. Counts for ids that are not in that version, or for a workflow that is not live, are not recorded and the answer says so (`recorded: false`) with 200: the visitor's page has nothing to fix. The body is JSON, sent as `application/json` or as `text/plain` (a \"simple\" cross-origin request, which is what lets a report leave a page that is being closed). **Address.** `https://api.widgetic.com/embed/workflows/{workflowId}/events`: 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.
+    # @param workflow_id [String] 
+    # @param public_workflow_events_request [PublicWorkflowEventsRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [ReportPublicWorkflowEvents200Response]
+    def report_public_workflow_events(workflow_id, public_workflow_events_request, opts = {})
+      data, _status_code, _headers = report_public_workflow_events_with_http_info(workflow_id, public_workflow_events_request, opts)
+      data
+    end
+
+    # Report what visitors did in a Workflow, as counts
+    # Public report of counts for a workflow, sent by the embed. No API key. Each event is one id and a number: a visitor reached a block (&#x60;n&#x60;), took a connection (&#x60;e&#x60;), or could not be moved on (&#x60;f&#x60;). Nothing else is kept: no visitor, no value a visitor typed, no address. A batch carries at most 100 events and 16 KB. The same report may carry &#x60;heights&#x60;: how tall a step settled at in the browser, which the embed code of the workflow uses to start its box at a real height (a composition, a whole number of pixels, nothing about the visitor). A report is accepted only with the &#x60;token&#x60; the workflow&#39;s own read handed out for that &#x60;versionId&#x60;, so a page that never read the workflow cannot raise its numbers. An expired token (&#x60;EVENT_TOKEN_EXPIRED&#x60;) is refused with 401: read the workflow again for a new one. Counts for ids that are not in that version, or for a workflow that is not live, are not recorded and the answer says so (&#x60;recorded: false&#x60;) with 200: the visitor&#39;s page has nothing to fix. The body is JSON, sent as &#x60;application/json&#x60; or as &#x60;text/plain&#x60; (a \&quot;simple\&quot; cross-origin request, which is what lets a report leave a page that is being closed). **Address.** &#x60;https://api.widgetic.com/embed/workflows/{workflowId}/events&#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 workflow_id [String] 
+    # @param public_workflow_events_request [PublicWorkflowEventsRequest] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(ReportPublicWorkflowEvents200Response, Integer, Hash)>] ReportPublicWorkflowEvents200Response data, response status code and response headers
+    def report_public_workflow_events_with_http_info(workflow_id, public_workflow_events_request, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.report_public_workflow_events ...'
+      end
+      # verify the required parameter 'workflow_id' is set
+      if @api_client.config.client_side_validation && workflow_id.nil?
+        fail ArgumentError, "Missing the required parameter 'workflow_id' when calling PublicEmbedApi.report_public_workflow_events"
+      end
+      # verify the required parameter 'public_workflow_events_request' is set
+      if @api_client.config.client_side_validation && public_workflow_events_request.nil?
+        fail ArgumentError, "Missing the required parameter 'public_workflow_events_request' when calling PublicEmbedApi.report_public_workflow_events"
+      end
+      # resource path
+      local_var_path = '/embed/workflows/{workflowId}/events'.sub('{' + 'workflowId' + '}', CGI.escape(workflow_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json']) unless header_params['Accept']
+      # HTTP header 'Content-Type'
+      content_type = @api_client.select_header_content_type(['application/json', 'text/plain'])
+      if !content_type.nil?
+          header_params['Content-Type'] = content_type
+      end
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body] || @api_client.object_to_http_body(public_workflow_events_request)
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'ReportPublicWorkflowEvents200Response'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || []
+
+      new_options = opts.merge(
+        :operation => :"PublicEmbedApi.report_public_workflow_events",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -395,58 +672,58 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#post_public_composition_embed_status_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#report_public_workflow_events\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end
 
     # Send the file a visitor chose through the upload adapter of a published widget
-    # The second of the two calls the `upload` adapter's module makes from the visitor's browser (the first, the `begin-upload` operation of `callPublicCompositionAdapter`, answers with the ticket this route takes). The module sends the file itself, as the body, with its media type as the `Content-Type`. It is not meant to be called by hand, and it takes no API key. **Address.** `https://api.widgetic.com/embed/compositions/{compositionId}/adapters/upload/files/{ticket}`: 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. **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's owner's settings (the kinds of file they take, the largest size) were applied. The `Content-Type` and the `Content-Length` of this request must be those, and the body must be exactly that many bytes (400 `UPLOAD_FILE_CHANGED` 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's storage: Widgetic's, or the partner's own bucket for a widget of a customer a partner manages. It counts against the owner's storage allowance and is filed in the folder the owner chose, as a file sent by a visitor, which the owner's own file list leaves out. A full allowance, a partner's storage that cannot be used and a stopped feature are all the same 503 `UPLOAD_UNAVAILABLE` to a visitor, and the owner is told through a notice. **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). 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. **Limits.** 30 requests a minute for each visitor address and composition and 240 a minute for a composition (429 `RATE_LIMITED`, with a `Retry-After` header); at most 10 MB for a file, and only so many files held in memory at once on each gateway process (503 `UPLOAD_BUSY`, with a `Retry-After`). A file that does not arrive within two minutes is 408 `UPLOAD_TIMEOUT`. 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.
+    # The second of the two calls the `upload` adapter's module makes from the visitor's browser (the first, the `begin-upload` operation of `callPublicCompositionAdapter`, answers with the ticket this route takes). The module sends the file itself, as the body, with its media type as the `Content-Type`. It is not meant to be called by hand, and it takes no API key. **Address.** `https://api.widgetic.com/embed/compositions/{compositionId}/adapters/upload/files/{ticket}`: 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. **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's owner's settings (the kinds of file they take, the largest size) were applied. The `Content-Type` and the `Content-Length` of this request must be those, and the body must be exactly that many bytes (400 `UPLOAD_FILE_CHANGED` 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. **The virus check.** Before anything is stored, the file is checked for viruses, wherever it would be kept (Widgetic's storage or a partner's own bucket). A file that fails the check is refused with 422 `UPLOAD_FILE_UNSAFE` and nothing is stored. When the check cannot be done, nothing is stored either, and the answer is the same neutral 503 `UPLOAD_UNAVAILABLE` as for any other cause the visitor is not told. The ticket of a refused file is spent. **What it stores.** The file goes to the widget owner's storage: Widgetic's, or the partner's own bucket for a widget of a customer a partner manages. It counts against the owner's storage allowance and is filed in the folder the owner chose, as a file sent by a visitor, which the owner's own file list leaves out. A full allowance, a partner's storage that cannot be used and a stopped feature are all the same 503 `UPLOAD_UNAVAILABLE` to a visitor, and the owner is told through a notice. **Who may call.** The same rule as the entry route: a permitted `Origin` header, which is the artifact origin the widget runs from or any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic's own sites, the visitor's own machine or the owner's own platform). 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. **Limits.** 30 requests a minute for each visitor address and composition and 240 a minute for a composition (429 `RATE_LIMITED`, with a `Retry-After` header); at most 10 MB for a file, and only so many files held in memory at once on each gateway process (503 `UPLOAD_BUSY`, with a `Retry-After`). A file that does not arrive within two minutes is 408 `UPLOAD_TIMEOUT`. 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 [String] 
     # @param ticket [String] The ticket the &#x60;begin-upload&#x60; operation answered with.
     # @param body [File] 
     # @param [Hash] opts the optional parameters
     # @return [PublicAdapterFileResult]
-    def upload_public_composition_adapter_file_0(composition_id, ticket, body, opts = {})
-      data, _status_code, _headers = upload_public_composition_adapter_file_0_with_http_info(composition_id, ticket, body, opts)
+    def upload_public_composition_adapter_file(composition_id, ticket, body, opts = {})
+      data, _status_code, _headers = upload_public_composition_adapter_file_with_http_info(composition_id, ticket, body, opts)
       data
     end
 
     # 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.
+    # 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. **The virus check.** Before anything is stored, the file is checked for viruses, wherever it would be kept (Widgetic&#39;s storage or a partner&#39;s own bucket). A file that fails the check is refused with 422 &#x60;UPLOAD_FILE_UNSAFE&#x60; and nothing is stored. When the check cannot be done, nothing is stored either, and the answer is the same neutral 503 &#x60;UPLOAD_UNAVAILABLE&#x60; as for any other cause the visitor is not told. The ticket of a refused file is spent. **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 any website when the owner has not restricted the allowed websites (when the owner has, one of the websites the owner listed, Widgetic&#39;s own sites, the visitor&#39;s own machine 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 [String] 
     # @param ticket [String] The ticket the &#x60;begin-upload&#x60; operation answered with.
     # @param body [File] 
     # @param [Hash] opts the optional parameters
     # @return [Array<(PublicAdapterFileResult, Integer, Hash)>] PublicAdapterFileResult data, response status code and response headers
-    def upload_public_composition_adapter_file_0_with_http_info(composition_id, ticket, body, opts = {})
+    def upload_public_composition_adapter_file_with_http_info(composition_id, ticket, body, opts = {})
       if @api_client.config.debugging
-        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.upload_public_composition_adapter_file_0 ...'
+        @api_client.config.logger.debug 'Calling API: PublicEmbedApi.upload_public_composition_adapter_file ...'
       end
       # verify the required parameter 'composition_id' is set
       if @api_client.config.client_side_validation && composition_id.nil?
-        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.upload_public_composition_adapter_file_0"
+        fail ArgumentError, "Missing the required parameter 'composition_id' when calling PublicEmbedApi.upload_public_composition_adapter_file"
       end
       # verify the required parameter 'ticket' is set
       if @api_client.config.client_side_validation && ticket.nil?
-        fail ArgumentError, "Missing the required parameter 'ticket' when calling PublicEmbedApi.upload_public_composition_adapter_file_0"
+        fail ArgumentError, "Missing the required parameter 'ticket' when calling PublicEmbedApi.upload_public_composition_adapter_file"
       end
       if @api_client.config.client_side_validation && ticket.to_s.length > 128
-        fail ArgumentError, 'invalid value for "ticket" when calling PublicEmbedApi.upload_public_composition_adapter_file_0, the character length must be smaller than or equal to 128.'
+        fail ArgumentError, 'invalid value for "ticket" when calling PublicEmbedApi.upload_public_composition_adapter_file, the character length must be smaller than or equal to 128.'
       end
 
       if @api_client.config.client_side_validation && ticket.to_s.length < 20
-        fail ArgumentError, 'invalid value for "ticket" when calling PublicEmbedApi.upload_public_composition_adapter_file_0, the character length must be great than or equal to 20.'
+        fail ArgumentError, 'invalid value for "ticket" when calling PublicEmbedApi.upload_public_composition_adapter_file, the character length must be great than or equal to 20.'
       end
 
       pattern = Regexp.new(/^[A-Za-z0-9_-]{20,128}$/)
       if @api_client.config.client_side_validation && ticket !~ pattern
-        fail ArgumentError, "invalid value for 'ticket' when calling PublicEmbedApi.upload_public_composition_adapter_file_0, must conform to the pattern #{pattern}."
+        fail ArgumentError, "invalid value for 'ticket' when calling PublicEmbedApi.upload_public_composition_adapter_file, must conform to the pattern #{pattern}."
       end
 
       # verify the required parameter 'body' is set
       if @api_client.config.client_side_validation && body.nil?
-        fail ArgumentError, "Missing the required parameter 'body' when calling PublicEmbedApi.upload_public_composition_adapter_file_0"
+        fail ArgumentError, "Missing the required parameter 'body' when calling PublicEmbedApi.upload_public_composition_adapter_file"
       end
       # resource path
       local_var_path = '/embed/compositions/{compositionId}/adapters/upload/files/{ticket}'.sub('{' + 'compositionId' + '}', CGI.escape(composition_id.to_s)).sub('{' + 'ticket' + '}', CGI.escape(ticket.to_s))
@@ -477,7 +754,7 @@ module ApiSdkRb
       auth_names = opts[:debug_auth_names] || []
 
       new_options = opts.merge(
-        :operation => :"PublicEmbedApi.upload_public_composition_adapter_file_0",
+        :operation => :"PublicEmbedApi.upload_public_composition_adapter_file",
         :header_params => header_params,
         :query_params => query_params,
         :form_params => form_params,
@@ -488,7 +765,7 @@ module ApiSdkRb
 
       data, status_code, headers = @api_client.call_api(:PUT, local_var_path, new_options)
       if @api_client.config.debugging
-        @api_client.config.logger.debug "API called: PublicEmbedApi#upload_public_composition_adapter_file_0\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+        @api_client.config.logger.debug "API called: PublicEmbedApi#upload_public_composition_adapter_file\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
       end
       return data, status_code, headers
     end