@widgetic/api-sdk 1.0.25 → 1.0.27

package/dist/apis/PartnersApi.d.ts

@@ -134,12 +134,12 @@ export declare class PartnersApi extends runtime.BaseAPI {
      */
     getPartnerCreditTransactions(requestParameters: GetPartnerCreditTransactionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
-     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means its own uploads are stored with Widgetic, and that its customers cannot upload through an editor session (a session with the `files` surface is not made until a destination is set).  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means the partner cannot be activated, its uploads are refused, and no editor session is made for its customers until a destination is set.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Get where a partner\'s uploaded files are stored
      */
     getPartnerStorageDestinationRaw(requestParameters: GetPartnerStorageDestinationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PartnerStorageDestination>>;
     /**
-     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means its own uploads are stored with Widgetic, and that its customers cannot upload through an editor session (a session with the `files` surface is not made until a destination is set).  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means the partner cannot be activated, its uploads are refused, and no editor session is made for its customers until a destination is set.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Get where a partner\'s uploaded files are stored
      */
     getPartnerStorageDestination(requestParameters: GetPartnerStorageDestinationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerStorageDestination>;
@@ -164,12 +164,12 @@ export declare class PartnersApi extends runtime.BaseAPI {
      */
     removePartnerPreset(requestParameters: RemovePartnerPresetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerPresetRemoval>;
     /**
-     * Removes the partner\'s storage destination. The account\'s own uploads after this are stored with Widgetic again and count against its storage allowance. The uploads of your customers\' editor sessions are not: they are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no session with the `files` surface can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Removes the partner\'s storage destination. Partner storage is not optional, so after this the account\'s own uploads with its API key and the uploads of your customers\' editor sessions are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no editor session can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Stop storing a partner\'s uploaded files in its own bucket
      */
     removePartnerStorageDestinationRaw(requestParameters: RemovePartnerStorageDestinationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PartnerStorageRemoval>>;
     /**
-     * Removes the partner\'s storage destination. The account\'s own uploads after this are stored with Widgetic again and count against its storage allowance. The uploads of your customers\' editor sessions are not: they are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no session with the `files` surface can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Removes the partner\'s storage destination. Partner storage is not optional, so after this the account\'s own uploads with its API key and the uploads of your customers\' editor sessions are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no editor session can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Stop storing a partner\'s uploaded files in its own bucket
      */
     removePartnerStorageDestination(requestParameters: RemovePartnerStorageDestinationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerStorageRemoval>;
@@ -184,12 +184,12 @@ export declare class PartnersApi extends runtime.BaseAPI {
      */
     setPartnerPreset(requestParameters: SetPartnerPresetOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerPreset>;
     /**
-     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required for the files your customers upload. An editor session with the `files` surface (`createManagedUserEditorSession`) keeps its user\'s uploads in this destination and nowhere else, so it cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), and a destination removed later stops the uploads of the sessions already made (the same 409). Your own uploads, with your API key, do not need one.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
+     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required. Partner storage is not optional: your customers\' files, and your own uploads with your API key, are kept in this destination and nowhere else. An editor session (`createManagedUserEditorSession`) of any surface cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), a destination removed later stops the uploads of the sessions already made (the same 409), and your own upload with no destination is refused in the same way instead of being stored with Widgetic. A partner cannot be activated until it has a destination that works.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
      * Set where a partner\'s uploaded files are stored
      */
     setPartnerStorageDestinationRaw(requestParameters: SetPartnerStorageDestinationOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PartnerStorageDestination>>;
     /**
-     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required for the files your customers upload. An editor session with the `files` surface (`createManagedUserEditorSession`) keeps its user\'s uploads in this destination and nowhere else, so it cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), and a destination removed later stops the uploads of the sessions already made (the same 409). Your own uploads, with your API key, do not need one.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
+     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required. Partner storage is not optional: your customers\' files, and your own uploads with your API key, are kept in this destination and nowhere else. An editor session (`createManagedUserEditorSession`) of any surface cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), a destination removed later stops the uploads of the sessions already made (the same 409), and your own upload with no destination is refused in the same way instead of being stored with Widgetic. A partner cannot be activated until it has a destination that works.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
      * Set where a partner\'s uploaded files are stored
      */
     setPartnerStorageDestination(requestParameters: SetPartnerStorageDestinationOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PartnerStorageDestination>;

package/dist/apis/PartnersApi.js

@@ -300,7 +300,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means its own uploads are stored with Widgetic, and that its customers cannot upload through an editor session (a session with the `files` surface is not made until a destination is set).  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means the partner cannot be activated, its uploads are refused, and no editor session is made for its customers until a destination is set.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Get where a partner\'s uploaded files are stored
      */
     getPartnerStorageDestinationRaw(requestParameters, initOverrides) {
@@ -327,7 +327,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means its own uploads are stored with Widgetic, and that its customers cannot upload through an editor session (a session with the `files` surface is not made until a destination is set).  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Returns the partner\'s storage destination without its secret: the endpoint, bucket, folder and public address, the last four characters of the access key id, when the destination last passed the check, and why the latest re-check failed if it did. Responds 404 while the partner has no destination, which means the partner cannot be activated, its uploads are refused, and no editor session is made for its customers until a destination is set.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Get where a partner\'s uploaded files are stored
      */
     getPartnerStorageDestination(requestParameters, initOverrides) {
@@ -414,7 +414,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Removes the partner\'s storage destination. The account\'s own uploads after this are stored with Widgetic again and count against its storage allowance. The uploads of your customers\' editor sessions are not: they are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no session with the `files` surface can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Removes the partner\'s storage destination. Partner storage is not optional, so after this the account\'s own uploads with its API key and the uploads of your customers\' editor sessions are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no editor session can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Stop storing a partner\'s uploaded files in its own bucket
      */
     removePartnerStorageDestinationRaw(requestParameters, initOverrides) {
@@ -441,7 +441,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Removes the partner\'s storage destination. The account\'s own uploads after this are stored with Widgetic again and count against its storage allowance. The uploads of your customers\' editor sessions are not: they are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no session with the `files` surface can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
+     * Removes the partner\'s storage destination. Partner storage is not optional, so after this the account\'s own uploads with its API key and the uploads of your customers\' editor sessions are refused (409 `PARTNER_STORAGE_REQUIRED`) until a destination is set again, and no editor session can be made. Files already in the partner\'s bucket are not touched and are not moved: they stay where they are, at the addresses they were given.  Removing a destination the partner does not have is not an error: the answer is `removed: false`.  The caller must be the person who administers the partner, or a Widgetic administrator.
      * Stop storing a partner\'s uploaded files in its own bucket
      */
     removePartnerStorageDestination(requestParameters, initOverrides) {
@@ -496,7 +496,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required for the files your customers upload. An editor session with the `files` surface (`createManagedUserEditorSession`) keeps its user\'s uploads in this destination and nowhere else, so it cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), and a destination removed later stops the uploads of the sessions already made (the same 409). Your own uploads, with your API key, do not need one.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
+     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required. Partner storage is not optional: your customers\' files, and your own uploads with your API key, are kept in this destination and nowhere else. An editor session (`createManagedUserEditorSession`) of any surface cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), a destination removed later stops the uploads of the sessions already made (the same 409), and your own upload with no destination is refused in the same way instead of being stored with Widgetic. A partner cannot be activated until it has a destination that works.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
      * Set where a partner\'s uploaded files are stored
      */
     setPartnerStorageDestinationRaw(requestParameters, initOverrides) {
@@ -528,7 +528,7 @@ class PartnersApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required for the files your customers upload. An editor session with the `files` surface (`createManagedUserEditorSession`) keeps its user\'s uploads in this destination and nowhere else, so it cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), and a destination removed later stops the uploads of the sessions already made (the same 409). Your own uploads, with your API key, do not need one.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
+     * Points the partner at a bucket of its own on an S3-compatible service (Amazon S3, Backblaze B2, Cloudflare R2, Wasabi, MinIO and the like). From then on, a file uploaded with `uploadsPost` by the account that administers the partner is stored in that bucket instead of with Widgetic. It takes none of the account\'s storage allowance, and its `url` is served from `public_base_url`.  Only uploads sent with an API key, an SDK token or an editor session use the destination. Uploads from the Widgetic website, resumable uploads and the media library keep using Widgetic\'s storage.  A destination is required. Partner storage is not optional: your customers\' files, and your own uploads with your API key, are kept in this destination and nowhere else. An editor session (`createManagedUserEditorSession`) of any surface cannot be made until a destination is set (409 `PARTNER_STORAGE_REQUIRED`), a destination removed later stops the uploads of the sessions already made (the same 409), and your own upload with no destination is refused in the same way instead of being stored with Widgetic. A partner cannot be activated until it has a destination that works.  The destination is checked before it is saved. Widgetic writes a small test file under `<key_prefix>widgetic-check/`, reads it back from `<public_base_url>/<its key>`, and deletes it. If any step fails nothing is saved and the answer is 422 `STORAGE_DESTINATION_UNVERIFIED`: `details.step` says where (`endpoint`, `write` or `public_read`), `details.reason` says why, and `param` names the field most likely to be wrong.  What the bucket needs: - an access key that may put objects into it (it may also delete objects, which lets the test file be   cleaned up, but that is not required); - its files publicly readable at `public_base_url`, either because the bucket is public or through a CDN.  The secret access key is stored encrypted and is never returned or logged; a response shows only the last four characters of the access key id (`accessKeyHint`). Saving replaces the whole destination, so send every field again, including the secret. Files already stored stay where they are, and keep working for as long as that bucket stays publicly readable.  Once a destination is set, an upload is never stored with Widgetic instead: when the destination cannot be used the upload is refused with 503 `STORAGE_DESTINATION_UNAVAILABLE`, and when the bucket rejects the file with 502 `STORAGE_DESTINATION_WRITE_FAILED`.  The caller must be the person who administers the partner (an API key of that account works); anyone else is refused with 403 whether or not the partner exists. Widgetic administrators can set any partner\'s.
      * Set where a partner\'s uploaded files are stored
      */
     setPartnerStorageDestination(requestParameters, initOverrides) {

package/dist/apis/UIComponentsApi.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Widgetic API Gateway
+ * API documentation for the Widgetic API Gateway
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import type { ComponentManifest, ListComponents200Response, MountRequest, MountResponse } from '../models/index';
+export interface GetComponentManifestRequest {
+    componentId: GetComponentManifestComponentIdEnum;
+}
+export interface MountComponentRequest {
+    componentId: MountComponentComponentIdEnum;
+    mountRequest: MountRequest;
+}
+export interface UnmountComponentRequest {
+    componentId: UnmountComponentComponentIdEnum;
+    instanceId: string;
+}
+/**
+ *
+ */
+export declare class UIComponentsApi extends runtime.BaseAPI {
+    /**
+     * Get component manifest with configuration and dependencies
+     * Get Component Manifest
+     */
+    getComponentManifestRaw(requestParameters: GetComponentManifestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ComponentManifest>>;
+    /**
+     * Get component manifest with configuration and dependencies
+     * Get Component Manifest
+     */
+    getComponentManifest(requestParameters: GetComponentManifestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ComponentManifest>;
+    /**
+     * List available UI components for partner
+     * List UI Components
+     */
+    listComponentsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListComponents200Response>>;
+    /**
+     * List available UI components for partner
+     * List UI Components
+     */
+    listComponents(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListComponents200Response>;
+    /**
+     * Initialize and mount a UI component
+     * Mount Component
+     */
+    mountComponentRaw(requestParameters: MountComponentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MountResponse>>;
+    /**
+     * Initialize and mount a UI component
+     * Mount Component
+     */
+    mountComponent(requestParameters: MountComponentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MountResponse>;
+    /**
+     * Cleanup and unmount a UI component instance
+     * Unmount Component
+     */
+    unmountComponentRaw(requestParameters: UnmountComponentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Cleanup and unmount a UI component instance
+     * Unmount Component
+     */
+    unmountComponent(requestParameters: UnmountComponentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+}
+/**
+ * @export
+ */
+export declare const GetComponentManifestComponentIdEnum: {
+    readonly WidgetCreator: "widget-creator";
+    readonly CompositionEditor: "composition-editor";
+    readonly EmbedEditor: "embed-editor";
+};
+export type GetComponentManifestComponentIdEnum = typeof GetComponentManifestComponentIdEnum[keyof typeof GetComponentManifestComponentIdEnum];
+/**
+ * @export
+ */
+export declare const MountComponentComponentIdEnum: {
+    readonly WidgetCreator: "widget-creator";
+    readonly CompositionEditor: "composition-editor";
+    readonly EmbedEditor: "embed-editor";
+};
+export type MountComponentComponentIdEnum = typeof MountComponentComponentIdEnum[keyof typeof MountComponentComponentIdEnum];
+/**
+ * @export
+ */
+export declare const UnmountComponentComponentIdEnum: {
+    readonly WidgetCreator: "widget-creator";
+    readonly CompositionEditor: "composition-editor";
+    readonly EmbedEditor: "embed-editor";
+};
+export type UnmountComponentComponentIdEnum = typeof UnmountComponentComponentIdEnum[keyof typeof UnmountComponentComponentIdEnum];

package/dist/apis/UIComponentsApi.js

@@ -0,0 +1,209 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Widgetic API Gateway
+ * API documentation for the Widgetic API Gateway
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnmountComponentComponentIdEnum = exports.MountComponentComponentIdEnum = exports.GetComponentManifestComponentIdEnum = exports.UIComponentsApi = void 0;
+const runtime = require("../runtime");
+const index_1 = require("../models/index");
+/**
+ *
+ */
+class UIComponentsApi extends runtime.BaseAPI {
+    /**
+     * Get component manifest with configuration and dependencies
+     * Get Component Manifest
+     */
+    getComponentManifestRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['componentId'] == null) {
+                throw new runtime.RequiredError('componentId', 'Required parameter "componentId" was null or undefined when calling getComponentManifest().');
+            }
+            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: `/ui/components/{componentId}/manifest`.replace(`{${"componentId"}}`, encodeURIComponent(String(requestParameters['componentId']))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ComponentManifestFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Get component manifest with configuration and dependencies
+     * Get Component Manifest
+     */
+    getComponentManifest(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getComponentManifestRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * List available UI components for partner
+     * List UI Components
+     */
+    listComponentsRaw(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: `/ui/components`,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.ListComponents200ResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * List available UI components for partner
+     * List UI Components
+     */
+    listComponents(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.listComponentsRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Initialize and mount a UI component
+     * Mount Component
+     */
+    mountComponentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['componentId'] == null) {
+                throw new runtime.RequiredError('componentId', 'Required parameter "componentId" was null or undefined when calling mountComponent().');
+            }
+            if (requestParameters['mountRequest'] == null) {
+                throw new runtime.RequiredError('mountRequest', 'Required parameter "mountRequest" was null or undefined when calling mountComponent().');
+            }
+            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: `/ui/components/{componentId}/mount`.replace(`{${"componentId"}}`, encodeURIComponent(String(requestParameters['componentId']))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, index_1.MountRequestToJSON)(requestParameters['mountRequest']),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.MountResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Initialize and mount a UI component
+     * Mount Component
+     */
+    mountComponent(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.mountComponentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Cleanup and unmount a UI component instance
+     * Unmount Component
+     */
+    unmountComponentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['componentId'] == null) {
+                throw new runtime.RequiredError('componentId', 'Required parameter "componentId" was null or undefined when calling unmountComponent().');
+            }
+            if (requestParameters['instanceId'] == null) {
+                throw new runtime.RequiredError('instanceId', 'Required parameter "instanceId" was null or undefined when calling unmountComponent().');
+            }
+            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: `/ui/components/{componentId}/{instanceId}`.replace(`{${"componentId"}}`, encodeURIComponent(String(requestParameters['componentId']))).replace(`{${"instanceId"}}`, encodeURIComponent(String(requestParameters['instanceId']))),
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Cleanup and unmount a UI component instance
+     * Unmount Component
+     */
+    unmountComponent(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.unmountComponentRaw(requestParameters, initOverrides);
+        });
+    }
+}
+exports.UIComponentsApi = UIComponentsApi;
+/**
+ * @export
+ */
+exports.GetComponentManifestComponentIdEnum = {
+    WidgetCreator: 'widget-creator',
+    CompositionEditor: 'composition-editor',
+    EmbedEditor: 'embed-editor'
+};
+/**
+ * @export
+ */
+exports.MountComponentComponentIdEnum = {
+    WidgetCreator: 'widget-creator',
+    CompositionEditor: 'composition-editor',
+    EmbedEditor: 'embed-editor'
+};
+/**
+ * @export
+ */
+exports.UnmountComponentComponentIdEnum = {
+    WidgetCreator: 'widget-creator',
+    CompositionEditor: 'composition-editor',
+    EmbedEditor: 'embed-editor'
+};

package/dist/apis/UploadsApi.d.ts

@@ -64,12 +64,12 @@ export declare class UploadsApi extends runtime.BaseAPI {
      */
     uploadsLimitsGet(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UploadLimits>;
     /**
-     * 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`.  A partner\'s own uploads (with its API key) go to Widgetic\'s storage while it has no destination. The uploads of an editor session never do: they 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`. The message only says that it is not available right now.
+     * 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<Upload>>;
     /**
-     * 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`.  A partner\'s own uploads (with its API key) go to Widgetic\'s storage while it has no destination. The uploads of an editor session never do: they 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`. The message only says that it is not available right now.
+     * 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<Upload>;

package/dist/apis/UploadsApi.js

@@ -144,7 +144,7 @@ class UploadsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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`.  A partner\'s own uploads (with its API key) go to Widgetic\'s storage while it has no destination. The uploads of an editor session never do: they 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`. The message only says that it is not available right now.
+     * 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) {
@@ -202,7 +202,7 @@ class UploadsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * 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`.  A partner\'s own uploads (with its API key) go to Widgetic\'s storage while it has no destination. The uploads of an editor session never do: they 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`. The message only says that it is not available right now.
+     * 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) {

package/dist/apis/WorkflowsApi.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Widgetic API Gateway
+ * API documentation for the Widgetic API Gateway
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import type { GenerateComponentWorkflowInput, GenerateMixedComponentInput, WorkflowAcceptedResponse } from '../models/index';
+export interface WorkflowsGenerateComponentFromMixPostRequest {
+    generateMixedComponentInput: GenerateMixedComponentInput;
+}
+export interface WorkflowsGenerateComponentPostRequest {
+    generateComponentWorkflowInput: GenerateComponentWorkflowInput;
+}
+/**
+ *
+ */
+export declare class WorkflowsApi extends runtime.BaseAPI {
+    /**
+     * Initiates an asynchronous workflow to create a new component based on instructions applied to one or more source components.
+     * Generate a New Component by Mixing Existing Ones
+     */
+    workflowsGenerateComponentFromMixPostRaw(requestParameters: WorkflowsGenerateComponentFromMixPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowAcceptedResponse>>;
+    /**
+     * Initiates an asynchronous workflow to create a new component based on instructions applied to one or more source components.
+     * Generate a New Component by Mixing Existing Ones
+     */
+    workflowsGenerateComponentFromMixPost(requestParameters: WorkflowsGenerateComponentFromMixPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowAcceptedResponse>;
+    /**
+     * Retired workflow route. Live codegen is POST /agent/code/generate (Direct LLM).
+     * Initiate initial component generation workflow
+     */
+    workflowsGenerateComponentPostRaw(requestParameters: WorkflowsGenerateComponentPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowAcceptedResponse>>;
+    /**
+     * Retired workflow route. Live codegen is POST /agent/code/generate (Direct LLM).
+     * Initiate initial component generation workflow
+     */
+    workflowsGenerateComponentPost(requestParameters: WorkflowsGenerateComponentPostRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowAcceptedResponse>;
+}