@whooshbang/sdk 5.0.0 → 6.0.0

package/dist/client.js

@@ -1,8 +1,8 @@
 import { validateWhoAmI, validateOperatorCollection, validateOperatorResolution, validateCreateOperatorMessageRequest, validateOperatorMessageResult, validateOperatorBroadcast, validateOperatorPreferences, validateOperatorConnectRequest, } from "@whooshbang/contracts";
 import { validateAssertEmailConsentRequest, validateBindingSummary, } from "@whooshbang/contracts";
-import { contractValidationErrors, validateOrganizationCredential, validateOrganizationCredentialCollection, validateOrganizationCredentialRotation, validateOrganizationCredentialSecretReveal, validateBillingProjectSlots, validateBillingPromotions, validateBillingPromotion, validateRedeemBillingPromotionRequest, validateAssignBillingProjectSlotsRequest, validateSubscriptionChange, validateConfirmSubscriptionChangeRequest, validateBillingEntitlements, validateSubscriptionSelection, validateProjectAttribution, validateUpdateProjectAttributionRequest, validateAutoTopUpSettings, validateUpdateAutoTopUpSettingsRequest, validateBillingAccount, validateCardSetup, validateCreateCreditPurchaseRequest, validateCreditPurchase, validateBillingInvoiceCollection, validateUpdateBillingReceiptEmailRequest, validateOrganizationProjection, validateApiCredential, validateApiCredentialCollection, validateApiCredentialRotation, validateApiCredentialSecretReveal, validateAttachNotifierConnectionRequest, validateChannelConnection, validateChannelConnectionCollection, validateConnectionProviderCollection, validateUsageReport, validateMessageListPage, validateMessageDeliveryHistory, validateMessageNotificationImage, validateInteractionTimeline, validateUpdateEmailSenderRequest, validateCustomerEventDeliveryHistory, validateCustomerEventDeliveryAttempt, validateDeliveryHolds, validateMachineClientOperationsList, validateRecipientCopyCatalogue, validateNotifierConnectionCollection, validateProjectRecipientExperience, validateRecipientBrandLogoUpload, validateNotificationImageAsset, validateUpdateProjectRecipientExperienceRequest, validateEnvironmentRecipientExperience, validateUpdateEnvironmentRecipientExperienceRequest, validateSubscriberChannelSettings, validateAcknowledgeEmailRemediationRequest, validateCreateRecipientSessionRequest, validateCreateRecipientSessionResponse, validateRecipientSession, validateCreateProviderHandoffRequest, validateProviderHandoff, validateSetPreferredBindingRequest, validatePreferredBinding, validateCreateSubscriberRequest, validateSubscriber, validateSubscriberDataExport, validateUpdateSubscriberRequest, validateSubscriberCollection, validateCloseOrganizationRequest, validateInviteTeammateRequest, validateTeammate, validateTeammateAccessRequest, validateTeammateCollection, validateOrganizationClosureResult, validateCreateSubscriberGroupRequest, validateUpdateSubscriberGroupRequest, validateSubscriberGroup, validateSubscriberGroupCollection, validateSubscriberGroupMembership, validateSubscriberGroupMembershipCollection, validateCreateGroupBroadcastRequest, validateGroupBroadcast, validateCreateOrganizationCredentialRequest, validateCreateApiCredentialRequest, validateCreateChannelConnectionRequest, validateCreateCustomerEndpointRequest, validateCreateMachineClientRequest, validateCreateMessageRequest, validateMessageCategory, validateMessageCategoryCollection, validateCreateMessageCategoryRequest, validateUpdateMessageCategoryRequest, validateSubscriberCategoryPreference, validateSubscriberCategoryPreferenceCollection, validateSetSubscriberCategoryPreferenceRequest, validateCreateProjectRequest, validateUpdateProjectRequest, validateCreateSubscriptionLinkRequest, validateCustomerEndpoint, validateCustomerEndpointAttemptCollection, validateCustomerEndpointCollection, validateCustomerEndpointMutationResult, validateInteractionSummary, validateMachineClient, validateMachineCredential, validateMachineEventAckRequest, validateMachineEventAckResponse, validateMachineEventPollResponse, validateMessage, validateProblem, validateProject, validateProjectCollection, validateRecipientCopyOverride, validateRecipientCopyOverrideCollection, validateProviderCapabilitiesCollection, validateProviderInstallationCollection, validateEmailDomainCollection, validateCreateEmailDomainRequest, validateRegisterMachineCredentialRequest, validateRotateOrganizationCredentialRequest, validateRotateApiCredentialRequest, validateConnectionTest, validateConnectionTestCollection, validateCreateConnectionTestRequest, validateCustomerApplicationManifest, validateRotateChannelConnectionCredentialRequest, validateRotateCustomerEndpointRequest, validateSubscriptionLink, validateUpdateChannelConnectionRequest, validateUpdateRecipientCopyOverrideRequest, } from "@whooshbang/contracts";
+import { contractValidationErrors, validateOrganizationCredential, validateOrganizationCredentialCollection, validateOrganizationCredentialRotation, validateOrganizationCredentialSecretReveal, validateBillingProjectSlots, validateBillingPromotions, validateBillingPromotion, validateRedeemBillingPromotionRequest, validateAssignBillingProjectSlotsRequest, validateSubscriptionChange, validateConfirmSubscriptionChangeRequest, validateBillingEntitlements, validateSubscriptionSelection, validateProjectAttribution, validateUpdateProjectAttributionRequest, validateAutoTopUpSettings, validateUpdateAutoTopUpSettingsRequest, validateBillingAccount, validateCardSetup, validateCreateCreditPurchaseRequest, validateCreditPurchase, validateBillingInvoiceCollection, validateUpdateBillingReceiptEmailRequest, validateOrganizationProjection, validateApiCredential, validateApiCredentialCollection, validateApiCredentialRotation, validateApiCredentialSecretReveal, validateAttachNotifierConnectionRequest, validateChannelConnection, validateChannelConnectionCollection, validateConnectionProviderCollection, validateUsageReport, validateMessageListPage, validateMessageDeliveryHistory, validateMessageNotificationImage, validateInteractionTimeline, validateUpdateEmailSenderRequest, validateCustomerEventDeliveryHistory, validateCustomerEventDeliveryAttempt, validateDeliveryHolds, validateMachineClientOperationsList, validateRecipientCopyCatalogue, validateNotifierConnectionCollection, validateProjectRecipientExperience, validateRecipientBrandLogoUpload, validateNotificationImageAsset, validateUpdateProjectRecipientExperienceRequest, validateEnvironmentRecipientExperience, validateUpdateEnvironmentRecipientExperienceRequest, validateSubscriberChannelSettings, validateAcknowledgeEmailRemediationRequest, validateCreateRecipientSessionRequest, validateCreateRecipientSessionResponse, validateRecipientSession, validateCreateProviderHandoffRequest, validateProviderHandoff, validateSetPreferredBindingRequest, validatePreferredBinding, validateCreateSubscriberRequest, validateSubscriber, validateSubscriberDataExport, validateUpdateSubscriberRequest, validateSubscriberCollection, validateCloseOrganizationRequest, validateInviteTeammateRequest, validateTeammate, validateTeammateAccessRequest, validateTeammateCollection, validateOrganizationClosureResult, validateCreateSubscriberGroupRequest, validateUpdateSubscriberGroupRequest, validateSubscriberGroup, validateSubscriberGroupCollection, validateSubscriberGroupMembership, validateSubscriberGroupMembershipCollection, validateCreateGroupBroadcastRequest, validateGroupBroadcast, validateCreateOrganizationCredentialRequest, validateCreateApiCredentialRequest, validateCreateChannelConnectionRequest, validateCreateCustomerEndpointRequest, validateCreateMachineClientRequest, validateCreateMessageRequest, validateCancelEscalationByKeyRequest, validateEscalationPathPreview, validateEscalationOrder, validateEscalationOrderCollection, validateSaveEscalationOrderRequest, validateQuietHours, validateSaveQuietHoursRequest, validateEscalationPolicy, validateEscalationPolicyCollection, validateEscalationLimits, validateUpdateEscalationLimitsRequest, validateEscalationPagingLimitReport, validateUpdateEscalationPolicyRequest, validateCancelEscalationRequest, validateEscalation, validateMessageCategory, validateMessageCategoryCollection, validateCreateMessageCategoryRequest, validateUpdateMessageCategoryRequest, validateSubscriberCategoryPreference, validateSubscriberCategoryPreferenceCollection, validateSetSubscriberCategoryPreferenceRequest, validateCreateProjectRequest, validateUpdateProjectRequest, validateCreateSubscriptionLinkRequest, validateCustomerEndpoint, validateCustomerEndpointAttemptCollection, validateCustomerEndpointCollection, validateCustomerEndpointMutationResult, validateInteractionSummary, validateMachineClient, validateMachineCredential, validateMachineEventAckRequest, validateMachineEventAckResponse, validateMachineEventPollResponse, validateMessage, validateProblem, validateProject, validateProjectCollection, validateRecipientCopyOverride, validateRecipientCopyOverrideCollection, validateProviderCapabilitiesCollection, validateProviderInstallationCollection, validateEmailDomainCollection, validateCreateEmailDomainRequest, validateRegisterMachineCredentialRequest, validateRotateOrganizationCredentialRequest, validateRotateApiCredentialRequest, validateConnectionTest, validateConnectionTestCollection, validateCreateConnectionTestRequest, validateCustomerApplicationManifest, validateRotateChannelConnectionCredentialRequest, validateRotateCustomerEndpointRequest, validateSubscriptionLink, validateUpdateChannelConnectionRequest, validateUpdateRecipientCopyOverrideRequest, } from "@whooshbang/contracts";
 import { validateAdditiveCompatible } from "./additive-compatibility.js";
