@widgetic/api-sdk 1.0.24 → 1.0.26

package/dist/esm/apis/SubscriptionsApi.js

@@ -21,50 +21,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime.js';
-import { ApiV1SubscriptionsIdRefundPreviewPost200ResponseFromJSON, ApiV1SubscriptionsIdRefundPreviewPostRequestToJSON, GetBillingReports200ResponseInnerFromJSON, MoveSubscriptionSurfaceRequestToJSON, NewSubscriptionToJSON, ProcessRefund200ResponseFromJSON, RefundRequestToJSON, SubscriptionFromJSON, UpdateSubscriptionToJSON, } from '../models/index.js';
+import { GetBillingReports200ResponseInnerFromJSON, MoveSubscriptionSurfaceRequestToJSON, NewSubscriptionToJSON, ProcessRefund200ResponseFromJSON, RefundRequestToJSON, SubscriptionFromJSON, SubscriptionsIdRefundPreviewPost200ResponseFromJSON, SubscriptionsIdRefundPreviewPostRequestToJSON, UpdateSubscriptionToJSON, } from '../models/index.js';
 /**
  *
  */
 export class SubscriptionsApi extends runtime.BaseAPI {
-    /**
-     * Resolves the subscription\'s latest paid charge exactly as the refund endpoint does and returns the derived amount, the plan\'s credit rate and — for an organization subscription — the per-member clawback the refund would make, before any money moves. Writes nothing: no Stripe refund, no audit row, no idempotency entry. Every guard refusal the refund endpoint can raise is raised here identically, so a client can drive its confirm dialog off a successful preview.
-     * Preview this subscription\'s refund without issuing it (dry run)
-     */
-    apiV1SubscriptionsIdRefundPreviewPostRaw(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 apiV1SubscriptionsIdRefundPreviewPost().');
-            }
-            const queryParameters = {};
-            const headerParameters = {};
-            headerParameters['Content-Type'] = 'application/json';
-            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: `/api/v1/subscriptions/{id}/refund/preview`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-                method: 'POST',
-                headers: headerParameters,
-                query: queryParameters,
-                body: ApiV1SubscriptionsIdRefundPreviewPostRequestToJSON(requestParameters['apiV1SubscriptionsIdRefundPreviewPostRequest']),
-            }, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => ApiV1SubscriptionsIdRefundPreviewPost200ResponseFromJSON(jsonValue));
-        });
-    }
-    /**
-     * Resolves the subscription\'s latest paid charge exactly as the refund endpoint does and returns the derived amount, the plan\'s credit rate and — for an organization subscription — the per-member clawback the refund would make, before any money moves. Writes nothing: no Stripe refund, no audit row, no idempotency entry. Every guard refusal the refund endpoint can raise is raised here identically, so a client can drive its confirm dialog off a successful preview.
-     * Preview this subscription\'s refund without issuing it (dry run)
-     */
-    apiV1SubscriptionsIdRefundPreviewPost(requestParameters, initOverrides) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.apiV1SubscriptionsIdRefundPreviewPostRaw(requestParameters, initOverrides);
-            return yield response.value();
-        });
-    }
     /**
      * Creates a new subscription. Admin only.
      * Create subscription
@@ -261,7 +222,7 @@ export class SubscriptionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves all subscriptions for a specific user.
+     * Retrieves all subscriptions for a specific user. Administrators only. An account reads its own plan and billing state through `GET /billing/users/{userId}/subscription`.
      * Get user subscriptions
      */
     getSubscriptionsByUserIdRaw(requestParameters, initOverrides) {
@@ -288,7 +249,7 @@ export class SubscriptionsApi extends runtime.BaseAPI {
                 }
             }
             const response = yield this.request({
-                path: `/users/{userId}/subscriptions`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                path: `/subscriptions/user/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
@@ -297,7 +258,7 @@ export class SubscriptionsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves all subscriptions for a specific user.
+     * Retrieves all subscriptions for a specific user. Administrators only. An account reads its own plan and billing state through `GET /billing/users/{userId}/subscription`.
      * Get user subscriptions
      */
     getSubscriptionsByUserId(requestParameters, initOverrides) {
@@ -386,6 +347,45 @@ export class SubscriptionsApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Resolves the subscription\'s latest paid charge exactly as the refund endpoint does and returns the derived amount, the plan\'s credit rate and — for an organization subscription — the per-member clawback the refund would make, before any money moves. Writes nothing: no Stripe refund, no audit row, no idempotency entry. Every guard refusal the refund endpoint can raise is raised here identically, so a client can drive its confirm dialog off a successful preview.
+     * Preview this subscription\'s refund without issuing it (dry run)
+     */
+    subscriptionsIdRefundPreviewPostRaw(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 subscriptionsIdRefundPreviewPost().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            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: `/subscriptions/{id}/refund/preview`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: SubscriptionsIdRefundPreviewPostRequestToJSON(requestParameters['subscriptionsIdRefundPreviewPostRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => SubscriptionsIdRefundPreviewPost200ResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Resolves the subscription\'s latest paid charge exactly as the refund endpoint does and returns the derived amount, the plan\'s credit rate and — for an organization subscription — the per-member clawback the refund would make, before any money moves. Writes nothing: no Stripe refund, no audit row, no idempotency entry. Every guard refusal the refund endpoint can raise is raised here identically, so a client can drive its confirm dialog off a successful preview.
+     * Preview this subscription\'s refund without issuing it (dry run)
+     */
+    subscriptionsIdRefundPreviewPost(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.subscriptionsIdRefundPreviewPostRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Updates an existing subscription. Admin only.
      * Update subscription

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

@@ -10,12 +10,21 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
+import type { Upload, UploadLimits, UploadsGet200Response } from '../models/index';
+export interface UploadsGetRequest {
+    limit?: number;
+    managedUserId?: string;
+    managedUserExternalId?: string;
+}
+export interface UploadsIdGetRequest {
+    id: string;
+}
 export interface UploadsPostRequest {
     file: Blob;
     contextType?: UploadsPostContextTypeEnum;
     source?: UploadsPostSourceEnum;
-    widgetId?: string;
-    conversationId?: string;
+    managedUserId?: string;
+    managedUserExternalId?: string;
 }
 export interface UploadsTusIdCompletePostRequest {
     id: string;
@@ -25,45 +34,55 @@ export interface UploadsTusIdCompletePostRequest {
  */
 export declare class UploadsApi extends runtime.BaseAPI {
     /**
-     * List user uploads (for FileBrowser hydration)
+     * The files the account has uploaded, newest first. Deleted files are not listed. Returns at most `limit` files and has no further pages: a client that needs more narrows the list instead, for example to one managed user\'s files with `managed_user_id` or `managed_user_external_id`.
+     * List the account\'s uploads
      */
-    uploadsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    uploadsGetRaw(requestParameters: UploadsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UploadsGet200Response>>;
     /**
-     * List user uploads (for FileBrowser hydration)
+     * The files the account has uploaded, newest first. Deleted files are not listed. Returns at most `limit` files and has no further pages: a client that needs more narrows the list instead, for example to one managed user\'s files with `managed_user_id` or `managed_user_external_id`.
+     * List the account\'s uploads
      */
-    uploadsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    uploadsGet(requestParameters?: UploadsGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UploadsGet200Response>;
     /**
-     * Get upload metadata by id
+     * The details of one of the account\'s uploads. An upload that belongs to another account is not found.
+     * Get an upload by id
      */
-    uploadsIdGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    uploadsIdGetRaw(requestParameters: UploadsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Upload>>;
     /**
-     * Get upload metadata by id
+     * The details of one of the account\'s uploads. An upload that belongs to another account is not found.
+     * Get an upload by id
      */
-    uploadsIdGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    uploadsIdGet(requestParameters: UploadsIdGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Upload>;
     /**
-     * Upload size limits and MIME allowlists (for clients — do not hardcode thresholds)
+     * The size limit and the accepted file types of the upload endpoints. Read them from here rather than hard-coding thresholds: they are configuration and can change. The limits are the same for every account, whatever its plan: `multipart_max_bytes` for a file sent in one request (10 MB) and `tus_max_bytes` for a resumable upload (250 MB).
+     * Upload size limits and accepted file types
      */
-    uploadsLimitsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    uploadsLimitsGetRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UploadLimits>>;
     /**
-     * Upload size limits and MIME allowlists (for clients — do not hardcode thresholds)
+     * The size limit and the accepted file types of the upload endpoints. Read them from here rather than hard-coding thresholds: they are configuration and can change. The limits are the same for every account, whatever its plan: `multipart_max_bytes` for a file sent in one request (10 MB) and `tus_max_bytes` for a resumable upload (250 MB).
+     * Upload size limits and accepted file types
      */
-    uploadsLimitsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    uploadsLimitsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UploadLimits>;
     /**
-     * Upload a user file for widget codegen, Browser IC, or content properties
+     * Stores one file for the account and returns its public address. This is how a user\'s own images, video and PDFs reach a widget\'s content.  Send a `multipart/form-data` request with the file in the field named `file`. The file counts against the account\'s storage allowance, and a full allowance is refused with 413 and `QUOTA_STORAGE_EXCEEDED`. A file over the size limit is refused with 413 and `UPLOAD_TOO_LARGE`, and a type that is not accepted with 415 and `UPLOAD_UNSUPPORTED_TYPE`; `uploadsLimitsGet` lists the size limit and the accepted types.  To upload the file for one of your managed users, send `managed_user_id` (Widgetic\'s id for the user) or `managed_user_external_id` (your own identifier for the user), not both. The file stays in your account and counts against its allowance; the tag lets you list one user\'s files with `uploadsGet`. The managed user must be yours and active: one that is not yours, or does not exist, is refused with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`, before the file is stored. The tag is set here and does not change afterwards.  Called with an editor session (`createManagedUserEditorSession`), the file is always filed for the session\'s own managed user and is always media for widget content: naming another managed user is refused with 403 and `MANAGED_USER_SESSION_MISMATCH`, and `context_type`, `source`, `widget_id` and `conversation_id` are ignored. A full storage allowance is refused with the same 413 and `QUOTA_STORAGE_EXCEEDED`, but the message only says that it is not available right now (not how much is stored: that is the partner\'s business) and `error.details.limit` is `storage`.  An account that administers a partner with a storage destination (`setPartnerStorageDestination`) has its files stored in the partner\'s own bucket instead. Such a file takes none of the allowance, its `url` is served from the partner\'s public address, and its `storage_key` is the key in the partner\'s bucket. The file is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 and `STORAGE_DESTINATION_UNAVAILABLE`, and when the partner\'s storage rejects the file with 502 and `STORAGE_DESTINATION_WRITE_FAILED`.  Partner storage is not optional. A partner\'s own uploads (with its API key) and the uploads of its customers\' editor sessions are kept in the partner\'s own storage or not at all, so a partner with no destination (or one that removed it after the session was made) has them refused with 409 and `PARTNER_STORAGE_REQUIRED`; they are never stored with Widgetic. An editor session\'s browser is only told that the feature is not available right now.
+     * Upload a file
      */
-    uploadsPostRaw(requestParameters: UploadsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    uploadsPostRaw(requestParameters: UploadsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Upload>>;
     /**
-     * Upload a user file for widget codegen, Browser IC, or content properties
+     * Stores one file for the account and returns its public address. This is how a user\'s own images, video and PDFs reach a widget\'s content.  Send a `multipart/form-data` request with the file in the field named `file`. The file counts against the account\'s storage allowance, and a full allowance is refused with 413 and `QUOTA_STORAGE_EXCEEDED`. A file over the size limit is refused with 413 and `UPLOAD_TOO_LARGE`, and a type that is not accepted with 415 and `UPLOAD_UNSUPPORTED_TYPE`; `uploadsLimitsGet` lists the size limit and the accepted types.  To upload the file for one of your managed users, send `managed_user_id` (Widgetic\'s id for the user) or `managed_user_external_id` (your own identifier for the user), not both. The file stays in your account and counts against its allowance; the tag lets you list one user\'s files with `uploadsGet`. The managed user must be yours and active: one that is not yours, or does not exist, is refused with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`, before the file is stored. The tag is set here and does not change afterwards.  Called with an editor session (`createManagedUserEditorSession`), the file is always filed for the session\'s own managed user and is always media for widget content: naming another managed user is refused with 403 and `MANAGED_USER_SESSION_MISMATCH`, and `context_type`, `source`, `widget_id` and `conversation_id` are ignored. A full storage allowance is refused with the same 413 and `QUOTA_STORAGE_EXCEEDED`, but the message only says that it is not available right now (not how much is stored: that is the partner\'s business) and `error.details.limit` is `storage`.  An account that administers a partner with a storage destination (`setPartnerStorageDestination`) has its files stored in the partner\'s own bucket instead. Such a file takes none of the allowance, its `url` is served from the partner\'s public address, and its `storage_key` is the key in the partner\'s bucket. The file is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 and `STORAGE_DESTINATION_UNAVAILABLE`, and when the partner\'s storage rejects the file with 502 and `STORAGE_DESTINATION_WRITE_FAILED`.  Partner storage is not optional. A partner\'s own uploads (with its API key) and the uploads of its customers\' editor sessions are kept in the partner\'s own storage or not at all, so a partner with no destination (or one that removed it after the session was made) has them refused with 409 and `PARTNER_STORAGE_REQUIRED`; they are never stored with Widgetic. An editor session\'s browser is only told that the feature is not available right now.
+     * Upload a file
      */
-    uploadsPost(requestParameters: UploadsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    uploadsPost(requestParameters: UploadsPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Upload>;
     /**
-     * Finalize a TUS upload — stream to R2 and persist metadata
+     * Resumable uploads carry a file of up to 250 MB (the limit `tus_max_bytes` of `uploadsLimitsGet`, the same for every account) in pieces that can be resumed after a dropped connection, or after the server was restarted: the pieces wait in shared storage, not on one server. They follow the [tus protocol](https://tus.io): `POST /uploads/tus` declares the file (`Upload-Length` and the `Upload-Metadata` keys `filename`, `filetype` and, optionally, `context_type`, `source`, `widget_id` and `conversation_id`), `PATCH` sends the bytes, `HEAD` says how far a client got. They need a signed-in session; an API key uses `uploadsPost`.  This call stores the finished file: it counts against the account\'s storage allowance only now, not while the file is on its way, so an upload that is abandoned costs nothing. It is safe to call again after a lost answer: the file that was stored is returned, not stored twice. A file that could not be stored (storage down, allowance full) stays available for a day from when the upload began, so the call can be repeated without sending the file again. An unfinished upload is deleted after that day, and an account can hold only a few at once.
+     * Finish a resumable upload — store the file and return it
      */
-    uploadsTusIdCompletePostRaw(requestParameters: UploadsTusIdCompletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    uploadsTusIdCompletePostRaw(requestParameters: UploadsTusIdCompletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Upload>>;
     /**
-     * Finalize a TUS upload — stream to R2 and persist metadata
+     * Resumable uploads carry a file of up to 250 MB (the limit `tus_max_bytes` of `uploadsLimitsGet`, the same for every account) in pieces that can be resumed after a dropped connection, or after the server was restarted: the pieces wait in shared storage, not on one server. They follow the [tus protocol](https://tus.io): `POST /uploads/tus` declares the file (`Upload-Length` and the `Upload-Metadata` keys `filename`, `filetype` and, optionally, `context_type`, `source`, `widget_id` and `conversation_id`), `PATCH` sends the bytes, `HEAD` says how far a client got. They need a signed-in session; an API key uses `uploadsPost`.  This call stores the finished file: it counts against the account\'s storage allowance only now, not while the file is on its way, so an upload that is abandoned costs nothing. It is safe to call again after a lost answer: the file that was stored is returned, not stored twice. A file that could not be stored (storage down, allowance full) stays available for a day from when the upload began, so the call can be repeated without sending the file again. An unfinished upload is deleted after that day, and an account can hold only a few at once.
+     * Finish a resumable upload — store the file and return it
      */
-    uploadsTusIdCompletePost(requestParameters: UploadsTusIdCompletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    uploadsTusIdCompletePost(requestParameters: UploadsTusIdCompletePostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Upload>;
 }
 /**
  * @export

package/dist/esm/apis/UploadsApi.js

@@ -21,84 +21,128 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime.js';
+import { UploadFromJSON, UploadLimitsFromJSON, UploadsGet200ResponseFromJSON, } from '../models/index.js';
 /**
  *
  */
 export class UploadsApi extends runtime.BaseAPI {
     /**
-     * List user uploads (for FileBrowser hydration)
+     * The files the account has uploaded, newest first. Deleted files are not listed. Returns at most `limit` files and has no further pages: a client that needs more narrows the list instead, for example to one managed user\'s files with `managed_user_id` or `managed_user_external_id`.
+     * List the account\'s uploads
      */
-    uploadsGetRaw(initOverrides) {
+    uploadsGetRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
+            if (requestParameters['limit'] != null) {
+                queryParameters['limit'] = requestParameters['limit'];
+            }
+            if (requestParameters['managedUserId'] != null) {
+                queryParameters['managed_user_id'] = requestParameters['managedUserId'];
+            }
+            if (requestParameters['managedUserExternalId'] != null) {
+                queryParameters['managed_user_external_id'] = requestParameters['managedUserExternalId'];
+            }
             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: `/uploads`,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UploadsGet200ResponseFromJSON(jsonValue));
         });
     }
     /**
-     * List user uploads (for FileBrowser hydration)
+     * The files the account has uploaded, newest first. Deleted files are not listed. Returns at most `limit` files and has no further pages: a client that needs more narrows the list instead, for example to one managed user\'s files with `managed_user_id` or `managed_user_external_id`.
+     * List the account\'s uploads
      */
-    uploadsGet(initOverrides) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.uploadsGetRaw(initOverrides);
+    uploadsGet() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.uploadsGetRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
-     * Get upload metadata by id
+     * The details of one of the account\'s uploads. An upload that belongs to another account is not found.
+     * Get an upload by id
      */
-    uploadsIdGetRaw(initOverrides) {
+    uploadsIdGetRaw(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 uploadsIdGet().');
+            }
             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: `/uploads/{id}`,
+                path: `/uploads/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UploadFromJSON(jsonValue));
         });
     }
     /**
-     * Get upload metadata by id
+     * The details of one of the account\'s uploads. An upload that belongs to another account is not found.
+     * Get an upload by id
      */
-    uploadsIdGet(initOverrides) {
+    uploadsIdGet(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.uploadsIdGetRaw(initOverrides);
+            const response = yield this.uploadsIdGetRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
-     * Upload size limits and MIME allowlists (for clients — do not hardcode thresholds)
+     * The size limit and the accepted file types of the upload endpoints. Read them from here rather than hard-coding thresholds: they are configuration and can change. The limits are the same for every account, whatever its plan: `multipart_max_bytes` for a file sent in one request (10 MB) and `tus_max_bytes` for a resumable upload (250 MB).
+     * Upload size limits and accepted file types
      */
     uploadsLimitsGetRaw(initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
             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: `/uploads/limits`,
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UploadLimitsFromJSON(jsonValue));
         });
     }
     /**
-     * Upload size limits and MIME allowlists (for clients — do not hardcode thresholds)
+     * The size limit and the accepted file types of the upload endpoints. Read them from here rather than hard-coding thresholds: they are configuration and can change. The limits are the same for every account, whatever its plan: `multipart_max_bytes` for a file sent in one request (10 MB) and `tus_max_bytes` for a resumable upload (250 MB).
+     * Upload size limits and accepted file types
      */
     uploadsLimitsGet(initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.uploadsLimitsGetRaw(initOverrides);
+            const response = yield this.uploadsLimitsGetRaw(initOverrides);
+            return yield response.value();
         });
     }
     /**
-     * Upload a user file for widget codegen, Browser IC, or content properties
+     * Stores one file for the account and returns its public address. This is how a user\'s own images, video and PDFs reach a widget\'s content.  Send a `multipart/form-data` request with the file in the field named `file`. The file counts against the account\'s storage allowance, and a full allowance is refused with 413 and `QUOTA_STORAGE_EXCEEDED`. A file over the size limit is refused with 413 and `UPLOAD_TOO_LARGE`, and a type that is not accepted with 415 and `UPLOAD_UNSUPPORTED_TYPE`; `uploadsLimitsGet` lists the size limit and the accepted types.  To upload the file for one of your managed users, send `managed_user_id` (Widgetic\'s id for the user) or `managed_user_external_id` (your own identifier for the user), not both. The file stays in your account and counts against its allowance; the tag lets you list one user\'s files with `uploadsGet`. The managed user must be yours and active: one that is not yours, or does not exist, is refused with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`, before the file is stored. The tag is set here and does not change afterwards.  Called with an editor session (`createManagedUserEditorSession`), the file is always filed for the session\'s own managed user and is always media for widget content: naming another managed user is refused with 403 and `MANAGED_USER_SESSION_MISMATCH`, and `context_type`, `source`, `widget_id` and `conversation_id` are ignored. A full storage allowance is refused with the same 413 and `QUOTA_STORAGE_EXCEEDED`, but the message only says that it is not available right now (not how much is stored: that is the partner\'s business) and `error.details.limit` is `storage`.  An account that administers a partner with a storage destination (`setPartnerStorageDestination`) has its files stored in the partner\'s own bucket instead. Such a file takes none of the allowance, its `url` is served from the partner\'s public address, and its `storage_key` is the key in the partner\'s bucket. The file is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 and `STORAGE_DESTINATION_UNAVAILABLE`, and when the partner\'s storage rejects the file with 502 and `STORAGE_DESTINATION_WRITE_FAILED`.  Partner storage is not optional. A partner\'s own uploads (with its API key) and the uploads of its customers\' editor sessions are kept in the partner\'s own storage or not at all, so a partner with no destination (or one that removed it after the session was made) has them refused with 409 and `PARTNER_STORAGE_REQUIRED`; they are never stored with Widgetic. An editor session\'s browser is only told that the feature is not available right now.
+     * Upload a file
      */
     uploadsPostRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -107,6 +151,13 @@ export class UploadsApi extends runtime.BaseAPI {
             }
             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 consumes = [
                 { contentType: 'multipart/form-data' },
             ];
@@ -131,11 +182,11 @@ export class UploadsApi extends runtime.BaseAPI {
             if (requestParameters['source'] != null) {
                 formParams.append('source', requestParameters['source']);
             }
-            if (requestParameters['widgetId'] != null) {
-                formParams.append('widget_id', requestParameters['widgetId']);
+            if (requestParameters['managedUserId'] != null) {
+                formParams.append('managed_user_id', requestParameters['managedUserId']);
             }
-            if (requestParameters['conversationId'] != null) {
-                formParams.append('conversation_id', requestParameters['conversationId']);
+            if (requestParameters['managedUserExternalId'] != null) {
+                formParams.append('managed_user_external_id', requestParameters['managedUserExternalId']);
             }
             const response = yield this.request({
                 path: `/uploads`,
@@ -144,19 +195,22 @@ export class UploadsApi extends runtime.BaseAPI {
                 query: queryParameters,
                 body: formParams,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UploadFromJSON(jsonValue));
         });
     }
     /**
-     * Upload a user file for widget codegen, Browser IC, or content properties
+     * Stores one file for the account and returns its public address. This is how a user\'s own images, video and PDFs reach a widget\'s content.  Send a `multipart/form-data` request with the file in the field named `file`. The file counts against the account\'s storage allowance, and a full allowance is refused with 413 and `QUOTA_STORAGE_EXCEEDED`. A file over the size limit is refused with 413 and `UPLOAD_TOO_LARGE`, and a type that is not accepted with 415 and `UPLOAD_UNSUPPORTED_TYPE`; `uploadsLimitsGet` lists the size limit and the accepted types.  To upload the file for one of your managed users, send `managed_user_id` (Widgetic\'s id for the user) or `managed_user_external_id` (your own identifier for the user), not both. The file stays in your account and counts against its allowance; the tag lets you list one user\'s files with `uploadsGet`. The managed user must be yours and active: one that is not yours, or does not exist, is refused with 404 and `MANAGED_USER_NOT_FOUND`, and one that is switched off with 409 and `MANAGED_USER_INACTIVE`, before the file is stored. The tag is set here and does not change afterwards.  Called with an editor session (`createManagedUserEditorSession`), the file is always filed for the session\'s own managed user and is always media for widget content: naming another managed user is refused with 403 and `MANAGED_USER_SESSION_MISMATCH`, and `context_type`, `source`, `widget_id` and `conversation_id` are ignored. A full storage allowance is refused with the same 413 and `QUOTA_STORAGE_EXCEEDED`, but the message only says that it is not available right now (not how much is stored: that is the partner\'s business) and `error.details.limit` is `storage`.  An account that administers a partner with a storage destination (`setPartnerStorageDestination`) has its files stored in the partner\'s own bucket instead. Such a file takes none of the allowance, its `url` is served from the partner\'s public address, and its `storage_key` is the key in the partner\'s bucket. The file is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 and `STORAGE_DESTINATION_UNAVAILABLE`, and when the partner\'s storage rejects the file with 502 and `STORAGE_DESTINATION_WRITE_FAILED`.  Partner storage is not optional. A partner\'s own uploads (with its API key) and the uploads of its customers\' editor sessions are kept in the partner\'s own storage or not at all, so a partner with no destination (or one that removed it after the session was made) has them refused with 409 and `PARTNER_STORAGE_REQUIRED`; they are never stored with Widgetic. An editor session\'s browser is only told that the feature is not available right now.
+     * Upload a file
      */
     uploadsPost(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.uploadsPostRaw(requestParameters, initOverrides);
+            const response = yield this.uploadsPostRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
-     * Finalize a TUS upload — stream to R2 and persist metadata
+     * Resumable uploads carry a file of up to 250 MB (the limit `tus_max_bytes` of `uploadsLimitsGet`, the same for every account) in pieces that can be resumed after a dropped connection, or after the server was restarted: the pieces wait in shared storage, not on one server. They follow the [tus protocol](https://tus.io): `POST /uploads/tus` declares the file (`Upload-Length` and the `Upload-Metadata` keys `filename`, `filetype` and, optionally, `context_type`, `source`, `widget_id` and `conversation_id`), `PATCH` sends the bytes, `HEAD` says how far a client got. They need a signed-in session; an API key uses `uploadsPost`.  This call stores the finished file: it counts against the account\'s storage allowance only now, not while the file is on its way, so an upload that is abandoned costs nothing. It is safe to call again after a lost answer: the file that was stored is returned, not stored twice. A file that could not be stored (storage down, allowance full) stays available for a day from when the upload began, so the call can be repeated without sending the file again. An unfinished upload is deleted after that day, and an account can hold only a few at once.
+     * Finish a resumable upload — store the file and return it
      */
     uploadsTusIdCompletePostRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -171,15 +225,17 @@ export class UploadsApi extends runtime.BaseAPI {
                 headers: headerParameters,
                 query: queryParameters,
             }, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UploadFromJSON(jsonValue));
         });
     }
     /**
-     * Finalize a TUS upload — stream to R2 and persist metadata
+     * Resumable uploads carry a file of up to 250 MB (the limit `tus_max_bytes` of `uploadsLimitsGet`, the same for every account) in pieces that can be resumed after a dropped connection, or after the server was restarted: the pieces wait in shared storage, not on one server. They follow the [tus protocol](https://tus.io): `POST /uploads/tus` declares the file (`Upload-Length` and the `Upload-Metadata` keys `filename`, `filetype` and, optionally, `context_type`, `source`, `widget_id` and `conversation_id`), `PATCH` sends the bytes, `HEAD` says how far a client got. They need a signed-in session; an API key uses `uploadsPost`.  This call stores the finished file: it counts against the account\'s storage allowance only now, not while the file is on its way, so an upload that is abandoned costs nothing. It is safe to call again after a lost answer: the file that was stored is returned, not stored twice. A file that could not be stored (storage down, allowance full) stays available for a day from when the upload began, so the call can be repeated without sending the file again. An unfinished upload is deleted after that day, and an account can hold only a few at once.
+     * Finish a resumable upload — store the file and return it
      */
     uploadsTusIdCompletePost(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.uploadsTusIdCompletePostRaw(requestParameters, initOverrides);
+            const response = yield this.uploadsTusIdCompletePostRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
 }

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

@@ -80,32 +80,32 @@ export declare class UsageApi extends runtime.BaseAPI {
      */
     getUsageById(requestParameters: GetUsageByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<object>;
     /**
-     * Retrieves usage metrics for a specific user.
+     * Retrieves the usage metrics recorded for a specific user through `recordUsage`. Administrators only. The credits an account spent are read from its credit ledger, as `debit` entries (`getUserCreditTransactions`).
      * Get user usage metrics
      */
     getUserUsageRaw(requestParameters: GetUserUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<object>>>;
     /**
-     * Retrieves usage metrics for a specific user.
+     * Retrieves the usage metrics recorded for a specific user through `recordUsage`. Administrators only. The credits an account spent are read from its credit ledger, as `debit` entries (`getUserCreditTransactions`).
      * Get user usage metrics
      */
     getUserUsage(requestParameters: GetUserUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>>;
     /**
-     * Retrieves aggregated usage metrics for a user.
+     * Retrieves aggregated usage metrics for a user. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get aggregated user usage
      */
     getUserUsageAggregatedRaw(requestParameters: GetUserUsageAggregatedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<object>>>;
     /**
-     * Retrieves aggregated usage metrics for a user.
+     * Retrieves aggregated usage metrics for a user. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get aggregated user usage
      */
     getUserUsageAggregated(requestParameters: GetUserUsageAggregatedRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<object>>;
     /**
-     * Retrieves usage summary for the current billing period.
+     * Retrieves usage summary for the current billing period. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get user usage summary
      */
     getUserUsageSummaryRaw(requestParameters: GetUserUsageSummaryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<object>>;
     /**
-     * Retrieves usage summary for the current billing period.
+     * Retrieves usage summary for the current billing period. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get user usage summary
      */
     getUserUsageSummary(requestParameters: GetUserUsageSummaryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<object>;

package/dist/esm/apis/UsageApi.js

@@ -154,7 +154,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves usage metrics for a specific user.
+     * Retrieves the usage metrics recorded for a specific user through `recordUsage`. Administrators only. The credits an account spent are read from its credit ledger, as `debit` entries (`getUserCreditTransactions`).
      * Get user usage metrics
      */
     getUserUsageRaw(requestParameters, initOverrides) {
@@ -187,7 +187,7 @@ export class UsageApi extends runtime.BaseAPI {
                 }
             }
             const response = yield this.request({
-                path: `/users/{userId}/usage`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                path: `/usage/user/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
@@ -196,7 +196,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves usage metrics for a specific user.
+     * Retrieves the usage metrics recorded for a specific user through `recordUsage`. Administrators only. The credits an account spent are read from its credit ledger, as `debit` entries (`getUserCreditTransactions`).
      * Get user usage metrics
      */
     getUserUsage(requestParameters, initOverrides) {
@@ -206,7 +206,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves aggregated usage metrics for a user.
+     * Retrieves aggregated usage metrics for a user. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get aggregated user usage
      */
     getUserUsageAggregatedRaw(requestParameters, initOverrides) {
@@ -236,7 +236,7 @@ export class UsageApi extends runtime.BaseAPI {
                 }
             }
             const response = yield this.request({
-                path: `/users/{userId}/usage/aggregated`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                path: `/usage/user/{userId}/aggregated`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
@@ -245,7 +245,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves aggregated usage metrics for a user.
+     * Retrieves aggregated usage metrics for a user. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get aggregated user usage
      */
     getUserUsageAggregated(requestParameters, initOverrides) {
@@ -255,7 +255,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves usage summary for the current billing period.
+     * Retrieves usage summary for the current billing period. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get user usage summary
      */
     getUserUsageSummaryRaw(requestParameters, initOverrides) {
@@ -273,7 +273,7 @@ export class UsageApi extends runtime.BaseAPI {
                 }
             }
             const response = yield this.request({
-                path: `/users/{userId}/usage/summary`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+                path: `/usage/user/{userId}/summary`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
                 method: 'GET',
                 headers: headerParameters,
                 query: queryParameters,
@@ -282,7 +282,7 @@ export class UsageApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Retrieves usage summary for the current billing period.
+     * Retrieves usage summary for the current billing period. Administrators only. An account reads the credits it spent from its credit ledger (`getUserCreditTransactions`).
      * Get user usage summary
      */
     getUserUsageSummary(requestParameters, initOverrides) {