@widgetic/api-sdk 1.0.30 → 1.0.32

package/dist/esm/apis/ManagedUsersApi.js

@@ -21,7 +21,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime.js';
-import { CopyMyPresetRequestToJSON, CopyPartnerPresetRequestToJSON, EditorSessionFromJSON, GetAllManagedUsers200ResponseFromJSON, GetManagedUsersByManagerId200ResponseFromJSON, ListMyPresets200ResponseFromJSON, ManagedUserFromJSON, ManagedUserUsageFromJSON, MyPresetCopyFromJSON, NewEditorSessionToJSON, NewManagedUserToJSON, PartnerPresetCopyFromJSON, RevokeManagedUserEditorSessions200ResponseFromJSON, UpdateManagedUserToJSON, } from '../models/index.js';
+import { CopyMyPresetRequestToJSON, CopyPartnerPresetRequestToJSON, CreateCompositionFromPresetRequestToJSON, CreateCompositionFromWidget201ResponseFromJSON, EditorSessionFromJSON, GetAllManagedUsers200ResponseFromJSON, GetManagedUserLimits200ResponseFromJSON, GetManagedUserStorageUsage200ResponseFromJSON, GetManagedUsersByManagerId200ResponseFromJSON, GetPartnerDesignDefaults200ResponseFromJSON, ListMyPresets200ResponseFromJSON, ManagedUserFromJSON, ManagedUserUsageFromJSON, MyPresetCopyFromJSON, NewEditorSessionToJSON, NewManagedUserToJSON, PartnerPresetCopyFromJSON, RevokeManagedUserEditorSessions200ResponseFromJSON, SetManagedUserLimitsRequestToJSON, SetPartnerDesignDefaultsRequestToJSON, UpdateManagedUserToJSON, } from '../models/index.js';
 /**
  *
  */
@@ -114,13 +114,19 @@ export class ManagedUsersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
-     * Create Managed User
+     * Validates the name, optional content, design, embed settings and locale, then creates a draft composition filed under the managed user, built on the preset\'s widget, in a single insert. A failure never leaves a half-made composition.  The preset\'s widget must be published. The managed user must be yours and active.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one composition is created, not two.
+     * Create a composition from one of your presets in one call
      */
-    createManagedUserRaw(requestParameters, initOverrides) {
+    createCompositionFromPresetRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (requestParameters['newManagedUser'] == null) {
-                throw new runtime.RequiredError('newManagedUser', 'Required parameter "newManagedUser" was null or undefined when calling createManagedUser().');
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling createCompositionFromPreset().');
+            }
+            if (requestParameters['key'] == null) {
+                throw new runtime.RequiredError('key', 'Required parameter "key" was null or undefined when calling createCompositionFromPreset().');
+            }
+            if (requestParameters['createCompositionFromPresetRequest'] == null) {
+                throw new runtime.RequiredError('createCompositionFromPresetRequest', 'Required parameter "createCompositionFromPresetRequest" was null or undefined when calling createCompositionFromPreset().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -136,22 +142,22 @@ export class ManagedUsersApi extends runtime.BaseAPI {
                 }
             }
             const response = yield this.request({
-                path: `/managed-users`,
+                path: `/managed-users/{id}/presets/{key}/composition`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))).replace(`{${"key"}}`, encodeURIComponent(String(requestParameters['key']))),
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: NewManagedUserToJSON(requestParameters['newManagedUser']),
+                body: CreateCompositionFromPresetRequestToJSON(requestParameters['createCompositionFromPresetRequest']),
             }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => ManagedUserFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => CreateCompositionFromWidget201ResponseFromJSON(jsonValue));
         });
     }
     /**
-     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
-     * Create Managed User
+     * Validates the name, optional content, design, embed settings and locale, then creates a draft composition filed under the managed user, built on the preset\'s widget, in a single insert. A failure never leaves a half-made composition.  The preset\'s widget must be published. The managed user must be yours and active.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one composition is created, not two.
+     * Create a composition from one of your presets in one call
      */