-import { WhooshBangContractError, WhooshBangOutcomeUnknownError, WhooshBangProblemError, WhooshBangProtocolError, WhooshBangTransportError, validationError, } from "./errors.js";
+import { WhooshBangContractError, WhooshBangOutcomeUnknownError, WhooshBangProblemError, WhooshBangProtocolError, WhooshBangTransportError, WhooshBangValidationError, validationError, } from "./errors.js";
 import { interactionAnswer } from "./interactions.js";
 const MAX_RESPONSE_BYTES = 1024 * 1024;
 /**
@@ -79,6 +79,42 @@ function usageQuery(operation, options) {
     }
     return search.size === 0 ? "" : `?${search.toString()}`;
 }
+const templateRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function validateTemplateCatalog(value) {
+    return (templateRecord(value) &&
+        Array.isArray(value.items) &&
+        value.items.length <= 100 &&
+        Array.isArray(value.categories) &&
+        value.categories.every((category) => typeof category === "string") &&
+        (value.next_cursor === null || typeof value.next_cursor === "string") &&
+        Number.isSafeInteger(value.total) &&
+        Number.isSafeInteger(value.page) &&
+        Number.isSafeInteger(value.page_size) &&
+        value.items.every((item) => validateTemplateCatalogEntry(item)));
+}
+function validateTemplateCatalogEntry(item) {
+    return (templateRecord(item) &&
+        typeof item.id === "string" &&
+        typeof item.name === "string" &&
+        typeof item.displayName === "string" &&
+        typeof item.description === "string" &&
+        typeof item.category === "string" &&
+        typeof item.disabled === "boolean" &&
+        Number.isSafeInteger(item.latestPublishedRevision) &&
+        templateRecord(item.draft) &&
+        (item.published === undefined ||
+            (templateRecord(item.published) &&
+                Number.isSafeInteger(item.published.revision) &&
+                templateRecord(item.published.definition))));
+}
+function validateTemplateMessageSendResult(value) {
+    return (templateRecord(value) &&
+        validateMessage(value.message) &&
+        templateRecord(value.template) &&
+        typeof value.template.id === "string" &&
+        Number.isSafeInteger(value.template.revision) &&
+        typeof value.template.locale === "string");
+}
 async function readBoundedBytes(response, operation, maximumBytes) {
     const length = response.headers.get("content-length");
     if (length !== null &&
@@ -485,10 +521,16 @@ async function messageCreation(send) {
  * response; the resource validators alone do not, because the field is an
  * endpoint-level promise rather than part of the resource.
  */
