sequenzy 2.0.0 → 2.1.4

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

@@ -73,6 +73,74 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/archive");
     }
+    /**
+     * Cancels a queued run immediately or asks a running run to stop after the batch it is currently enrolling. Contacts already enrolled stay in the sequence.
+     *
+     * @param {Sequenzy.CancelAudienceEnrollmentSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.cancelAudienceEnrollment({
+     *         runId: "runId",
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    cancelAudienceEnrollment(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__cancelAudienceEnrollment(request, requestOptions));
+    }
+    async __cancelAudienceEnrollment(request, requestOptions) {
+        const { sequenceId, runId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/audience-enrollments/${core.url.encodePathParam(runId)}/cancel`),
+            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.CancelAudienceEnrollmentSequencesResponse.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 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", "/sequences/{sequenceId}/audience-enrollments/{runId}/cancel");
+    }
     /**
      * Cancels active or waiting enrollments in one sequence. Target every enrollment with cancelAll, a batch with subscriberIds, one contact with subscriberId, or matching stored entry event property values with fieldValues. Bulk cancellation is capped at 1000 enrollments per request; repeat the request while remainingCount is above zero.
      *
@@ -162,13 +230,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -181,6 +243,90 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enrollments/cancel");
     }
+    /**
+     * Run the pre-send email check on a saved sequence email step: the same rules as the editor's email checker, plus live verification of every link and image, including links in every A/B variant and translation unless variantId or locale pins one version. Read-only: this never sends or modifies anything, and uses POST only so personalization input can travel in a request body.
+     *
+     * @param {Sequenzy.CheckStepSequencesRequest} request
+     * @param {SequencesClient.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 Sequenzy.TooManyRequestsError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.checkStep({
+     *         nodeId: "nodeId",
+     *         sequenceId: "sequenceId",
+     *         body: {}
+     *     })
+     */
+    checkStep(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__checkStep(request, requestOptions));
+    }
+    async __checkStep(request, requestOptions) {
+        const { sequenceId, nodeId, body: _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, `sequences/${core.url.encodePathParam(sequenceId)}/nodes/${core.url.encodePathParam(nodeId)}/check`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.CheckEmailRequest.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.CheckEmailResponse.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);
+                case 429:
+                    throw new Sequenzy.TooManyRequestsError(_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", "/sequences/{sequenceId}/nodes/{nodeId}/check");
+    }
     /**
      * Creates or updates the endpoint attached to an inbound_webhook trigger. On first setup, omitted fields use catalog/custom integration defaults; on later calls, omitted fields keep their saved values. Use null to clear a saved mapping or sample.
      *
@@ -255,7 +401,7 @@ export class SequencesClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/sequences/{sequenceId}/inbound-webhook");
     }
     /**
-     * Creates a draft automation sequence using AI-generated content, explicit email/action steps, or a blank trigger-to-completion graph when both are omitted. Discount action steps dynamically generate Stripe or Shopify codes that later emails can reference with discount merge tags.
+     * Creates a draft automation sequence using AI-generated content, explicit email/action steps, or a blank trigger-to-completion graph when both are omitted. Discount action steps dynamically generate Stripe or Shopify codes that later emails can reference with discount merge tags. Marketer account keys must choose existing sender and Reply-To profiles; requests requiring new profiles return 400 before creating profiles, labels, or campaign/sequence changes, including nested steps and branches.
      *
      * @param {Sequenzy.SequenceCreateRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -263,6 +409,7 @@ export class SequencesClient {
      * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.UnauthorizedError}
      * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
      * @throws {@link Sequenzy.InternalServerError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
@@ -416,13 +563,9 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
+                case 422:
+                    throw new Sequenzy.UnprocessableEntityError(_response.error.body, _response.rawResponse);
                 case 500:
                     throw new Sequenzy.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
@@ -435,6 +578,85 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences");
     }
+    /**
+     * Clones a public sequence from the Sequenzy email gallery into a draft sequence for your company. The draft keeps the example's trigger family and send timing, up to 12 emails (the first 12 unless `stepNumbers` picks which), and AI then writes every email in your brand in the background (usually 30 to 60 seconds). Poll [Get Sequence](/api-reference/sequences/get) until `enrichmentStatus` is `complete`. The sequence sends nothing until you enable it. Every successful call creates another sequence, so do not retry after a success. Requires `sequences:write`.
+     *
+     * @param {Sequenzy.CreateFromExampleSequencesRequest} request
+     * @param {SequencesClient.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 Sequenzy.InternalServerError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.createFromExample()
+     */
+    createFromExample(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__createFromExample(request, requestOptions));
+    }
+    async __createFromExample(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, "sequences/from-example"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.CreateFromExampleSequencesRequest.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.CreateFromExampleSequencesResponse.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);
+                case 500:
+                    throw new Sequenzy.InternalServerError(_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", "/sequences/from-example");
+    }
     /**
      * Creates a conversion goal for an event, subscriber attribute change, or applied tag.
      *
@@ -443,6 +665,7 @@ export class SequencesClient {
      *
      * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ConflictError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
@@ -495,6 +718,8 @@ export class SequencesClient {
                     throw new Sequenzy.BadRequestError(_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);
                 default:
                     throw new errors.SequenzyError({
                         statusCode: _response.error.statusCode,
@@ -560,13 +785,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 case 503:
@@ -700,13 +919,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -720,41 +933,39 @@ export class SequencesClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/disable");
     }
     /**
-     * Creates an independent draft copy of the sequence graph, email templates, and sequence A/B tests.
+     * Discards a variation. It is no longer listed; the email does not change.
      *
-     * @param {Sequenzy.DuplicateSequencesRequest} request
+     * @param {Sequenzy.DiscardEmailVariationSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
      * @throws {@link Sequenzy.NotFoundError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.duplicate({
-     *         sequenceId: "sequenceId"
+     *     await client.sequences.discardEmailVariation({
+     *         emailId: "emailId",
+     *         sequenceId: "sequenceId",
+     *         variationId: "variationId"
      *     })
      */