-    createManagedUser(requestParameters, initOverrides) {
+    createCompositionFromPreset(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.createManagedUserRaw(requestParameters, initOverrides);
+            const response = yield this.createCompositionFromPresetRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
@@ -197,6 +203,48 @@ export class ManagedUsersApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
+     * Create Managed User
+     */
+    createManagedUserRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['newManagedUser'] == null) {
+                throw new runtime.RequiredError('newManagedUser', 'Required parameter "newManagedUser" was null or undefined when calling createManagedUser().');
+            }
+            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("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users`,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: NewManagedUserToJSON(requestParameters['newManagedUser']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ManagedUserFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Creates a new managed user for a partner account.  The `Idempotency-Key` header is required (`400` without it). Send the same key when you retry, so one managed user is created, not two.
+     * Create Managed User
+     */
+    createManagedUser(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createManagedUserRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Deletes a managed user by ID. Its editor sessions end with it. What was filed under it (compositions, widgets, uploads) stays in your account, untagged.
      * Delete Managed User
@@ -313,6 +361,111 @@ export class ManagedUsersApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Read design defaults for one managed user
+     */
+    getManagedUserDesignDefaultsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getManagedUserDesignDefaults().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/design-defaults`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetPartnerDesignDefaults200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Read design defaults for one managed user
+     */
+    getManagedUserDesignDefaults(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getManagedUserDesignDefaultsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Read monthly credit cap and usage for one managed user
+     */
+    getManagedUserLimitsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getManagedUserLimits().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/limits`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetManagedUserLimits200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Read monthly credit cap and usage for one managed user
+     */
+    getManagedUserLimits(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getManagedUserLimitsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Storage used by one managed user\'s uploads
+     */
+    getManagedUserStorageUsageRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getManagedUserStorageUsage().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/storage-usage`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetManagedUserStorageUsage200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Storage used by one managed user\'s uploads
+     */
+    getManagedUserStorageUsage(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getManagedUserStorageUsageRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Says how many credits the editor sessions of one of your managed users took from your account over a period, in total and for each operation. A generation costs one credit, taken from your account when it starts; one that fails is refunded and is counted as refunded, not as spent.  Only what was spent through editor sessions is here, and only since usage was first recorded: what you spend with your API key, and anything from before, is not. Use it to see which of your users spend the most, or to charge them for it. To hold one session to a number of credits, set `max_credits` when you make it (`createManagedUserEditorSession`).  The period runs from `startDate` (included) to `endDate` (not included): the 30 days before now when you give neither, and at most 366 days. A date without a time is midnight UTC at the start of that day, so for all of October give `startDate=2026-10-01` and `endDate=2026-11-01`.
      * What a managed user\'s editor sessions spent
@@ -512,6 +665,88 @@ export class ManagedUsersApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Send `{ \"design\": { ... } }` to store a JSON object (at most 64 KB, nesting depth 32), or `{ \"design\": null }` to remove the override. New compositions for this customer merge this layer over the partner default and under the request body.
+     * Set or clear design defaults for one managed user
+     */
+    setManagedUserDesignDefaultsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling setManagedUserDesignDefaults().');
+            }
+            if (requestParameters['setPartnerDesignDefaultsRequest'] == null) {
+                throw new runtime.RequiredError('setPartnerDesignDefaultsRequest', 'Required parameter "setPartnerDesignDefaultsRequest" was null or undefined when calling setManagedUserDesignDefaults().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/design-defaults`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: SetPartnerDesignDefaultsRequestToJSON(requestParameters['setPartnerDesignDefaultsRequest']),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Send `{ \"design\": { ... } }` to store a JSON object (at most 64 KB, nesting depth 32), or `{ \"design\": null }` to remove the override. New compositions for this customer merge this layer over the partner default and under the request body.
+     * Set or clear design defaults for one managed user
+     */
+    setManagedUserDesignDefaults(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setManagedUserDesignDefaultsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Send monthly_credits as a whole number from 0 up to 2147483647 to cap what this customer\'s editor sessions may spend in a UTC calendar month, or null to remove the cap. The cap counts the credits the customer\'s sessions spent that month (refunded credits do not count) and applies to all of the customer\'s sessions together, beside any `max_credits` a single session was given. A cap of 0 stops all paid work by this customer until you raise it. The cap starts counting from the first of the month (UTC); a cap set below what was already spent this month stops further work at once.
+     * Set or clear the monthly credit cap for one managed user
+     */
+    setManagedUserLimitsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['id'] == null) {
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling setManagedUserLimits().');
+            }
+            if (requestParameters['setManagedUserLimitsRequest'] == null) {
+                throw new runtime.RequiredError('setManagedUserLimitsRequest', 'Required parameter "setManagedUserLimitsRequest" was null or undefined when calling setManagedUserLimits().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("apiKeyAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/managed-users/{id}/limits`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: SetManagedUserLimitsRequestToJSON(requestParameters['setManagedUserLimitsRequest']),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Send monthly_credits as a whole number from 0 up to 2147483647 to cap what this customer\'s editor sessions may spend in a UTC calendar month, or null to remove the cap. The cap counts the credits the customer\'s sessions spent that month (refunded credits do not count) and applies to all of the customer\'s sessions together, beside any `max_credits` a single session was given. A cap of 0 stops all paid work by this customer until you raise it. The cap starts counting from the first of the month (UTC); a cap set below what was already spent this month stops further work at once.
+     * Set or clear the monthly credit cap for one managed user
+     */
+    setManagedUserLimits(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setManagedUserLimitsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Updates an existing managed user. Only `external_id`, `metadata` and `is_active` can change, and `metadata` is replaced as a whole, so send all of it. `is_active: false` switches the managed user off: what it already has stays, and nothing new can be filed under it until you send `is_active: true`. Switching it off also ends all of its editor sessions, and they do not come back when you switch it on again.  The `Idempotency-Key` header is required (`400` without it).
      * Update Managed User

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

@@ -15,7 +15,7 @@ export interface OperationsIdCancelPostRequest {
     id: string;
     idempotencyKey?: string;
 }
-export interface OperationsIdGetRequest {
+export interface OperationsIdGet0Request {
     id: string;
 }
 export interface OperationsStreamGetRequest {
@@ -39,12 +39,12 @@ export declare class OperationsApi extends runtime.BaseAPI {
      * Follows work that carries on after the response that started it. Duplicating a composition, for one, answers 202 with an `operationId`: ask for that operation until its `status` is `completed` (or `failed`, with the reason in `error`). A finished duplication names the new composition in `metadata.newCompositionId`.  An operation belongs to the user who started it. Asking for somebody else\'s operation answers 404, exactly as for one that does not exist. Administrators may read any operation.
      * Get operation status
      */
-    operationsIdGetRaw(requestParameters: OperationsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OperationsIdGet200Response>>;
+    operationsIdGetRaw(requestParameters: OperationsIdGet0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OperationsIdGet200Response>>;
     /**
      * Follows work that carries on after the response that started it. Duplicating a composition, for one, answers 202 with an `operationId`: ask for that operation until its `status` is `completed` (or `failed`, with the reason in `error`). A finished duplication names the new composition in `metadata.newCompositionId`.  An operation belongs to the user who started it. Asking for somebody else\'s operation answers 404, exactly as for one that does not exist. Administrators may read any operation.
      * Get operation status
      */
-    operationsIdGet(requestParameters: OperationsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OperationsIdGet200Response>;
+    operationsIdGet(requestParameters: OperationsIdGet0Request, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OperationsIdGet200Response>;
     /**
      * Opens a server-sent events stream for long-running operations.  An operation belongs to the user who started it, so the stream carries your own operations only. Following an operation that is somebody else\'s answers 404, exactly as for one that does not exist. Administrators may follow any operation.  Cross-origin access follows the gateway\'s origin allow-list; the stream never answers with a wildcard `Access-Control-Allow-Origin`.
      * Stream operation updates