+const CANCELLATION_RESPONSE_PATHS = {
+    cancelEscalation: "~1v1~1escalations~1{escalation_id}~1cancel",
+    cancelEscalationByKey: "~1v1~1escalations~1cancel",
+    cancelEscalationByKeyInEnvironment: "~1v1~1projects~1{project_id}~1environments~1{environment_id}~1escalations~1cancel",
+    cancelEscalationInEnvironment: "~1v1~1projects~1{project_id}~1environments~1{environment_id}~1escalations~1{escalation_id}~1cancel",
+    cancelMessage: "~1v1~1messages~1{message_id}~1cancel",
+    cancelSubscriptionLink: "~1v1~1subscription-links~1{subscription_link_id}~1cancel",
+};
 function cancellationEffectiveMissing(operationId) {
-    const path = operationId === "cancelMessage"
-        ? "~1v1~1messages~1{message_id}~1cancel"
-        : "~1v1~1subscription-links~1{subscription_link_id}~1cancel";
+    const path = CANCELLATION_RESPONSE_PATHS[operationId];
     return {
         instancePath: "",
         keyword: "required",
@@ -497,6 +539,16 @@ function cancellationEffectiveMissing(operationId) {
         schemaPath: `#/paths/${path}/post/responses/200/content/application~1json/schema/allOf/1/required`,
     };
 }
+/** Reads a cancellation response's `cancellation_effective` as the outcome. */
+function escalationCancelOutcome(operation, escalation) {
+    if (escalation.cancellation_effective === true) {
+        return { escalation, outcome: "cancelled" };
+    }
+    if (escalation.cancellation_effective === false) {
+        return { escalation, outcome: "already_closed" };
+    }
+    throw new WhooshBangContractError(operation, [cancellationEffectiveMissing(operation)], "The cancellation response did not say whether cancellation took effect.");
+}
 function describeFailure(error) {
     if (error instanceof WhooshBangProblemError) {
         return {
@@ -1370,6 +1422,61 @@ export class WhooshBangClient {
             validator: validateMessageCategoryCollection,
         });
     }
+    async listMessageTemplates(projectId, query = {}, options = {}) {
+        const operation = "listMessageTemplates";
+        const params = new URLSearchParams({ executable_only: "true" });
+        if (query.search !== undefined)
+            params.set("search", query.search);
+        if (query.category !== undefined)
+            params.set("category", query.category);
+        if (query.after !== undefined)
+            params.set("after", query.after);
+        if (query.limit !== undefined)
+            params.set("limit", String(query.limit));
+        if (query.page !== undefined)
+            params.set("page", String(query.page));
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            sideEffect: false,
+            path: `v1/projects/${pathSegment(operation, projectId, "projectId")}/message-templates?${params}`,
+            validator: validateTemplateCatalog,
+            strictResponse: true,
+        });
+    }
+    async sendTemplateMessage(projectId, environmentId, request, options = {}) {
+        const operation = "sendTemplateMessage";
+        if (!request.template ||
+            !templateRecord(request.input) ||
+            !request.to.subscriber_id)
+            throw new WhooshBangValidationError(operation, [
+                { path: "/template", code: "required" },
+            ]);
+        return this.#request({
+            body: request,
+            method: "POST",
+            operation,
+            options,
+            idempotencyKey: options.idempotencyKey,
+            sideEffect: true,
+            path: `${environmentRoot(operation, projectId, environmentId)}/template-messages`,
+            validator: validateTemplateMessageSendResult,
+            strictResponse: true,
+        });
+    }
+    async getMessageTemplate(projectId, reference, options = {}) {
+        const operation = "getMessageTemplate";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            sideEffect: false,
+            path: `v1/projects/${pathSegment(operation, projectId, "projectId")}/message-templates/${pathSegment(operation, reference, "reference")}`,
+            validator: validateTemplateCatalogEntry,
+            strictResponse: true,
+        });
+    }
     async createMessageCategory(projectId, request, options = {}) {
         const operation = "createMessageCategory";
         assertInput(operation, request, validateCreateMessageCategoryRequest);
@@ -1432,6 +1539,88 @@ export class WhooshBangClient {
             validator: validateSubscriberCategoryPreference,
         });
     }
