@widgetic/api-sdk 1.0.31 → 1.0.33

package/dist/apis/BillingApi.js

@@ -324,6 +324,133 @@ class BillingApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Gives back extra storage: removes `pack_size_gb` GB from the person\'s storage add-on, or all of it with `remove_all`. The add-on stops billing for the GB removed; what was already paid for the rest of the current period is credited on the next invoice.  Removing storage does not delete files. A person who holds more than their limit afterwards can read and delete what they have but cannot upload until they are back under the limit.  Send either `pack_size_gb` or `remove_all: true`, not both. The `Idempotency-Key` header is required and names this change: a retry with the same key replays the first result.  Removing is allowed on an overdue subscription and on one that ends with the period, so a person is never stuck paying for storage they want to drop. Users can only change their own storage.
+     * Remove Extra Storage from Your Own Storage
+     */
+    billingUsersUserIdStorageCancelPackPostRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['userId'] == null) {
+                throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling billingUsersUserIdStorageCancelPackPost().');
+            }
+            if (requestParameters['billingUsersUserIdStorageCancelPackPostRequest'] == null) {
+                throw new runtime.RequiredError('billingUsersUserIdStorageCancelPackPostRequest', 'Required parameter "billingUsersUserIdStorageCancelPackPostRequest" was null or undefined when calling billingUsersUserIdStorageCancelPackPost().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/billing/users/{userId}/storage/cancel-pack`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.BillingUsersUserIdStorageCancelPackPostRequestToJSON)(requestParameters['billingUsersUserIdStorageCancelPackPostRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PurchaseStoragePack200ResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Gives back extra storage: removes `pack_size_gb` GB from the person\'s storage add-on, or all of it with `remove_all`. The add-on stops billing for the GB removed; what was already paid for the rest of the current period is credited on the next invoice.  Removing storage does not delete files. A person who holds more than their limit afterwards can read and delete what they have but cannot upload until they are back under the limit.  Send either `pack_size_gb` or `remove_all: true`, not both. The `Idempotency-Key` header is required and names this change: a retry with the same key replays the first result.  Removing is allowed on an overdue subscription and on one that ends with the period, so a person is never stuck paying for storage they want to drop. Users can only change their own storage.
+     * Remove Extra Storage from Your Own Storage
+     */
+    billingUsersUserIdStorageCancelPackPost(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.billingUsersUserIdStorageCancelPackPostRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Returns a person\'s own storage and the extra storage they can add to it on Solo, in one call: the limit the upload check holds their own workspace to (plan plus extra storage), what they have stored, the extra storage they hold (one row per storage item on the subscription) and what it costs per billing period, and whether storage can be added or removed right now (`extraStorage.canAdd` and `extraStorage.canRemove`) with the reason when it cannot (`extraStorage.addBlockedReason`; its codes are the ones the purchase request answers with). A partner account is never offered extra storage (`PARTNER_STORAGE_NOT_SOLD`): its files are kept in its own storage destination.  This is the person\'s OWN workspace. The storage of a team they belong to is the team\'s pool, read with `GET /organizations/{orgId}/storage/usage`; extra storage bought here does not add to it.  Users can only read their own storage; internal callers can read anyone\'s.
+     * Get Your Own Storage and Extra Storage
+     */
+    billingUsersUserIdStorageGetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['userId'] == null) {
+                throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling billingUsersUserIdStorageGet().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/billing/users/{userId}/storage`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.BillingUsersUserIdStorageGet200ResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Returns a person\'s own storage and the extra storage they can add to it on Solo, in one call: the limit the upload check holds their own workspace to (plan plus extra storage), what they have stored, the extra storage they hold (one row per storage item on the subscription) and what it costs per billing period, and whether storage can be added or removed right now (`extraStorage.canAdd` and `extraStorage.canRemove`) with the reason when it cannot (`extraStorage.addBlockedReason`; its codes are the ones the purchase request answers with). A partner account is never offered extra storage (`PARTNER_STORAGE_NOT_SOLD`): its files are kept in its own storage destination.  This is the person\'s OWN workspace. The storage of a team they belong to is the team\'s pool, read with `GET /organizations/{orgId}/storage/usage`; extra storage bought here does not add to it.  Users can only read their own storage; internal callers can read anyone\'s.
+     * Get Your Own Storage and Extra Storage
+     */
+    billingUsersUserIdStorageGet(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.billingUsersUserIdStorageGetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Adds extra storage to the person\'s own Solo subscription. Extra storage is a RECURRING add-on, not a one-time purchase: it is one more item on the same subscription as the plan, billed every period (per GB per month on a monthly subscription, per GB per year on a yearly one) until it is removed or the subscription ends.  The GB are charged now, prorated for the rest of the current period, to the subscription\'s payment method, and join the person\'s own storage as soon as the charge succeeds. If the charge fails (for example a declined card) nothing is added and the request is refused with 402 `PAYMENT_FAILED`.  Storage is sold in packs (the pricing payload\'s `storage.defaultPackSizeGb`, 50 GB). Ask for as many packs as you need in one request by sending a multiple of the pack size: `pack_size_gb: 50` is one pack, `100` is two, `500` is ten. `pack_size_gb` is added to what the person already has, so buying again adds more. Remove storage with `POST /billing/users/{userId}/storage/cancel-pack`.  The extra storage adds to the person\'s OWN workspace only. It is not shared with a team the person belongs to: a team\'s storage is the team\'s pool, and its admins buy storage for it.  The `Idempotency-Key` header is required and names this change: a retry with the same key replays the first result instead of adding the storage twice. A refused request gives the key back: after a declined card (402 `PAYMENT_FAILED`), fix the payment method and send the request again with the same key. It is charged as a new attempt and is not answered with the old decline.  Only a Solo subscription that Stripe bills and that is active can have extra storage. During the free trial the request is refused with 409 `TRIAL_NOT_ENDED` (storage added then would be free until the trial ends); a person with no Solo subscription is refused with a plan restriction pointing at Solo, and the owner account of a Shopify store (whose plan Shopify bills) with 409 `BILLED_THROUGH_SHOPIFY`. Users can only change their own storage.  Extra storage is not sold to an account that administers a partner (403 `PARTNER_STORAGE_NOT_SOLD`): the files of a partner account are kept in the partner\'s own storage destination and never use Widgetic storage, so there would be nothing for the storage to add to. Giving storage back stays open to such an account.
+     * Add Extra Storage to Your Own Storage
+     */
+    billingUsersUserIdStoragePurchasePackPostRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['userId'] == null) {
+                throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling billingUsersUserIdStoragePurchasePackPost().');
+            }
+            if (requestParameters['purchaseStoragePackRequest'] == null) {
+                throw new runtime.RequiredError('purchaseStoragePackRequest', 'Required parameter "purchaseStoragePackRequest" was null or undefined when calling billingUsersUserIdStoragePurchasePackPost().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (requestParameters['idempotencyKey'] != null) {
+                headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+            }
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/billing/users/{userId}/storage/purchase-pack`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.PurchaseStoragePackRequestToJSON)(requestParameters['purchaseStoragePackRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PurchaseStoragePack200ResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Adds extra storage to the person\'s own Solo subscription. Extra storage is a RECURRING add-on, not a one-time purchase: it is one more item on the same subscription as the plan, billed every period (per GB per month on a monthly subscription, per GB per year on a yearly one) until it is removed or the subscription ends.  The GB are charged now, prorated for the rest of the current period, to the subscription\'s payment method, and join the person\'s own storage as soon as the charge succeeds. If the charge fails (for example a declined card) nothing is added and the request is refused with 402 `PAYMENT_FAILED`.  Storage is sold in packs (the pricing payload\'s `storage.defaultPackSizeGb`, 50 GB). Ask for as many packs as you need in one request by sending a multiple of the pack size: `pack_size_gb: 50` is one pack, `100` is two, `500` is ten. `pack_size_gb` is added to what the person already has, so buying again adds more. Remove storage with `POST /billing/users/{userId}/storage/cancel-pack`.  The extra storage adds to the person\'s OWN workspace only. It is not shared with a team the person belongs to: a team\'s storage is the team\'s pool, and its admins buy storage for it.  The `Idempotency-Key` header is required and names this change: a retry with the same key replays the first result instead of adding the storage twice. A refused request gives the key back: after a declined card (402 `PAYMENT_FAILED`), fix the payment method and send the request again with the same key. It is charged as a new attempt and is not answered with the old decline.  Only a Solo subscription that Stripe bills and that is active can have extra storage. During the free trial the request is refused with 409 `TRIAL_NOT_ENDED` (storage added then would be free until the trial ends); a person with no Solo subscription is refused with a plan restriction pointing at Solo, and the owner account of a Shopify store (whose plan Shopify bills) with 409 `BILLED_THROUGH_SHOPIFY`. Users can only change their own storage.  Extra storage is not sold to an account that administers a partner (403 `PARTNER_STORAGE_NOT_SOLD`): the files of a partner account are kept in the partner\'s own storage destination and never use Widgetic storage, so there would be nothing for the storage to add to. Giving storage back stays open to such an account.
+     * Add Extra Storage to Your Own Storage
+     */
+    billingUsersUserIdStoragePurchasePackPost(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.billingUsersUserIdStoragePurchasePackPostRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Cancel the active subscription
      */

package/dist/apis/CompositionsApi.d.ts

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { CheckCompositionAccess200Response, Composition, CompositionEntriesDescription, CompositionEntriesReading, CreateCompositionContentItemRequest, CreateCompositionFromWidget201Response, DeleteCompositionContentItem200Response, DuplicateComposition202Response, DuplicateCompositionRequest, GetAllCompositions200Response, GetCompositionContentSchema200Response, GetCompositionDesignSchema200Response, GetCompositionEmbedSchema200Response, GetCompositionPreview200Response, GetCompositionVersions200Response, GetCompositionsBatch200Response, GetCompositionsBatchRequest, NewComposition, SetCompositionDataSourceRequest, SetDynamicContent200Response, SetDynamicContentRequest, UpdateComposition, UpdateCompositionStatusRequest, ValidateCompositionContent200Response } from '../models/index';
+import type { CheckCompositionAccess200Response, Composition, CompositionDataSource, CompositionEntriesDescription, CompositionEntriesReading, CreateCompositionContentItemRequest, CreateCompositionFromWidget201Response, DeleteCompositionContentItem200Response, DeleteCompositionDataSource200Response, DuplicateComposition202Response, DuplicateCompositionRequest, GetAllCompositions200Response, GetCompositionContentSchema200Response, GetCompositionDesignSchema200Response, GetCompositionEmbedSchema200Response, GetCompositionPreview200Response, GetCompositionVersions200Response, GetCompositionsBatch200Response, GetCompositionsBatchRequest, NewComposition, SetCompositionDataSourceRequest, SetDynamicContent200Response, SetDynamicContentRequest, UpdateComposition, UpdateCompositionStatusRequest, ValidateCompositionContent200Response } from '../models/index';
 export interface CheckCompositionAccessRequest {
     id: string;
 }
@@ -224,13 +224,15 @@ export declare class CompositionsApi extends runtime.BaseAPI {
      */
     deleteCompositionContentItem(requestParameters: DeleteCompositionContentItem0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeleteCompositionContentItem200Response>;
     /**
+     * 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.
      * Remove the composition data source binding
      */
-    deleteCompositionDataSourceRaw(requestParameters: DeleteCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    deleteCompositionDataSourceRaw(requestParameters: DeleteCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DeleteCompositionDataSource200Response>>;
     /**
+     * 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.
      * Remove the composition data source binding
      */
-    deleteCompositionDataSource(requestParameters: DeleteCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    deleteCompositionDataSource(requestParameters: DeleteCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DeleteCompositionDataSource200Response>;
     /**
      * Deletes a specific record from a table in the composition\'s database.
      * Delete Record From Composition Database
@@ -282,12 +284,12 @@ export declare class CompositionsApi extends runtime.BaseAPI {
      */
     getAllCompositions(requestParameters?: GetAllCompositions0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAllCompositions200Response>;
     /**
-     * Retrieves a specific composition by its ID.
+     * Retrieves a specific composition by its ID.  The answer carries `direct`, which says whether the widget the composition is made from is drawn straight into your page (`true`) or inside a frame (`false`), or `null` 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\'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\'s own frame and is accepted whatever the list says.
      * Get Composition
      */
     getCompositionByIdRaw(requestParameters: GetCompositionById0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateCompositionFromWidget201Response>>;
     /**
-     * Retrieves a specific composition by its ID.
+     * Retrieves a specific composition by its ID.  The answer carries `direct`, which says whether the widget the composition is made from is drawn straight into your page (`true`) or inside a frame (`false`), or `null` 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\'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\'s own frame and is accepted whatever the list says.
      * Get Composition
      */
     getCompositionById(requestParameters: GetCompositionById0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateCompositionFromWidget201Response>;
@@ -312,13 +314,15 @@ export declare class CompositionsApi extends runtime.BaseAPI {
      */
     getCompositionContent(requestParameters: GetCompositionContent0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<object>;
     /**
+     * The data source that is bound to the composition: `url` and `refreshSeconds`. The answer\'s `data` is `null` 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).
      * Read the composition data source binding
      */
-    getCompositionDataSourceRaw(requestParameters: GetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    getCompositionDataSourceRaw(requestParameters: GetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompositionDataSource>>;
     /**
+     * The data source that is bound to the composition: `url` and `refreshSeconds`. The answer\'s `data` is `null` 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).
      * Read the composition data source binding
      */
-    getCompositionDataSource(requestParameters: GetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    getCompositionDataSource(requestParameters: GetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompositionDataSource>;
     /**
      * Retrieves a specific record from a table in the composition\'s database.
      * Get Record From Composition Database
@@ -400,12 +404,12 @@ export declare class CompositionsApi extends runtime.BaseAPI {
      */
     getCompositionVersions(requestParameters: GetCompositionVersionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCompositionVersions200Response>;
     /**
-     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed.
+     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (`platformDomain` in the answer of `GET /partners/mine`), for the compositions of that partner: a partner\'s list never has to name it.
      * Get Compositions Batch
      */
     getCompositionsBatchRaw(requestParameters: GetCompositionsBatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCompositionsBatch200Response>>;
     /**
-     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed.
+     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (`platformDomain` in the answer of `GET /partners/mine`), for the compositions of that partner: a partner\'s list never has to name it.
      * Get Compositions Batch
      */
     getCompositionsBatch(requestParameters: GetCompositionsBatchOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCompositionsBatch200Response>;
@@ -418,25 +422,25 @@ export declare class CompositionsApi extends runtime.BaseAPI {
      */
     patchCompositionContentItem(requestParameters: PatchCompositionContentItem0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
-     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists.  This read is bounded on purpose: it never returns more than 25 entries, 20 groups, 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`.  **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.
+     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists. - **`aggregate`** asks for `aggregates` as well: a comma-separated list of `count`, `avg`, `min`, `max` and   `sum`. `avg`, `min`, `max` and `sum` need `column`, a numeric column of the table. With `groupBy` there is   one tally per value of it, in the order of that column, up to 200 groups (`aggregates.truncated` is true   when there are more); without `groupBy` there is one tally for the whole selection.  **`aggregates` counts a selection; the rest of the answer does not.** `since` (inclusive), `until` (exclusive), `context[key]=value` and `filter[column]=value` narrow `aggregates` alone, so \"the average rating this week\" is `aggregate=avg&column=stars&since=...`. `totalRows`, `tallies` and `rows` always describe the whole table. These parameters, and `column`, are refused (400) on a read without `aggregate`, 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 `aggregates`), 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`; to page through entries with their time, context and filters, use `listCompositionEntryItems`.  **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.
      * Read the Entries of a Composition\'s Table
      */
     readCompositionEntriesRaw(requestParameters: ReadCompositionEntries0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompositionEntriesReading>>;
     /**
-     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists.  This read is bounded on purpose: it never returns more than 25 entries, 20 groups, 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`.  **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.
+     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists. - **`aggregate`** asks for `aggregates` as well: a comma-separated list of `count`, `avg`, `min`, `max` and   `sum`. `avg`, `min`, `max` and `sum` need `column`, a numeric column of the table. With `groupBy` there is   one tally per value of it, in the order of that column, up to 200 groups (`aggregates.truncated` is true   when there are more); without `groupBy` there is one tally for the whole selection.  **`aggregates` counts a selection; the rest of the answer does not.** `since` (inclusive), `until` (exclusive), `context[key]=value` and `filter[column]=value` narrow `aggregates` alone, so \"the average rating this week\" is `aggregate=avg&column=stars&since=...`. `totalRows`, `tallies` and `rows` always describe the whole table. These parameters, and `column`, are refused (400) on a read without `aggregate`, 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 `aggregates`), 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`; to page through entries with their time, context and filters, use `listCompositionEntryItems`.  **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.
      * Read the Entries of a Composition\'s Table
      */
     readCompositionEntries(requestParameters: ReadCompositionEntries0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompositionEntriesReading>;
     /**
-     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. The URL must name a public host (no loopback, link-local or metadata addresses).
+     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. 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 (`url`, `refreshSeconds`).
      * Bind a public JSON data source for embed refresh
      */
-    setCompositionDataSourceRaw(requestParameters: SetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    setCompositionDataSourceRaw(requestParameters: SetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CompositionDataSource>>;
     /**
-     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. The URL must name a public host (no loopback, link-local or metadata addresses).
+     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. 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 (`url`, `refreshSeconds`).
      * Bind a public JSON data source for embed refresh
      */
-    setCompositionDataSource(requestParameters: SetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    setCompositionDataSource(requestParameters: SetCompositionDataSource0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CompositionDataSource>;
     /**
      * Updates the content of a composition dynamically with optional schema validation.  An editor session (see `createManagedUserEditorSession`) can send only `content`, `validate` and `partial`, and only for a composition made for its managed user. A body that names `version`, `source` or any other field is refused with `403` and `EDITOR_SESSION_FIELD_NOT_ALLOWED`.
      * Set Dynamic Content

package/dist/apis/CompositionsApi.js

@@ -253,6 +253,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
+     * 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.
      * Remove the composition data source binding
      */
     deleteCompositionDataSourceRaw(requestParameters, initOverrides) {
@@ -278,15 +279,17 @@ class CompositionsApi extends runtime.BaseAPI {
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteCompositionDataSource200ResponseFromJSON)(jsonValue));
         });
     }
     /**
+     * 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.
      * Remove the composition data source binding
      */
     deleteCompositionDataSource(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.deleteCompositionDataSourceRaw(requestParameters, initOverrides);
+            const response = yield this.deleteCompositionDataSourceRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
@@ -511,7 +514,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves a specific composition by its ID.
+     * Retrieves a specific composition by its ID.  The answer carries `direct`, which says whether the widget the composition is made from is drawn straight into your page (`true`) or inside a frame (`false`), or `null` 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\'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\'s own frame and is accepted whatever the list says.
      * Get Composition
      */
     getCompositionByIdRaw(requestParameters, initOverrides) {
@@ -538,7 +541,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves a specific composition by its ID.
+     * Retrieves a specific composition by its ID.  The answer carries `direct`, which says whether the widget the composition is made from is drawn straight into your page (`true`) or inside a frame (`false`), or `null` 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\'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\'s own frame and is accepted whatever the list says.
      * Get Composition
      */
     getCompositionById(requestParameters, initOverrides) {
@@ -622,6 +625,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
+     * The data source that is bound to the composition: `url` and `refreshSeconds`. The answer\'s `data` is `null` 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).
      * Read the composition data source binding
      */
     getCompositionDataSourceRaw(requestParameters, initOverrides) {
@@ -644,15 +648,17 @@ class CompositionsApi extends runtime.BaseAPI {
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompositionDataSourceFromJSON)(jsonValue));
         });
     }
     /**
+     * The data source that is bound to the composition: `url` and `refreshSeconds`. The answer\'s `data` is `null` 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).
      * Read the composition data source binding
      */
     getCompositionDataSource(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getCompositionDataSourceRaw(requestParameters, initOverrides);
+            const response = yield this.getCompositionDataSourceRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
@@ -959,7 +965,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed.
+     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (`platformDomain` in the answer of `GET /partners/mine`), for the compositions of that partner: a partner\'s list never has to name it.
      * Get Compositions Batch
      */
     getCompositionsBatchRaw(requestParameters, initOverrides) {
@@ -988,7 +994,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed.
+     * 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\'s domain list, or the `allowedDomains` of a partner the owner administers) and the request comes from another website (the `Origin` header, or the host of `Referer` when there is no `Origin`), that composition is left out of `compositions` and reported in `errors` as `Domain access denied: <reason>`; 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\'s own machine (`localhost`, `127.0.0.1` or `[::1]`, on any port) is always allowed. So is the website where a partner integrates Widgetic, with every subdomain of it (`platformDomain` in the answer of `GET /partners/mine`), for the compositions of that partner: a partner\'s list never has to name it.
      * Get Compositions Batch
      */
     getCompositionsBatch(requestParameters, initOverrides) {
@@ -1049,7 +1055,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists.  This read is bounded on purpose: it never returns more than 25 entries, 20 groups, 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`.  **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.
+     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists. - **`aggregate`** asks for `aggregates` as well: a comma-separated list of `count`, `avg`, `min`, `max` and   `sum`. `avg`, `min`, `max` and `sum` need `column`, a numeric column of the table. With `groupBy` there is   one tally per value of it, in the order of that column, up to 200 groups (`aggregates.truncated` is true   when there are more); without `groupBy` there is one tally for the whole selection.  **`aggregates` counts a selection; the rest of the answer does not.** `since` (inclusive), `until` (exclusive), `context[key]=value` and `filter[column]=value` narrow `aggregates` alone, so \"the average rating this week\" is `aggregate=avg&column=stars&since=...`. `totalRows`, `tallies` and `rows` always describe the whole table. These parameters, and `column`, are refused (400) on a read without `aggregate`, 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 `aggregates`), 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`; to page through entries with their time, context and filters, use `listCompositionEntryItems`.  **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.
      * Read the Entries of a Composition\'s Table
      */
     readCompositionEntriesRaw(requestParameters, initOverrides) {
@@ -1103,7 +1109,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists.  This read is bounded on purpose: it never returns more than 25 entries, 20 groups, 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`.  **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.
+     * 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 (`groupBy`): each group is a rating and how many visitors gave it. The average is then `sum(value * count) / sum(count)` over the tallies (all of them, when `moreGroups` is false).  - **`totalRows`** is how many entries the table holds in all. - **`groupBy`** names a column (as `describeCompositionEntries` lists it). `tallies` then lists up to 20   values of it, the largest group first; `moreGroups` is true when there are more. - **`rows`** asks for the newest entries too, 1 to 25. The default is 0: counts and tallies only.   `moreRows` is true when the table holds more than were returned. Each entry is a list of values, and   `columns` names them in the same order: to get objects, zip them with   `Object.fromEntries(columns.map((name, index) => [name, entry[index]]))`. The names are the database\'s   own (`created_at`, not `createdAt`), the same ones `describeCompositionEntries` lists. - **`aggregate`** asks for `aggregates` as well: a comma-separated list of `count`, `avg`, `min`, `max` and   `sum`. `avg`, `min`, `max` and `sum` need `column`, a numeric column of the table. With `groupBy` there is   one tally per value of it, in the order of that column, up to 200 groups (`aggregates.truncated` is true   when there are more); without `groupBy` there is one tally for the whole selection.  **`aggregates` counts a selection; the rest of the answer does not.** `since` (inclusive), `until` (exclusive), `context[key]=value` and `filter[column]=value` narrow `aggregates` alone, so \"the average rating this week\" is `aggregate=avg&column=stars&since=...`. `totalRows`, `tallies` and `rows` always describe the whole table. These parameters, and `column`, are refused (400) on a read without `aggregate`, 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 `aggregates`), 40 columns or 200 characters a value. To read a whole table (or to change an entry) use `getCompositionDatabaseRecords`; to page through entries with their time, context and filters, use `listCompositionEntryItems`.  **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.
      * Read the Entries of a Composition\'s Table
      */
     readCompositionEntries(requestParameters, initOverrides) {
@@ -1113,7 +1119,7 @@ class CompositionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. The URL must name a public host (no loopback, link-local or metadata addresses).
+     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. 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 (`url`, `refreshSeconds`).
      * Bind a public JSON data source for embed refresh
      */
     setCompositionDataSourceRaw(requestParameters, initOverrides) {
@@ -1144,16 +1150,17 @@ class CompositionsApi extends runtime.BaseAPI {
                 query: queryParameters,
                 body: (0, index_1.SetCompositionDataSourceRequestToJSON)(requestParameters['setCompositionDataSourceRequest']),
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CompositionDataSourceFromJSON)(jsonValue));
         });
     }
     /**
-     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. The URL must name a public host (no loopback, link-local or metadata addresses).
+     * Stores an https URL the widget runtime may read on load and every `refresh_seconds`. 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 (`url`, `refreshSeconds`).
      * Bind a public JSON data source for embed refresh
      */
     setCompositionDataSource(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.setCompositionDataSourceRaw(requestParameters, initOverrides);
+            const response = yield this.setCompositionDataSourceRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**

package/dist/apis/CreditsApi.d.ts

@@ -10,7 +10,7 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { AccountCreditBalance, GetUserCreditTransactions200Response } from '../models/index';
+import type { AccountCreditBalance, GetPartnerCreditTransactions200Response } from '../models/index';
 export interface AddCreditsRequest {
     body: object;
     idempotencyKey?: string;
@@ -57,25 +57,25 @@ export declare class CreditsApi extends runtime.BaseAPI {
      */
     getAllCreditBalances(requestParameters?: GetAllCreditBalancesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>>;
     /**
-     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0.
+     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0. `getPartnerCreditBalance` reads this same balance by partner id.
      * Get an account\'s credit balance
      */
     getUserCreditBalanceRaw(requestParameters: GetUserCreditBalance0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccountCreditBalance>>;
     /**
-     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0.
+     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0. `getPartnerCreditBalance` reads this same balance by partner id.
      * Get an account\'s credit balance
      */
     getUserCreditBalance(requestParameters: GetUserCreditBalance0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccountCreditBalance>;
     /**
-     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. A partner\'s wallet is a separate ledger, read with `getPartnerCreditTransactions`.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
+     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. `getPartnerCreditTransactions` reads this same ledger by partner id.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
      * List an account\'s credit ledger
      */
-    getUserCreditTransactionsRaw(requestParameters: GetUserCreditTransactions0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetUserCreditTransactions200Response>>;
+    getUserCreditTransactionsRaw(requestParameters: GetUserCreditTransactions0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetPartnerCreditTransactions200Response>>;
     /**
-     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. A partner\'s wallet is a separate ledger, read with `getPartnerCreditTransactions`.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
+     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. `getPartnerCreditTransactions` reads this same ledger by partner id.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
      * List an account\'s credit ledger
      */
-    getUserCreditTransactions(requestParameters: GetUserCreditTransactions0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetUserCreditTransactions200Response>;
+    getUserCreditTransactions(requestParameters: GetUserCreditTransactions0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetPartnerCreditTransactions200Response>;
     /**
      * Subtracts credits from a user\'s balance. Admin only. A `referenceId` in the body names the deduction event; when it is omitted the request\'s `Idempotency-Key` header is used instead, and the request is refused with 400 when neither is present, so a retried deduction cannot be applied twice.
      * Subtract credits from user balance

package/dist/apis/CreditsApi.js

@@ -112,7 +112,7 @@ class CreditsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0.
+     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0. `getPartnerCreditBalance` reads this same balance by partner id.
      * Get an account\'s credit balance
      */
     getUserCreditBalanceRaw(requestParameters, initOverrides) {
@@ -139,7 +139,7 @@ class CreditsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0.
+     * 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. An account that has never held credits reads a balance of 0. `getPartnerCreditBalance` reads this same balance by partner id.
      * Get an account\'s credit balance
      */
     getUserCreditBalance(requestParameters, initOverrides) {
@@ -149,7 +149,7 @@ class CreditsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. A partner\'s wallet is a separate ledger, read with `getPartnerCreditTransactions`.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
+     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. `getPartnerCreditTransactions` reads this same ledger by partner id.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
      * List an account\'s credit ledger
      */
     getUserCreditTransactionsRaw(requestParameters, initOverrides) {
@@ -181,11 +181,11 @@ class CreditsApi extends runtime.BaseAPI {
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserCreditTransactions200ResponseFromJSON)(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPartnerCreditTransactions200ResponseFromJSON)(jsonValue));
         });
     }
     /**
-     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. A partner\'s wallet is a separate ledger, read with `getPartnerCreditTransactions`.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
+     * Lists the entries of an account\'s credit ledger, newest first. This is also how an account\'s usage is read: every operation that spends credits is a `debit` entry, so summing the `debit` 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\'s API key, that is the account of the person who administers the partner. Widgetic administrators can read any account\'s. `getPartnerCreditTransactions` reads this same ledger by partner id.  The page is always bounded: `limit` defaults to 100 and is capped at 500, `offset` defaults to 0.
      * List an account\'s credit ledger
      */
     getUserCreditTransactions(requestParameters, initOverrides) {