-    duplicate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__duplicate(request, requestOptions));
+    discardEmailVariation(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__discardEmailVariation(request, requestOptions));
     }
-    async __duplicate(request, requestOptions) {
-        const { sequenceId, ..._body } = request;
+    async __discardEmailVariation(request, requestOptions) {
+        const { sequenceId, emailId, variationId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/duplicate`),
-            method: "POST",
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/emails/${core.url.encodePathParam(emailId)}/variations/${core.url.encodePathParam(variationId)}`),
+            method: "DELETE",
             headers: _headers,
-            contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
-            requestType: "json",
-            body: mergeAdditionalBodyParameters(serializers.DuplicateSequencesRequest.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,
@@ -763,7 +974,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.DuplicateSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.DiscardEmailVariationSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -777,6 +988,10 @@ export class SequencesClient {
             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);
                 default:
@@ -787,40 +1002,44 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/duplicate");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/sequences/{sequenceId}/emails/{emailId}/variations/{variationId}");
     }
     /**
-     * Activates a sequence and opens it for new enrollments. Activation enforces the same readiness checks returned by simulateSequence; invalid triggers, incomplete steps, disconnected graphs, and archived sequences are rejected without changing status. If it was paused, held subscribers continue from their current step and due waits are queued gradually.
+     * Creates an independent draft copy of the sequence graph, email templates, and sequence A/B tests.
      *
-     * @param {Sequenzy.EnableSequencesRequest} request
+     * @param {Sequenzy.DuplicateSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Sequenzy.BadRequestError}
-     * @throws {@link Sequenzy.UnauthorizedError}
-     * @throws {@link Sequenzy.ForbiddenError}
      * @throws {@link Sequenzy.NotFoundError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.enable({
+     *     await client.sequences.duplicate({
      *         sequenceId: "sequenceId"
      *     })
      */
-    enable(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__enable(request, requestOptions));
+    duplicate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__duplicate(request, requestOptions));
     }