+    /**
+     * The signed-in teammate's own escalation order for each urgency
+     * (FXO-3673); never another person's.
+     */
+    async getOwnEscalationOrders(projectId, environmentId, options = {}) {
+        const operation = "getOwnEscalationOrders";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/escalation-orders`,
+            sideEffect: false,
+            validator: validateEscalationOrderCollection,
+        });
+    }
+    /** Saves the signed-in teammate's own order for one urgency (FXO-3673). */
+    async saveOwnEscalationOrder(projectId, environmentId, level, request, options = {}) {
+        const operation = "saveOwnEscalationOrder";
+        assertInput(operation, request, validateSaveEscalationOrderRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/escalation-orders/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationOrder,
+        });
+    }
+    /** Returns the signed-in teammate to the project's order for one urgency. */
+    async resetOwnEscalationOrder(projectId, environmentId, level, options = {}) {
+        const operation = "resetOwnEscalationOrder";
+        return this.#request({
+            method: "DELETE",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/escalation-orders/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationOrder,
+        });
+    }
+    /** The signed-in teammate's own quiet hours (FXO-2103); never another person's. */
+    async getOwnQuietHours(projectId, environmentId, options = {}) {
+        const operation = "getOwnQuietHours";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/quiet-hours`,
+            sideEffect: false,
+            validator: validateQuietHours,
+        });
+    }
+    /**
+     * Replaces the signed-in teammate's own quiet hours. A value outside the
+     * rules fails with `request_invalid` naming the field.
+     */
+    async saveOwnQuietHours(projectId, environmentId, request, options = {}) {
+        const operation = "saveOwnQuietHours";
+        assertInput(operation, request, validateSaveQuietHoursRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/quiet-hours`,
+            sideEffect: true,
+            validator: validateQuietHours,
+        });
+    }
+    /** Turns off the signed-in teammate's own quiet hours. */
+    async resetOwnQuietHours(projectId, environmentId, options = {}) {
+        const operation = "resetOwnQuietHours";
+        return this.#request({
+            method: "DELETE",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/notification-preferences/quiet-hours`,
+            sideEffect: true,
+            validator: validateQuietHours,
+        });
+    }
     async getEnvironmentRecipientExperience(projectId, environmentId, options = {}) {
         const operation = "getEnvironmentRecipientExperience";
         return this.#request({
@@ -1468,6 +1657,37 @@ export class WhooshBangClient {
             strictResponse: true,
         });
     }
