sequenzy 2.0.0 → 2.1.4

package/dist/esm/api/resources/conversations/client/Client.js

@@ -13,7 +13,243 @@ export class ConversationsClient {
         this._options = normalizeClientOptionsWithAuth(options);
     }
     /**
-     * Returns one conversation with all messages, originating campaign or sequence context, and subscriber details.
+     * Moves up to 100 conversations into the Spam folder (spam true) or back to the inbox (spam false). Only conversations that move are updated, so retries are safe. IDs that do not exist in the company are reported in `notFoundIds` and do not fail the request.
+     *
+     * @param {Sequenzy.BulkUpdateSpamConversationsRequest} request
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.bulkUpdateSpam({
+     *         conversationIds: ["conversationIds"],
+     *         spam: true
+     *     })
+     */
+    bulkUpdateSpam(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__bulkUpdateSpam(request, requestOptions));
+    }
+    async __bulkUpdateSpam(request, requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, "conversations/bulk/spam"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.BulkUpdateSpamConversationsRequest.jsonOrThrow(request, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }), requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.BulkUpdateSpamConversationsResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Sequenzy.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new Sequenzy.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Sequenzy.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/bulk/spam");
+    }
+    /**
+     * Opens or closes up to 100 conversations in one request. Only conversations whose status changes are updated, so retries are safe. IDs that do not exist in the company are reported in `notFoundIds` and do not fail the request.
+     *
+     * @param {Sequenzy.BulkUpdateStatusConversationsRequest} request
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.bulkUpdateStatus({
+     *         conversationIds: ["conversationIds"],
+     *         status: "open"
+     *     })
+     */
+    bulkUpdateStatus(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__bulkUpdateStatus(request, requestOptions));
+    }
+    async __bulkUpdateStatus(request, requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, "conversations/bulk/status"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.BulkUpdateStatusConversationsRequest.jsonOrThrow(request, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }), requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.BulkUpdateStatusConversationsResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Sequenzy.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new Sequenzy.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/bulk/status");
+    }
+    /**
+     * Emails a copy of one received or sent message, with its stored attachments up to 15 MB in total (files left out are listed in the forwarded email), to another address. The forward is recorded in the conversation as a system message whose deliveryStatus moves from pending to sent or failed. It does not change the conversation's status, unread state, or last activity. Notes cannot be forwarded.
+     *
+     * @param {Sequenzy.ForwardMessageConversationsRequest} request
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.forwardMessage({
+     *         conversationId: "conversationId",
+     *         messageId: "messageId",
+     *         to: "to"
+     *     })
+     */
+    forwardMessage(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__forwardMessage(request, requestOptions));
+    }
+    async __forwardMessage(request, requestOptions) {
+        const { conversationId, messageId, ..._body } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, `conversations/${core.url.encodePathParam(conversationId)}/messages/${core.url.encodePathParam(messageId)}/forward`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.ForwardMessageConversationsRequest.jsonOrThrow(_body, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }), requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.ForwardMessageConversationsResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Sequenzy.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new Sequenzy.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/{conversationId}/messages/{messageId}/forward");
+    }
+    /**
+     * Returns one conversation with all messages, originating campaign or sequence context, and subscriber details. Stored attachments include a signed downloadUrl valid for one hour.
      *
      * @param {Sequenzy.GetConversationsRequest} request
      * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -80,7 +316,67 @@ export class ConversationsClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/conversations/{conversationId}");
     }
     /**
-     * Lists inbox conversations with subscriber replies, filtered by status, unread flag, or search term.
+     * Returns the address anyone can email to reach this company's inbox, the same inbox+ address on each verified receiving domain, whether receiving is on, whether attachments are stored, and how long received email is kept. Every other address on a receiving domain reaches the inbox too.
+     *
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.getInboxAddress()
+     */
+    getInboxAddress(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getInboxAddress(requestOptions));
+    }
+    async __getInboxAddress(requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, "conversations/inbox-address"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.GetInboxAddressResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/conversations/inbox-address");
+    }
+    /**
+     * Lists inbox conversations: replies to your campaigns, sequences, and transactional email, plus email sent to your inbox address. Filter by status, unread flag, search term, inbox address, or the Spam folder. Conversations in the Spam folder are only listed with spam=true.
      *
      * @param {Sequenzy.ListConversationsRequest} request
      * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -98,11 +394,18 @@ export class ConversationsClient {
         return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
     }
     async __list(request = {}, requestOptions) {
-        const { limit, page, search, status, unread } = request;
+        const { limit, page, recipient, search, spam, status, unread } = request;
         const _queryParams = {
             limit,
             page,
+            recipient,
             search,
+            spam: spam != null
+                ? serializers.ListConversationsRequestSpam.jsonOrThrow(spam, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
             status: status != null
                 ? serializers.ListConversationsRequestStatus.jsonOrThrow(status, {
                     unrecognizedObjectKeys: "strip",
@@ -165,6 +468,66 @@ export class ConversationsClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/conversations");
     }
+    /**
+     * Lists the inbox addresses conversations started at, such as admin@acme.com and team@acme.com, most recently used first (up to 100). Addresses that only received spam are left out. Use one as the recipient filter of List conversations.
+     *
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.listRecipients()
+     */
+    listRecipients(requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listRecipients(requestOptions));
+    }
+    async __listRecipients(requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, "conversations/recipients"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.ListRecipientsConversationsResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Sequenzy.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/conversations/recipients");
+    }
     /**
      * Marks all unread inbound messages in a conversation as read and clears the unread flag.
      *
@@ -229,6 +592,73 @@ export class ConversationsClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/{conversationId}/read");
     }
+    /**
+     * Sets the conversation's unread flag and marks its latest received message unread.
+     *
+     * @param {Sequenzy.MarkUnreadConversationsRequest} request
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.markUnread({
+     *         conversationId: "conversationId"
+     *     })
+     */
+    markUnread(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__markUnread(request, requestOptions));
+    }
+    async __markUnread(request, requestOptions) {
+        const { conversationId } = request;
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, `conversations/${core.url.encodePathParam(conversationId)}/unread`),
+            method: "POST",
+            headers: _headers,
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.MarkUnreadConversationsResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/{conversationId}/unread");
+    }
     /**
      * Sends an email reply to the subscriber or adds an internal note. Replies reopen closed conversations.
      *
@@ -239,6 +669,7 @@ export class ConversationsClient {
      * @throws {@link Sequenzy.UnauthorizedError}
      * @throws {@link Sequenzy.NotFoundError}
      * @throws {@link Sequenzy.InternalServerError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
@@ -295,6 +726,8 @@ export class ConversationsClient {
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 case 500:
                     throw new Sequenzy.InternalServerError(_response.error.body, _response.rawResponse);
+                case 503:
+                    throw new Sequenzy.ServiceUnavailableError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.SequenzyError({
                         statusCode: _response.error.statusCode,
@@ -305,6 +738,85 @@ export class ConversationsClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/conversations/{conversationId}/messages");
     }
+    /**
+     * Sets a branded inbox address `{localPart}@{domain}` on one of your receiving domains, or clears it when both fields are null. The address is active once the receiving domain is verified; the default address keeps working. Every other address on the domain reaches the inbox too; the branded one is the address to share. Returns the same body as Get Inbox Address.
+     *
+     * @param {Sequenzy.UpdateInboxAddressRequest} request
+     * @param {ConversationsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ConflictError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.conversations.updateInboxAddress({})
+     */
+    updateInboxAddress(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__updateInboxAddress(request, requestOptions));
+    }
+    async __updateInboxAddress(request, requestOptions) {
+        const _authRequest = await this._options.authProvider.getAuthRequest();
+        const _headers = mergeHeaders(_authRequest.headers, this._options?.headers, requestOptions?.headers);
+        const _response = await core.fetcher({
+            url: core.url.join((await core.Supplier.get(this._options.baseUrl)) ??
+                (await core.Supplier.get(this._options.environment)) ??
+                environments.SequenzyEnvironment.Default, "conversations/inbox-address"),
+            method: "PUT",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.UpdateInboxAddressRequest.jsonOrThrow(request, {
+                unrecognizedObjectKeys: "strip",
+                omitUndefined: true,
+            }), requestOptions?.additionalBodyParameters),
+            timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000,
+            maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries,
+            abortSignal: requestOptions?.abortSignal,
+            fetchFn: this._options?.fetch,
+            logging: this._options.logging,
+        });
+        if (_response.ok) {
+            return {
+                data: serializers.UpdateInboxAddressResponse.parseOrThrow(_response.body, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    breadcrumbsPrefix: ["response"],
+                }),
+                rawResponse: _response.rawResponse,
+            };
+        }
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 400:
+                    throw new Sequenzy.BadRequestError(_response.error.body, _response.rawResponse);
+                case 401:
+                    throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
+                case 403:
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 404:
+                    throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
+                case 409:
+                    throw new Sequenzy.ConflictError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new Sequenzy.UnprocessableEntityError(_response.error.body, _response.rawResponse);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/conversations/inbox-address");
+    }
     /**
      * Opens or closes a conversation.
      *

package/dist/esm/api/resources/conversations/client/requests/BulkUpdateSpamConversationsRequest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @example
+ *     {
+ *         conversationIds: ["conversationIds"],
+ *         spam: true
+ *     }
+ */
+export interface BulkUpdateSpamConversationsRequest {
+    /** Conversation IDs to move, up to 100. Whitespace is trimmed and blank or repeated IDs are ignored; at least one non-blank ID is required. */
+    conversationIds: string[];
+    /** True moves them to Spam; false moves them back. */
+    spam: boolean;
+}