-    async __enable(request, requestOptions) {
-        const { sequenceId } = request;
+    async __duplicate(request, requestOptions) {
+        const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/enable`),
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/duplicate`),
             method: "POST",
             headers: _headers,
+            contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.DuplicateSequencesRequest.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,
@@ -829,7 +1048,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SequenceActionResponse.parseOrThrow(_response.body, {
+                data: serializers.DuplicateSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -843,16 +1062,6 @@ export class SequencesClient {
             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(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -863,42 +1072,47 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enable");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/duplicate");
     }
     /**
-     * Manually enrolls active subscribers into a sequence by email or subscriber ID, starting at the first step or a specific node.
+     * Changes a sequence's emails with AI in one request, like the Emails view in the sequence editor. The prompt says what to change, in any language. Without emailIds the prompt decides which emails change, every email unless it names some. A look change is made identical across the emails it restyles, down to each kind of block's style. A prompt asking to make emails look like one of them copies that email's style exactly, without AI. A request for design variations ("make a few variations of email 1") returns 400; use Generate Sequence Email Variations instead. Each email succeeds or fails on its own; changed emails are saved unless dryRun is true. An email written in HTML is edited as HTML. A/B test steps and steps without an email are skipped. Runs synchronously; one request edits up to 12 emails. An email saved elsewhere while the AI worked is not overwritten (saved false with an error).
      *
-     * @param {Sequenzy.EnrollSubscribersInSequencesRequest} request
+     * @param {Sequenzy.EditEmailsSequencesRequest} request
      * @param {SequencesClient.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 Sequenzy.InternalServerError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.enrollSubscribersIn({
-     *         sequenceId: "sequenceId"
+     *     await client.sequences.editEmails({
+     *         sequenceId: "sequenceId",
+     *         prompt: "Make the background cream and remove the header"
      *     })
      */
-    enrollSubscribersIn(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__enrollSubscribersIn(request, requestOptions));
+    editEmails(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__editEmails(request, requestOptions));
     }
-    async __enrollSubscribersIn(request, requestOptions) {
+    async __editEmails(request, requestOptions) {
         const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/enroll`),
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/emails/edit`),
             method: "POST",
             headers: _headers,
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: mergeAdditionalBodyParameters(serializers.EnrollSubscribersInSequencesRequest.jsonOrThrow(_body, {
+            body: mergeAdditionalBodyParameters(serializers.EditEmailsSequencesRequest.jsonOrThrow(_body, {
                 unrecognizedObjectKeys: "strip",
                 omitUndefined: true,
             }), requestOptions?.additionalBodyParameters),
@@ -910,7 +1124,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.EnrollSubscribersInSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.EditEmailsSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -926,8 +1140,16 @@ export class SequencesClient {
                     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);
+                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,
@@ -936,44 +1158,116 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enroll");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/emails/edit");
     }
     /**
-     * @deprecated
-     *
-     * Deprecated compatibility alias that creates and persists a disabled contact_added sequence draft from a goal. Use POST /sequences for new integrations.
+     * Activates a sequence and opens it for new enrollments. Activation enforces the same readiness checks returned by simulateSequence; invalid triggers, incomplete steps, disconnected graphs, and archived sequences are rejected without changing status. If it was paused, held subscribers continue from their current step and due waits are queued gradually.
      *
-     * @param {Sequenzy.GenerateSequencesRequest} request
+     * @param {Sequenzy.EnableSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.UnauthorizedError}
      * @throws {@link Sequenzy.ForbiddenError}
-     * @throws {@link Sequenzy.InternalServerError}
+     * @throws {@link Sequenzy.NotFoundError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.generate({
-     *         goal: "Onboard a new workspace admin"
+     *     await client.sequences.enable({
+     *         sequenceId: "sequenceId"
      *     })
      */
-    generate(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__generate(request, requestOptions));
+    enable(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__enable(request, requestOptions));
     }
-    async __generate(request, requestOptions) {
+    async __enable(request, requestOptions) {
+        const { sequenceId } = 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, "generate/sequence"),
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/enable`),
+            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.SequenceActionResponse.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);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enable");
+    }
+    /**
+     * Starts a background run that enrolls every active contact matching the audience (everyone, lists, a segment, a filter, or rules) into the sequence, in batches, with no per-request cap. Contacts already active or waiting in the sequence are skipped; one_time sequences also skip contacts who completed or were cancelled before; unsubscribed and bounced contacts are never enrolled. Only one run per sequence can be queued or running at a time. The sequence must be enabled and accepting entrants. This is how a manual-trigger countdown sequence gets its audience; late enrollees skip the steps whose key date already passed.
+     *
+     * @param {Sequenzy.EnrollAudienceSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ConflictError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.enrollAudience({
+     *         sequenceId: "sequenceId",
+     *         audience: {
+     *             type: "all"
+     *         }
+     *     })
+     */
+    enrollAudience(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__enrollAudience(request, requestOptions));
+    }
+    async __enrollAudience(request, requestOptions) {
+        const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/enroll-audience`),
             method: "POST",
             headers: _headers,
             contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
             requestType: "json",
-            body: mergeAdditionalBodyParameters(serializers.GenerateSequencesRequest.jsonOrThrow(request, {
+            body: mergeAdditionalBodyParameters(serializers.EnrollAudienceSequencesRequest.jsonOrThrow(_body, {
                 unrecognizedObjectKeys: "strip",
                 omitUndefined: true,
             }), requestOptions?.additionalBodyParameters),
@@ -985,7 +1279,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.GenerateSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.EnrollAudienceSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1001,16 +1295,10 @@ export class SequencesClient {
                     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(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
-                case 500:
-                    throw new Sequenzy.InternalServerError(_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);
                 default:
                     throw new errors.SequenzyError({
                         statusCode: _response.error.statusCode,
@@ -1019,40 +1307,45 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/generate/sequence");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enroll-audience");
     }
     /**
-     * Returns sequence metadata, nodes, and editable email steps.
+     * Manually enrolls active subscribers into a sequence by email or subscriber ID, starting at the first step or a specific node.
      *
-     * @param {Sequenzy.GetSequencesRequest} request
+     * @param {Sequenzy.EnrollSubscribersInSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.UnauthorizedError}
-     * @throws {@link Sequenzy.ForbiddenError}
      * @throws {@link Sequenzy.NotFoundError}
-     * @throws {@link Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.get({
+     *     await client.sequences.enrollSubscribersIn({
      *         sequenceId: "sequenceId"
      *     })
      */
-    get(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__get(request, requestOptions));
+    enrollSubscribersIn(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__enrollSubscribersIn(request, requestOptions));
     }
-    async __get(request, requestOptions) {
-        const { sequenceId } = request;
+    async __enrollSubscribersIn(request, requestOptions) {
+        const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}`),
-            method: "GET",
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/enroll`),
+            method: "POST",
             headers: _headers,
+            contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.EnrollSubscribersInSequencesRequest.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,
@@ -1061,7 +1354,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.GetSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.EnrollSubscribersInSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1073,20 +1366,12 @@ export class SequencesClient {
         }
         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(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_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,
@@ -1095,41 +1380,48 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enroll");
     }
     /**
-     * Returns the state of an applied realignment job. When status is completed, result contains the bounded realignment result and any continuation cursor.
+     * Counts the contacts matching an audience and how many of them would be enrolled. Contacts already in the sequence are skipped; one_time sequences also skip contacts who completed or were cancelled before. Nothing is changed.
      *
-     * @param {Sequenzy.GetEnrollmentRealignmentSequencesRequest} request
+     * @param {Sequenzy.EstimateAudienceEnrollmentSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.UnauthorizedError}
-     * @throws {@link Sequenzy.ForbiddenError}
      * @throws {@link Sequenzy.NotFoundError}
-     * @throws {@link Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.getEnrollmentRealignment({
-     *         jobId: "jobId",
-     *         sequenceId: "sequenceId"
+     *     await client.sequences.estimateAudienceEnrollment({
+     *         sequenceId: "sequenceId",
+     *         audience: {
+     *             type: "all"
+     *         }
      *     })
      */
-    getEnrollmentRealignment(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__getEnrollmentRealignment(request, requestOptions));
+    estimateAudienceEnrollment(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__estimateAudienceEnrollment(request, requestOptions));
     }
-    async __getEnrollmentRealignment(request, requestOptions) {
-        const { sequenceId, jobId } = request;
+    async __estimateAudienceEnrollment(request, requestOptions) {
+        const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/enrollments/realign-sending-window/jobs/${core.url.encodePathParam(jobId)}`),
-            method: "GET",
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/enroll-audience/estimate`),
+            method: "POST",
             headers: _headers,
+            contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.EstimateAudienceEnrollmentSequencesRequest.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,
@@ -1138,7 +1430,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.SequenceEnrollmentRealignJobResponse.parseOrThrow(_response.body, {
+                data: serializers.EstimateAudienceEnrollmentSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1150,20 +1442,12 @@ export class SequencesClient {
         }
         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(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_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,
@@ -1172,39 +1456,47 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/enrollments/realign-sending-window/jobs/{jobId}");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/enroll-audience/estimate");
     }
     /**
-     * Returns the endpoint configuration attached to an inbound_webhook trigger.
+     * @deprecated
      *
-     * @param {Sequenzy.GetInboundWebhookSequencesRequest} request
+     * Deprecated compatibility alias that creates and persists a disabled contact_added sequence draft from a goal. Use POST /sequences for new integrations.
+     *
+     * @param {Sequenzy.GenerateSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
      * @throws {@link Sequenzy.BadRequestError}
-     * @throws {@link Sequenzy.NotFoundError}
-     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.InternalServerError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.getInboundWebhook({
-     *         sequenceId: "sequenceId"
+     *     await client.sequences.generate({
+     *         goal: "Onboard a new workspace admin"
      *     })
      */
-    getInboundWebhook(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__getInboundWebhook(request, requestOptions));
+    generate(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__generate(request, requestOptions));
     }
-    async __getInboundWebhook(request, requestOptions) {
-        const { sequenceId } = request;
+    async __generate(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, `sequences/${core.url.encodePathParam(sequenceId)}/inbound-webhook`),
-            method: "GET",
+                environments.SequenzyEnvironment.Default, "generate/sequence"),
+            method: "POST",
             headers: _headers,
+            contentType: "application/json",
             queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.GenerateSequencesRequest.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,
@@ -1213,7 +1505,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.GetInboundWebhookSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.GenerateSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1227,10 +1519,12 @@ export class SequencesClient {
             switch (_response.error.statusCode) {
                 case 400:
                     throw new Sequenzy.BadRequestError(_response.error.body, _response.rawResponse);
-                case 404:
-                    throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
-                case 503:
-                    throw new Sequenzy.ServiceUnavailableError(_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 500:
+                    throw new Sequenzy.InternalServerError(_response.error.body, _response.rawResponse);
                 default:
                     throw new errors.SequenzyError({
                         statusCode: _response.error.statusCode,
@@ -1239,48 +1533,710 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/inbound-webhook");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/generate/sequence");
     }
     /**
-     * Returns aggregated engagement metrics plus a live active/waiting enrollment breakdown by current node for a specific sequence. This is an alias for /metrics/sequences/{sequenceId}.
+     * Starts designing 1 to 4 variations of one email of a sequence with AI, like "I like email 1, make a few variations" in the sequence editor's Emails view, and returns them at once with status generating. The source is the email's saved content. Generation runs in the background, usually under a minute; poll List Sequence Email Variations until each is ready or failed. The email does not change until you use one. An email can have up to 8 variations generating at once.
      *
-     * @param {Sequenzy.GetStatsSequencesRequest} request
+     * @param {Sequenzy.GenerateEmailVariationsSequencesRequest} request
      * @param {SequencesClient.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 Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.getStats({
-     *         sequenceId: "sequenceId"
+     *     await client.sequences.generateEmailVariations({
+     *         emailId: "emailId",
+     *         sequenceId: "sequenceId",
+     *         prompt: "A few bolder versions"
      *     })
      */
-    getStats(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__getStats(request, requestOptions));
+    generateEmailVariations(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__generateEmailVariations(request, requestOptions));
+    }
+    async __generateEmailVariations(request, requestOptions) {
+        const { sequenceId, emailId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/emails/${core.url.encodePathParam(emailId)}/variations/generate`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.GenerateEmailVariationsSequencesRequest.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.GenerateEmailVariationsSequencesResponse.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);
+                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", "/sequences/{sequenceId}/emails/{emailId}/variations/generate");
+    }
+    /**
+     * Returns sequence metadata, nodes, and editable email steps.
+     *
+     * @param {Sequenzy.GetSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.get({
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    get(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__get(request, requestOptions));
+    }
+    async __get(request, requestOptions) {
+        const { sequenceId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}`),
+            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.GetSequencesResponse.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);
+                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", "/sequences/{sequenceId}");
+    }
+    /**
+     * Status and counters of one audience enrollment run. Poll this while status is queued or running.
+     *
+     * @param {Sequenzy.GetAudienceEnrollmentSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getAudienceEnrollment({
+     *         runId: "runId",
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getAudienceEnrollment(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getAudienceEnrollment(request, requestOptions));
+    }
+    async __getAudienceEnrollment(request, requestOptions) {
+        const { sequenceId, runId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/audience-enrollments/${core.url.encodePathParam(runId)}`),
+            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.GetAudienceEnrollmentSequencesResponse.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 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, "GET", "/sequences/{sequenceId}/audience-enrollments/{runId}");
+    }
+    /**
+     * Reads one enrollment token, including how it entered, which branches it already took, and the bounded recorded graph walk from ClickHouse. Use this when list enrollments shows a completed token with enteredVia unknown or sitting on the completion node and you need to know why the first branch took its else path. Compared values are summaries (missing, empty, nonempty, equals_expected), never the raw field or event-property value. Legacy node-completion metadata that stored an unredacted evaluation reason is redacted on read. Check nodeHistoryTruncated and branchDecisionsTruncated before treating either history as complete.
+     *
+     * @param {Sequenzy.GetEnrollmentSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getEnrollment({
+     *         enrollmentId: "enrollmentId",
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getEnrollment(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getEnrollment(request, requestOptions));
+    }
+    async __getEnrollment(request, requestOptions) {
+        const { sequenceId, enrollmentId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/enrollments/${core.url.encodePathParam(enrollmentId)}`),
+            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.SequenceEnrollmentGetResponse.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);
+                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", "/sequences/{sequenceId}/enrollments/{enrollmentId}");
+    }
+    /**
+     * Returns the state of an applied realignment job. When status is completed, result contains the bounded realignment result and any continuation cursor.
+     *
+     * @param {Sequenzy.GetEnrollmentRealignmentSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getEnrollmentRealignment({
+     *         jobId: "jobId",
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getEnrollmentRealignment(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getEnrollmentRealignment(request, requestOptions));
+    }
+    async __getEnrollmentRealignment(request, requestOptions) {
+        const { sequenceId, jobId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/enrollments/realign-sending-window/jobs/${core.url.encodePathParam(jobId)}`),
+            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.SequenceEnrollmentRealignJobResponse.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);
+                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", "/sequences/{sequenceId}/enrollments/realign-sending-window/jobs/{jobId}");
+    }
+    /**
+     * Returns the endpoint configuration attached to an inbound_webhook trigger.
+     *
+     * @param {Sequenzy.GetInboundWebhookSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getInboundWebhook({
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getInboundWebhook(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getInboundWebhook(request, requestOptions));
+    }
+    async __getInboundWebhook(request, requestOptions) {
+        const { sequenceId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/inbound-webhook`),
+            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.GetInboundWebhookSequencesResponse.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 404:
+                    throw new Sequenzy.NotFoundError(_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", "/sequences/{sequenceId}/inbound-webhook");
+    }
+    /**
+     * Returns aggregated engagement metrics plus a live active/waiting enrollment breakdown by current node for a specific sequence. This is an alias for /metrics/sequences/{sequenceId}.
+     *
+     * @param {Sequenzy.GetStatsSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getStats({
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getStats(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getStats(request, requestOptions));
+    }
+    async __getStats(request, requestOptions) {
+        const { sequenceId, end, includeMachineEngagement, period, start } = request;
+        const _queryParams = {
+            end: end != null ? end?.toISOString() : undefined,
+            includeMachineEngagement,
+            period: period != null
+                ? serializers.GetStatsSequencesRequestPeriod.jsonOrThrow(period, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
+            start: start != null ? start?.toISOString() : undefined,
+        };
+        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, `sequences/${core.url.encodePathParam(sequenceId)}/stats`),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .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.GetStatsSequencesResponse.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);
+                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", "/sequences/{sequenceId}/stats");
+    }
+    /**
+     * Read status and step logs for a same-company sequence test run. Requires sequences:read and subscribers:read.
+     *
+     * @param {Sequenzy.GetTestRunSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.getTestRun({
+     *         runId: "runId",
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    getTestRun(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__getTestRun(request, requestOptions));
+    }
+    async __getTestRun(request, requestOptions) {
+        const { sequenceId, runId } = 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, `sequences/${core.url.encodePathParam(sequenceId)}/test-runs/${core.url.encodePathParam(runId)}`),
+            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.SequenceTestRunResponse.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);
+                default:
+                    throw new errors.SequenzyError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/test-runs/{runId}");
+    }
+    /**
+     * Returns matching automation sequences, newest first. Omit limit and offset to return all matches; either parameter enables pagination (default page size 50, capped at 100).
+     *
+     * @param {Sequenzy.ListSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.BadRequestError}
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.ForbiddenError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.list()
+     */
+    list(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    }
+    async __list(request = {}, requestOptions) {
+        const { label, labels, limit, offset, search, status } = request;
+        const _queryParams = {
+            label,
+            labels,
+            limit,
+            offset,
+            search,
+            status: status != null
+                ? serializers.SequenceStatus.jsonOrThrow(status, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })
+                : undefined,
+        };
+        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, "sequences"),
+            method: "GET",
+            headers: _headers,
+            queryString: core.url
+                .queryBuilder()
+                .addMany(_queryParams)
+                .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.ListSequencesResponse.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 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", "/sequences");
+    }
+    /**
+     * Recent audience enrollment runs for a sequence, newest first, with their status and counters.
+     *
+     * @param {Sequenzy.ListAudienceEnrollmentsSequencesRequest} request
+     * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Sequenzy.UnauthorizedError}
+     * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.listAudienceEnrollments({
+     *         sequenceId: "sequenceId"
+     *     })
+     */
+    listAudienceEnrollments(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listAudienceEnrollments(request, requestOptions));
     }
-    async __getStats(request, requestOptions) {
-        const { sequenceId, end, includeMachineEngagement, period, start } = request;
+    async __listAudienceEnrollments(request, requestOptions) {
+        const { sequenceId, limit } = request;
         const _queryParams = {
-            end: end != null ? end?.toISOString() : undefined,
-            includeMachineEngagement,
-            period: period != null
-                ? serializers.GetStatsSequencesRequestPeriod.jsonOrThrow(period, {
-                    unrecognizedObjectKeys: "strip",
-                    omitUndefined: true,
-                })
-                : undefined,
-            start: start != null ? start?.toISOString() : undefined,
+            limit,
         };
         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, `sequences/${core.url.encodePathParam(sequenceId)}/stats`),
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/audience-enrollments`),
             method: "GET",
             headers: _headers,
             queryString: core.url
@@ -1296,7 +2252,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.GetStatsSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.ListAudienceEnrollmentsSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1310,18 +2266,8 @@ export class SequencesClient {
             switch (_response.error.statusCode) {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
-                case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_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,
@@ -1330,53 +2276,41 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/stats");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/audience-enrollments");
     }
     /**
-     * Returns filtered, paginated automation sequences for the authenticated company.
+     * Lists the design variations of one email of a sequence, oldest first, with status (generating, ready, failed) and inUse (the email has exactly this content). Discarded variations are not listed. Poll this after Generate Sequence Email Variations until none is generating.
      *
-     * @param {Sequenzy.ListSequencesRequest} request
+     * @param {Sequenzy.ListEmailVariationsSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
      *
+     * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.UnauthorizedError}
      * @throws {@link Sequenzy.ForbiddenError}
-     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link Sequenzy.NotFoundError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
      * @example
-     *     await client.sequences.list()
+     *     await client.sequences.listEmailVariations({
+     *         emailId: "emailId",
+     *         sequenceId: "sequenceId"
+     *     })
      */
-    list(request = {}, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__list(request, requestOptions));
+    listEmailVariations(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__listEmailVariations(request, requestOptions));
     }
-    async __list(request = {}, requestOptions) {
-        const { labels, limit, offset, search, status } = request;
-        const _queryParams = {
-            labels,
-            limit,
-            offset,
-            search,
-            status: status != null
-                ? serializers.SequenceStatus.jsonOrThrow(status, {
-                    unrecognizedObjectKeys: "strip",
-                    omitUndefined: true,
-                })
-                : undefined,
-        };
+    async __listEmailVariations(request, requestOptions) {
+        const { sequenceId, emailId } = 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, "sequences"),
+                environments.SequenzyEnvironment.Default, `sequences/${core.url.encodePathParam(sequenceId)}/emails/${core.url.encodePathParam(emailId)}/variations`),
             method: "GET",
             headers: _headers,
-            queryString: core.url
-                .queryBuilder()
-                .addMany(_queryParams)
-                .mergeAdditional(requestOptions?.queryParams)
-                .build(),
+            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,
@@ -1385,7 +2319,7 @@ export class SequencesClient {
         });
         if (_response.ok) {
             return {
-                data: serializers.ListSequencesResponse.parseOrThrow(_response.body, {
+                data: serializers.ListEmailVariationsSequencesResponse.parseOrThrow(_response.body, {
                     unrecognizedObjectKeys: "passthrough",
                     allowUnrecognizedUnionMembers: true,
                     allowUnrecognizedEnumValues: true,
@@ -1397,18 +2331,14 @@ export class SequencesClient {
         }
         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(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
-                case 503:
-                    throw new Sequenzy.ServiceUnavailableError(_response.error.body, _response.rawResponse);
+                    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,
@@ -1417,7 +2347,7 @@ export class SequencesClient {
                     });
             }
         }
-        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences");
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/emails/{emailId}/variations");
     }
     /**
      * Lists the individual contacts enrolled in one sequence, with the node each one is currently sitting on. Defaults to active and waiting enrollments. Use this when sequence stats give you enrollmentCounts and you need the actual subscribers behind a number.
@@ -1500,13 +2430,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 case 503:
@@ -1662,13 +2586,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -1738,13 +2656,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -1757,6 +2669,88 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/pause-enrollments");
     }
+    /**
+     * Rewrites the first 3 emails of a public gallery sequence for your brand, or for another `website`, and returns them without creating anything. Emails that could not be written are counted in `failedEmailCount`; the call fails only when none could be written. Usually takes 10 to 30 seconds. Requires `sequences:write`.
+     *
+     * @param {Sequenzy.PreviewFromExampleSequencesRequest} request
+     * @param {SequencesClient.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 Sequenzy.InternalServerError}
+     * @throws {@link Sequenzy.ServiceUnavailableError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.previewFromExample()
+     */
+    previewFromExample(request = {}, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__previewFromExample(request, requestOptions));
+    }
+    async __previewFromExample(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, "sequences/from-example/preview"),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.PreviewFromExampleSequencesRequest.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.PreviewFromExampleSequencesResponse.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);
+                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,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/from-example/preview");
+    }
     /**
      * Pulls waiting enrollments forward to the start of the sequence sending window on the day they are already scheduled for. Changing a sending window leaves existing waits alone, so a widened window never reaches contacts already parked on an email-bound delay step and a narrowed one defers them to the next allowed day. Sequence windows never advance SMS, webhooks, branches, or other non-email actions. A wait only ever moves earlier, never onto a different local day, and never before now. Nobody is cancelled or re-enrolled. Defaults to a synchronous dry run; set dryRun false to queue a background apply job, then poll its status endpoint. Each job is capped at 1000 enrollments; when the completed result has hasMore true, pass nextCursor as cursor on the next request.
      *
@@ -1833,13 +2827,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -1917,13 +2905,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -1993,13 +2975,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -2077,7 +3053,7 @@ export class SequencesClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/inbound-webhook/rotate-secret");
     }
     /**
-     * Queues a real test email for one saved action_email sequence step to one or more internal reviewers. action_ab_test steps are not supported; inspect their variants through the A/B test endpoints. The sequence is not activated and no subscribers are enrolled. Returns one durable email send ID per recipient for delivery inspection.
+     * Queues a real test email for one saved action_email sequence step to one or more internal reviewers. action_ab_test steps are not supported; inspect their variants on the sequence detail emails[].abTest.variants payload. The sequence is not activated and no subscribers are enrolled. Returns one durable email send ID per recipient for delivery inspection.
      *
      * @param {Sequenzy.SendTestEmailSequencesRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -2141,13 +3117,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 default:
@@ -2227,13 +3197,7 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    throw new Sequenzy.ForbiddenError(_response.error.body, _response.rawResponse);
                 case 404:
                     throw new Sequenzy.NotFoundError(_response.error.body, _response.rawResponse);
                 case 503:
@@ -2248,6 +3212,89 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/sequences/{sequenceId}/simulate");
     }
+    /**
+     * Runs real sequence actions for one active subscriber. Emails are marked as tests. Requires sequences:activate and subscribers:read. Does not enable the sequence or record a trigger event. Ordinary failure retries are disabled; stalled-job recovery can replay actions after worker loss. Completed side effects are not rolled back. Inspect before starting another run.
+     *
+     * @param {Sequenzy.StartTestRunSequencesRequest} request
+     * @param {SequencesClient.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.InternalServerError}
+     * @throws {@link errors.SequenzyError}
+     * @throws {@link errors.SequenzyTimeoutError}
+     *
+     * @example
+     *     await client.sequences.startTestRun({
+     *         sequenceId: "sequenceId",
+     *         subscriberId: "subscriberId"
+     *     })
+     */
+    startTestRun(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__startTestRun(request, requestOptions));
+    }
+    async __startTestRun(request, requestOptions) {
+        const { sequenceId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/test-runs`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.StartTestRunSequencesRequest.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.SequenceTestRunResponse.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 500:
+                    throw new Sequenzy.InternalServerError(_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", "/sequences/{sequenceId}/test-runs");
+    }
     /**
      * Restores an archived sequence as a disabled draft for review.
      *
@@ -2310,7 +3357,7 @@ export class SequencesClient {
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/sequences/{sequenceId}/unarchive");
     }
     /**
-     * Updates sequence settings and content, inserts linear or branching steps, or performs revision-guarded graph edits.
+     * Updates sequence settings and content, inserts linear or branching steps, or performs revision-guarded graph edits. Marketer account keys must choose existing sender and Reply-To profiles; requests requiring new profiles return 400 before creating profiles, labels, or campaign/sequence changes, including nested steps and branches.
      *
      * @param {Sequenzy.SequenceUpdateRequest} request
      * @param {SequencesClient.RequestOptions} requestOptions - Request-specific configuration.
@@ -2319,6 +3366,7 @@ export class SequencesClient {
      * @throws {@link Sequenzy.UnauthorizedError}
      * @throws {@link Sequenzy.ForbiddenError}
      * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.UnprocessableEntityError}
      * @throws {@link Sequenzy.ServiceUnavailableError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
@@ -2530,15 +3578,11 @@ export class SequencesClient {
                 case 401:
                     throw new Sequenzy.UnauthorizedError(_response.error.body, _response.rawResponse);
                 case 403:
-                    throw new Sequenzy.ForbiddenError(serializers.Error_.parseOrThrow(_response.error.body, {
-                        unrecognizedObjectKeys: "passthrough",
-                        allowUnrecognizedUnionMembers: true,
-                        allowUnrecognizedEnumValues: true,
-                        skipValidation: true,
-                        breadcrumbsPrefix: ["response"],
-                    }), _response.rawResponse);
+                    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);
                 case 503:
                     throw new Sequenzy.ServiceUnavailableError(_response.error.body, _response.rawResponse);
                 default:
@@ -2559,6 +3603,7 @@ export class SequencesClient {
      *
      * @throws {@link Sequenzy.BadRequestError}
      * @throws {@link Sequenzy.NotFoundError}
+     * @throws {@link Sequenzy.ConflictError}
      * @throws {@link errors.SequenzyError}
      * @throws {@link errors.SequenzyTimeoutError}
      *
@@ -2613,6 +3658,8 @@ export class SequencesClient {
                     throw new Sequenzy.BadRequestError(_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);
                 default:
                     throw new errors.SequenzyError({
                         statusCode: _response.error.statusCode,
@@ -2623,4 +3670,88 @@ export class SequencesClient {
         }
         return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/sequences/{sequenceId}/goals/{goalId}");
     }
+    /**
+     * Saves a ready variation's design (blocks, theme and font) into the email, which keeps its own subject and preview text. With scope all, every other editable email of the sequence also takes its style exactly, without AI, keeping its own words. Each email saves on its own; one saved elsewhere since it was read is not overwritten (saved false with an error). Translations and A/B copy are re-derived. With dryRun nothing is saved.
+     *
+     * @param {Sequenzy.UseEmailVariationSequencesRequest} request
+     * @param {SequencesClient.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.sequences.useEmailVariation({
+     *         emailId: "emailId",
+     *         sequenceId: "sequenceId",
+     *         variationId: "variationId"
+     *     })
+     */
+    useEmailVariation(request, requestOptions) {
+        return core.HttpResponsePromise.fromPromise(this.__useEmailVariation(request, requestOptions));
+    }
+    async __useEmailVariation(request, requestOptions) {
+        const { sequenceId, emailId, variationId, ..._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, `sequences/${core.url.encodePathParam(sequenceId)}/emails/${core.url.encodePathParam(emailId)}/variations/${core.url.encodePathParam(variationId)}/use`),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryString: core.url.queryBuilder().mergeAdditional(requestOptions?.queryParams).build(),
+            requestType: "json",
+            body: mergeAdditionalBodyParameters(serializers.UseEmailVariationSequencesRequest.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.UseEmailVariationSequencesResponse.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, "POST", "/sequences/{sequenceId}/emails/{emailId}/variations/{variationId}/use");
+    }
 }