+    /**
+     * One subscriber's escalation order for every urgency, read only. Only the
+     * subscriber can change it, through their recipient session; unlike the
+     * preferred binding, no application credential can set it.
+     */
+    async getSubscriberEscalationOrders(projectId, environmentId, subscriberId, options = {}) {
+        const operation = "getSubscriberEscalationOrders";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            sideEffect: false,
+            path: `${environmentRoot(operation, projectId, environmentId)}/subscribers/${pathSegment(operation, subscriberId, "subscriberId")}/escalation-orders`,
+            validator: validateEscalationOrderCollection,
+        });
+    }
+    /**
+     * One subscriber's quiet hours, read only. Only the subscriber can change
+     * them, through their recipient session.
+     */
+    async getSubscriberQuietHours(projectId, environmentId, subscriberId, options = {}) {
+        const operation = "getSubscriberQuietHours";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            sideEffect: false,
+            path: `${environmentRoot(operation, projectId, environmentId)}/subscribers/${pathSegment(operation, subscriberId, "subscriberId")}/quiet-hours`,
+            validator: validateQuietHours,
+        });
+    }
     async transitionSubscriberBinding(projectId, environmentId, subscriberId, bindingId, action, options = {}) {
         const operation = "transitionSubscriberBinding";
         if (!["pause", "resume", "unsubscribe"].includes(action)) {
@@ -2073,6 +2293,71 @@ export class WhooshBangClient {
         }
         throw new WhooshBangContractError(operation, [cancellationEffectiveMissing("cancelMessage")], "The cancellation response did not say whether cancellation took effect.");
     }
+    /**
+     * Reads an escalation: every stage, each person's attempts and timing, and
+     * the single request-level outcome once it closes.
+     *
+     * While the escalation is open, `wait` holds the read until it closes, up to
+     * 30 seconds; a wait that expires still resolves with the current state.
+     * Inspection changes nothing.
+     */
+    async getEscalation(escalationId, options = {}) {
+        const operation = "getEscalation";
+        const suffix = inspectionWait(operation, options.wait);
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `v1/escalations/${pathSegment(operation, escalationId, "escalationId")}${suffix}`,
+            sideEffect: false,
+            validator: validateEscalation,
+        });
+    }
+    /**
+     * Stops every future attempt of an escalation and reports whether this call
+     * closed it.
+     *
+     * Idempotent on the service: cancelling a closed escalation, including one
+     * already answered, returns it unchanged as `already_closed`. Pass
+     * `reason: "resolved"` when your application resolved the matter itself.
+     */
+    async cancelEscalation(escalationId, request = {}, options = {}) {
+        const operation = "cancelEscalation";
+        assertInput(operation, request, validateCancelEscalationRequest);
+        const escalation = await this.#request({
+            body: request,
+            method: "POST",
+            operation,
+            options,
+            path: `v1/escalations/${pathSegment(operation, escalationId, "escalationId")}/cancel`,
+            sideEffect: true,
+            validator: validateEscalation,
+        });
+        return escalationCancelOutcome(operation, escalation);
+    }
+    /**
+     * Cancels the escalation created by the send that used this idempotency
+     * key, for a caller that kept the key but not the escalation id.
+     *
+     * `send_operation` names the send that used the key: `createMessage` (the
+     * default, covering `createMessageInEnvironment` too) or
+     * `sendOperatorMessage`. A key whose send did not escalate, or that matches
+     * nothing, is `resource_not_found`.
+     */
+    async cancelEscalationByKey(request, options = {}) {
+        const operation = "cancelEscalationByKey";
+        assertInput(operation, request, validateCancelEscalationByKeyRequest);
+        const escalation = await this.#request({
+            body: request,
+            method: "POST",
+            operation,
+            options,
+            path: "v1/escalations/cancel",
+            sideEffect: true,
+            validator: validateEscalation,
+        });
+        return escalationCancelOutcome(operation, escalation);
+    }
     async getCapabilities(options = {}) {
         return this.#request({
             method: "GET",
@@ -2953,6 +3238,161 @@ export class WhooshBangClient {
             validator: validateInteractionSummary,
         });
     }