package/dist/esm/api/resources/conversations/client/requests/BulkUpdateSpamConversationsRequest.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/esm/api/resources/conversations/client/requests/BulkUpdateStatusConversationsRequest.d.ts

@@ -0,0 +1,14 @@
+import type * as Sequenzy from "../../../../index.js";
+/**
+ * @example
+ *     {
+ *         conversationIds: ["conversationIds"],
+ *         status: "open"
+ *     }
+ */
+export interface BulkUpdateStatusConversationsRequest {
+    /** Conversation IDs to update, up to 100. Whitespace is trimmed and blank or repeated IDs are ignored; at least one non-blank ID is required. */
+    conversationIds: string[];
+    /** New status for every listed conversation. */
+    status: Sequenzy.BulkUpdateStatusConversationsRequestStatus;
+}

package/dist/esm/api/resources/conversations/client/requests/BulkUpdateStatusConversationsRequest.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/esm/api/resources/conversations/client/requests/ForwardMessageConversationsRequest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @example
+ *     {
+ *         conversationId: "conversationId",
+ *         messageId: "messageId",
+ *         to: "to"
+ *     }
+ */
+export interface ForwardMessageConversationsRequest {
+    /** Conversation ID. */
+    conversationId: string;
+    /** ID of the message to forward. */
+    messageId: string;
+    /** Sender profile to forward from. Its sending domain must be verified. When omitted, the company default sender is used. */
+    senderProfileId?: string;
+    /** One email address to forward the message to. */
+    to: string;
+}

package/dist/esm/api/resources/conversations/client/requests/ForwardMessageConversationsRequest.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};

package/dist/esm/api/resources/conversations/client/requests/ListConversationsRequest.d.ts

@@ -8,8 +8,12 @@ export interface ListConversationsRequest {
     limit?: number;
     /** Page number. */
     page?: number;
+    /** Only conversations that started at this inbox address. Case does not matter. See List conversation recipients. */
+    recipient?: string;
     /** Search in subject, subscriber email, or subscriber name. */
     search?: string;
+    /** Pass "true" to list the Spam folder instead. Other lists leave spam out. */
+    spam?: Sequenzy.ListConversationsRequestSpam;
     /** Filter by conversation status. */
     status?: Sequenzy.ListConversationsRequestStatus;
     /** Pass "true" to only return conversations with unread messages. */

package/dist/esm/api/resources/conversations/client/requests/MarkUnreadConversationsRequest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @example
+ *     {
+ *         conversationId: "conversationId"
+ *     }
+ */
+export interface MarkUnreadConversationsRequest {
+    /** Conversation ID. */
+    conversationId: string;
+}

package/dist/esm/api/resources/conversations/client/requests/MarkUnreadConversationsRequest.js

@@ -0,0 +1,2 @@
+// This file was auto-generated by Fern from our API Definition.
+export {};