+    async getEscalationInEnvironment(projectId, environmentId, escalationId, options = {}) {
+        const operation = "getEscalationInEnvironment";
+        const suffix = inspectionWait(operation, options.wait);
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalations/` +
+                `${pathSegment(operation, escalationId, "escalationId")}${suffix}`,
+            sideEffect: false,
+            validator: validateEscalation,
+        });
+    }
+    async cancelEscalationInEnvironment(projectId, environmentId, escalationId, request = {}, options = {}) {
+        const operation = "cancelEscalationInEnvironment";
+        assertInput(operation, request, validateCancelEscalationRequest);
+        const escalation = await this.#request({
+            body: request,
+            method: "POST",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalations/` +
+                `${pathSegment(operation, escalationId, "escalationId")}/cancel`,
+            sideEffect: true,
+            validator: validateEscalation,
+        });
+        return escalationCancelOutcome(operation, escalation);
+    }
+    async cancelEscalationByKeyInEnvironment(projectId, environmentId, request, options = {}) {
+        const operation = "cancelEscalationByKeyInEnvironment";
+        assertInput(operation, request, validateCancelEscalationByKeyRequest);
+        const escalation = await this.#request({
+            body: request,
+            method: "POST",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalations/cancel`,
+            sideEffect: true,
+            validator: validateEscalation,
+        });
+        return escalationCancelOutcome(operation, escalation);
+    }
+    /**
+     * The environment's escalation limits and the most each may be
+     * (FXO-2105). Until someone narrows them every limit is its maximum and
+     * `version` is absent.
+     */
+    async getEscalationLimits(projectId, environmentId, options = {}) {
+        const operation = "getEscalationLimits";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-limits`,
+            sideEffect: false,
+            validator: validateEscalationLimits,
+        });
+    }
+    /**
+     * Narrows the environment's escalation limits. Send the `version` read,
+     * or omit it when none was shown; a stale one fails with
+     * `escalation_limits_conflict` and nothing changes.
+     */
+    async updateEscalationLimits(projectId, environmentId, request, options = {}) {
+        const operation = "updateEscalationLimits";
+        assertInput(operation, request, validateUpdateEscalationLimitsRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-limits`,
+            sideEffect: true,
+            validator: validateEscalationLimits,
+        });
+    }
+    /** What the paging limit held back in this environment over the last 7 days. */
+    async getEscalationPagingLimitReport(projectId, environmentId, options = {}) {
+        const operation = "getEscalationPagingLimitReport";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-limits/held-back`,
+            sideEffect: false,
+            validator: validateEscalationPagingLimitReport,
+        });
+    }
+    /** One escalation default per urgency tier, lowest first (FXO-2103). */
+    async listEscalationPolicies(projectId, environmentId, options = {}) {
+        const operation = "listEscalationPolicies";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-policies`,
+            sideEffect: false,
+            validator: validateEscalationPolicyCollection,
+        });
+    }
+    /** A tier's saved default, or the built-in suggested order. */
+    async getEscalationPolicy(projectId, environmentId, level, options = {}) {
+        const operation = "getEscalationPolicy";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-policies/${pathSegment(operation, level, "level")}`,
+            sideEffect: false,
+            validator: validateEscalationPolicy,
+        });
+    }
+    /**
+     * Saves a tier's default as a new version. Every step's channel must be
+     * connected in the environment, or the call fails with
+     * `escalation_policy_channel_unconnected` and nothing changes.
+     */
+    async updateEscalationPolicy(projectId, environmentId, level, request, options = {}) {
+        const operation = "updateEscalationPolicy";
+        assertInput(operation, request, validateUpdateEscalationPolicyRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-policies/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationPolicy,
+        });
+    }
+    /** Returns a tier to the built-in suggested order and returns that order. */
+    async resetEscalationPolicy(projectId, environmentId, level, options = {}) {
+        const operation = "resetEscalationPolicy";
+        return this.#request({
+            method: "DELETE",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-policies/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationPolicy,
+        });
+    }
+    /** The order an escalation at this tier would snapshot for one subscriber. */
+    async previewEscalationPath(projectId, environmentId, level, subscriberId, options = {}) {
+        const operation = "previewEscalationPath";
+        const query = new URLSearchParams({ subscriber_id: subscriberId });
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `${environmentRoot(operation, projectId, environmentId)}/escalation-policies/${pathSegment(operation, level, "level")}/preview?${query}`,
+            sideEffect: false,
+            validator: validateEscalationPathPreview,
+        });
+    }
     async createMachineClientInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createMachineClientInEnvironment";
         assertInput(operation, request, validateCreateMachineClientRequest);
@@ -3546,6 +3986,101 @@ export class WhooshBangRecipientSessionClient {
             validator: validatePreferredBinding,
         });
     }
+    /**
+     * This subscriber's escalation order for every urgency: their own where they
+     * saved one, otherwise the project's, with each step's availability and the
+     * eligible bindings the order leaves out.
+     */
+    async getEscalationOrders(options = {}) {
+        const operation = "getEscalationOrders";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: "v1/recipient-session/escalation-orders",
+            sideEffect: false,
+            validator: validateEscalationOrderCollection,
+        });
+    }
+    /**
+     * Saves this subscriber's own order for one urgency. An empty `steps` is a
+     * choice that nothing is tried. Send back the `version` the tier showed
+     * when read (none for the suggested order); an order that changed since
+     * fails with `escalation_order_conflict`, and a binding they cannot use
+     * with `escalation_order_step_ineligible`.
+     */
+    async saveEscalationOrder(level, request, options = {}) {
+        const operation = "saveEscalationOrder";
+        assertInput(operation, request, validateSaveEscalationOrderRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: `v1/recipient-session/escalation-orders/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationOrder,
+        });
+    }
+    /** Goes back to the project's order for one urgency. */
+    async resetEscalationOrder(level, options = {}) {
+        const operation = "resetEscalationOrder";
+        return this.#request({
+            method: "DELETE",
+            operation,
+            options,
+            path: `v1/recipient-session/escalation-orders/${pathSegment(operation, level, "level")}`,
+            sideEffect: true,
+            validator: validateEscalationOrder,
+        });
+    }
+    /**
+     * This subscriber's quiet hours: when they would rather not be interrupted,
+     * what each channel does then, the choices each channel offers, the
+     * channels a withheld message can go to, and whether quiet hours are on now.
+     */
+    async getQuietHours(options = {}) {
+        const operation = "getQuietHours";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: "v1/recipient-session/quiet-hours",
+            sideEffect: false,
+            validator: validateQuietHours,
+        });
+    }
+    /**
+     * Replaces this subscriber's quiet hours. Send the time zone they see the
+     * times in. A value outside the rules fails with `request_invalid` naming
+     * the field, such as `quiet_channel_unavailable` for a quiet channel that
+     * is not theirs.
+     */
+    async saveQuietHours(request, options = {}) {
+        const operation = "saveQuietHours";
+        assertInput(operation, request, validateSaveQuietHoursRequest);
+        return this.#request({
+            body: request,
+            method: "PUT",
+            operation,
+            options,
+            path: "v1/recipient-session/quiet-hours",
+            sideEffect: true,
+            validator: validateQuietHours,
+        });
+    }
+    /** Turns off this subscriber's quiet hours. */
+    async resetQuietHours(options = {}) {
+        const operation = "resetQuietHours";
+        return this.#request({
+            method: "DELETE",
+            operation,
+            options,
+            path: "v1/recipient-session/quiet-hours",
+            sideEffect: true,
+            validator: validateQuietHours,
+        });
+    }
     async transitionBinding(bindingId, action, options = {}) {
         const operation = `${action}RecipientBinding`;
         return this.#request({