@whooshbang/sdk 3.1.0 → 4.0.0

package/dist/client.js

@@ -568,10 +568,11 @@ export class WhooshBangClient {
             strictResponse: true,
         });
     }
-    async sendOperatorMessage(projectId, environmentId, request, options) {
+    async sendOperatorMessage(projectId, environmentId, request, options = {}) {
         const operation = "sendOperatorMessage";
         assertInput(operation, request, validateCreateOperatorMessageRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "POST",
             operation,
@@ -584,10 +585,11 @@ export class WhooshBangClient {
             body: request,
         });
     }
-    async broadcastOperators(projectId, environmentId, request, options) {
+    async broadcastOperators(projectId, environmentId, request, options = {}) {
         const operation = "broadcastOperators";
         assertInput(operation, request, validateCreateGroupBroadcastRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "POST",
             operation,
@@ -638,10 +640,11 @@ export class WhooshBangClient {
             body: request,
         });
     }
-    async connectOperatorChannel(projectId, environmentId, request, options) {
+    async connectOperatorChannel(projectId, environmentId, request, options = {}) {
         const operation = "connectOperatorChannel";
         assertInput(operation, request, validateOperatorConnectRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "POST",
             operation,
@@ -659,7 +662,7 @@ export class WhooshBangClient {
     #fetch;
     #logger;
     constructor(options) {
-        this.#baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.#baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://api.whooshbang.com");
         validateCredential(options.credential);
         this.#credential = options.credential;
         const runtimeFetch = options.fetch ?? globalThis.fetch;
@@ -689,10 +692,11 @@ export class WhooshBangClient {
             validator: validateBillingProjectSlots,
         });
     }
-    async assignBillingProjectSlots(request, options) {
+    async assignBillingProjectSlots(request, options = {}) {
         const operation = "assignBillingProjectSlots";
         assertInput(operation, request, validateAssignBillingProjectSlotsRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "PUT",
             operation,
@@ -714,10 +718,11 @@ export class WhooshBangClient {
             validator: validateBillingPromotions,
         });
     }
-    async redeemBillingPromotion(request, options) {
+    async redeemBillingPromotion(request, options = {}) {
         const operation = "redeemBillingPromotion";
         assertInput(operation, request, validateRedeemBillingPromotionRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "POST",
             operation,
@@ -729,10 +734,11 @@ export class WhooshBangClient {
             validator: validateBillingPromotion,
         });
     }
-    async createSubscriptionChange(request, options) {
+    async createSubscriptionChange(request, options = {}) {
         const operation = "createSubscriptionChange";
         assertInput(operation, request, validateSubscriptionSelection);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             body: request,
             idempotencyKey: options.idempotencyKey,
@@ -850,7 +856,8 @@ export class WhooshBangClient {
      * enters the card in the browser; nothing is charged. */
     async createCardSetup(options) {
         const operation = "createCardSetup";
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             method: "POST",
             operation,
@@ -874,10 +881,11 @@ export class WhooshBangClient {
     }
     /** Charges the default card for one credit pack. Credit is granted only
      * after a verified payment; a retry with the same key never charges twice. */
-    async createCreditPurchase(request, options) {
+    async createCreditPurchase(request, options = {}) {
         const operation = "createCreditPurchase";
         assertInput(operation, request, validateCreateCreditPurchaseRequest);
-        assertIdempotencyKey(operation, options.idempotencyKey);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
         return this.#request({
             body: request,
             idempotencyKey: options.idempotencyKey,
@@ -1177,7 +1185,7 @@ export class WhooshBangClient {
             validator: validateProjectCollection,
         });
     }
-    async createProject(request, options) {
+    async createProject(request, options = {}) {
         assertInput("createProject", request, validateCreateProjectRequest);
         return this.#request({
             body: request,
@@ -1303,7 +1311,7 @@ export class WhooshBangClient {
             validator: validateRecipientBrandLogoUpload,
         });
     }
-    async uploadNotificationImageAsset(projectId, environmentId, image, options) {
+    async uploadNotificationImageAsset(projectId, environmentId, image, options = {}) {
         const operation = "uploadNotificationImageAsset";
         if (image instanceof Blob && image.type.toLowerCase() !== "image/png") {
             throw validationError(operation, "image", "invalid_media_type", "image must be an image/png Blob or PNG Uint8Array.");
@@ -1417,7 +1425,7 @@ export class WhooshBangClient {
             strictResponse: true,
         });
     }
-    async createRecipientSession(request, options) {
+    async createRecipientSession(request, options = {}) {
         const operation = "createRecipientSession";
         assertInput(operation, request, validateCreateRecipientSessionRequest);
         return this.#request({
@@ -1462,14 +1470,14 @@ export class WhooshBangClient {
      * other. A difference between them would be a bug, not a feature, so there
      * is nowhere for one to appear.
      */
-    async assertEmailConsent(request, options) {
+    async assertEmailConsent(request, options = {}) {
         return this.#assertEmailConsent("assertEmailConsent", "v1", request, options);
     }
-    async assertEmailConsentInEnvironment(projectId, environmentId, request, options) {
+    async assertEmailConsentInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "assertEmailConsentInEnvironment";
         return this.#assertEmailConsent(operation, environmentRoot(operation, projectId, environmentId), request, options);
     }
-    async #assertEmailConsent(operation, root, request, options) {
+    async #assertEmailConsent(operation, root, request, options = {}) {
         assertInput(operation, request, validateAssertEmailConsentRequest);
         return this.#request({
             body: request,
@@ -1482,10 +1490,10 @@ export class WhooshBangClient {
             validator: validateBindingSummary,
         });
     }
-    async createSubscriber(request, options) {
+    async createSubscriber(request, options = {}) {
         return this.#createSubscriber("createSubscriber", "v1", request, options);
     }
-    async createSubscriberInEnvironment(projectId, environmentId, request, options) {
+    async createSubscriberInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createSubscriberInEnvironment";
         return this.#createSubscriber(operation, environmentRoot(operation, projectId, environmentId), request, options);
     }
@@ -1525,10 +1533,10 @@ export class WhooshBangClient {
         const operation = "listSubscriberGroupsInEnvironment";
         return this.#listSubscriberGroups(operation, environmentRoot(operation, projectId, environmentId), options);
     }
-    async createSubscriberGroup(request, options) {
+    async createSubscriberGroup(request, options = {}) {
         return this.#createSubscriberGroup("createSubscriberGroup", "v1", request, options);
     }
-    async createSubscriberGroupInEnvironment(projectId, environmentId, request, options) {
+    async createSubscriberGroupInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createSubscriberGroupInEnvironment";
         return this.#createSubscriberGroup(operation, environmentRoot(operation, projectId, environmentId), request, options);
     }
@@ -1581,10 +1589,10 @@ export class WhooshBangClient {
         const operation = "removeSubscriberGroupMemberInEnvironment";
         return this.#removeSubscriberGroupMember(operation, environmentRoot(operation, projectId, environmentId), groupKey, subscriberId, options);
     }
-    async createGroupBroadcast(groupKey, request, options) {
+    async createGroupBroadcast(groupKey, request, options = {}) {
         return this.#createGroupBroadcast("createGroupBroadcast", "v1", groupKey, request, options);
     }
-    async createGroupBroadcastInEnvironment(projectId, environmentId, groupKey, request, options) {
+    async createGroupBroadcastInEnvironment(projectId, environmentId, groupKey, request, options = {}) {
         const operation = "createGroupBroadcastInEnvironment";
         return this.#createGroupBroadcast(operation, environmentRoot(operation, projectId, environmentId), groupKey, request, options);
     }
@@ -1707,7 +1715,7 @@ export class WhooshBangClient {
             validator: validateApiCredential,
         });
     }
-    async createSubscriptionLink(request, options) {
+    async createSubscriptionLink(request, options = {}) {
         assertInput("createSubscriptionLink", request, validateCreateSubscriptionLinkRequest);
         return this.#request({
             body: request,
@@ -1731,7 +1739,7 @@ export class WhooshBangClient {
             validator: validateSubscriptionLink,
         });
     }
-    async cancelSubscriptionLink(subscriptionLinkId, options) {
+    async cancelSubscriptionLink(subscriptionLinkId, options = {}) {
         const operation = "cancelSubscriptionLink";
         let link;
         try {
@@ -1770,7 +1778,7 @@ export class WhooshBangClient {
      * failure: a person can revoke their channel at any time, and the branch
      * a caller takes is to invite them again.
      */
-    async createMessage(request, options) {
+    async createMessage(request, options = {}) {
         assertInput("createMessage", request, validateCreateMessageRequest);
         return messageCreation(() => this.#request({
             body: request,
@@ -1927,7 +1935,7 @@ export class WhooshBangClient {
      * `idempotencyKey` replays the send — the service returns the original
      * message and asks nothing twice — and resumes the wait.
      */
-    async ask(request, options) {
+    async ask(request, options = {}) {
         const operation = "ask";
         assertInput(operation, request, validateCreateMessageRequest);
         if (request.interaction === undefined) {
@@ -1960,7 +1968,7 @@ export class WhooshBangClient {
      * `sending`, `provider_accepted`, or `outcome_unknown` returns it with
      * `cancellation_effective: false` and never claims provider-side deletion.
      */
-    async cancelMessage(messageId, options) {
+    async cancelMessage(messageId, options = {}) {
         const operation = "cancelMessage";
         const message = await this.#request({
             idempotencyKey: options.idempotencyKey,
@@ -1989,6 +1997,159 @@ export class WhooshBangClient {
             validator: validateProviderCapabilitiesCollection,
         });
     }
+    /** Project-credential routes derive project and environment from the bearer. */
+    async listCustomerEndpointsWithCredential(options = {}) {
+        const operation = "listCustomerEndpointsWithCredential";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: "/v1/customer-endpoints" +
+                listPageQuery(operation, options, "customer endpoint"),
+            sideEffect: false,
+            validator: validateCustomerEndpointCollection,
+        });
+    }
+    async createCustomerEndpointWithCredential(request, options = {}) {
+        const operation = "createCustomerEndpointWithCredential";
+        assertInput(operation, request, validateCreateCustomerEndpointRequest);
+        return this.#request({
+            body: request,
+            idempotencyKey: options.idempotencyKey,
+            method: "POST",
+            operation,
+            options,
+            path: "/v1/customer-endpoints",
+            sideEffect: true,
+            validator: validateCustomerEndpointMutationResult,
+        });
+    }
+    async getCustomerEndpointWithCredential(endpointId, options = {}) {
+        const operation = "getCustomerEndpointWithCredential";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}`,
+            sideEffect: false,
+            validator: validateCustomerEndpoint,
+        });
+    }
+    async verifyCustomerEndpointWithCredential(endpointId, options = {}) {
+        const operation = "verifyCustomerEndpointWithCredential";
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/verify`,
+            sideEffect: true,
+            validator: validateCustomerEndpoint,
+        });
+    }
+    async rotateCustomerEndpointWithCredential(endpointId, request, options = {}) {
+        const operation = "rotateCustomerEndpointWithCredential";
+        assertInput(operation, request, validateRotateCustomerEndpointRequest);
+        return this.#request({
+            body: request,
+            idempotencyKey: options.idempotencyKey,
+            method: "POST",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/rotate`,
+            sideEffect: true,
+            validator: validateCustomerEndpointMutationResult,
+        });
+    }
+    async listCustomerEndpointAttemptsWithCredential(endpointId, options = {}) {
+        const operation = "listCustomerEndpointAttemptsWithCredential";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/attempts${listPageQuery(operation, options, "endpoint attempt")}`,
+            sideEffect: false,
+            validator: validateCustomerEndpointAttemptCollection,
+        });
+    }
+    async sendOperatorMessageWithCredential(request, options = {}) {
+        const operation = "sendOperatorMessageWithCredential";
+        assertInput(operation, request, validateCreateOperatorMessageRequest);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            idempotencyKey: options.idempotencyKey,
+            sideEffect: true,
+            path: "/v1/operator-messages",
+            validator: validateOperatorMessageResult,
+            strictResponse: true,
+            body: request,
+        });
+    }
+    async broadcastOperatorsWithCredential(request, options = {}) {
+        const operation = "broadcastOperatorsWithCredential";
+        assertInput(operation, request, validateCreateGroupBroadcastRequest);
+        if (options.idempotencyKey !== undefined)
+            assertIdempotencyKey(operation, options.idempotencyKey);
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            idempotencyKey: options.idempotencyKey,
+            sideEffect: true,
+            path: "/v1/operators/broadcasts",
+            validator: validateOperatorBroadcast,
+            strictResponse: true,
+            body: request,
+        });
+    }
+    async getOperatorBroadcastWithCredential(broadcastId, options = {}) {
+        const operation = "getOperatorBroadcastWithCredential";
+        return this.#request({
+            method: "GET",
+            operation,
+            options,
+            sideEffect: false,
+            path: `/v1/operators/broadcasts/${pathSegment(operation, broadcastId, "broadcastId")}`,
+            validator: validateOperatorBroadcast,
+            strictResponse: true,
+        });
+    }
+    async pauseCustomerEndpointWithCredential(endpointId, options = {}) {
+        const operation = "pauseCustomerEndpointWithCredential";
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/pause`,
+            sideEffect: true,
+            validator: validateCustomerEndpoint,
+        });
+    }
+    async resumeCustomerEndpointWithCredential(endpointId, options = {}) {
+        const operation = "resumeCustomerEndpointWithCredential";
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/resume`,
+            sideEffect: true,
+            validator: validateCustomerEndpoint,
+        });
+    }
+    async disableCustomerEndpointWithCredential(endpointId, options = {}) {
+        const operation = "disableCustomerEndpointWithCredential";
+        return this.#request({
+            method: "POST",
+            operation,
+            options,
+            path: `/v1/customer-endpoints/${pathSegment(operation, endpointId, "endpointId")}/disable`,
+            sideEffect: true,
+            validator: validateCustomerEndpoint,
+        });
+    }
     async listCustomerEndpoints(projectId, environmentId, options = {}) {
         const operation = "listCustomerEndpoints";
         return this.#request({
@@ -2008,7 +2169,7 @@ export class WhooshBangClient {
      * idempotent replay returns the same logical endpoint without it, so a caller
      * that loses the value must rotate rather than re-read.
      */
-    async createCustomerEndpoint(projectId, environmentId, request, options) {
+    async createCustomerEndpoint(projectId, environmentId, request, options = {}) {
         const operation = "createCustomerEndpoint";
         assertInput(operation, request, validateCreateCustomerEndpointRequest);
         return this.#request({
@@ -2050,7 +2211,7 @@ export class WhooshBangClient {
      * Both secrets verify for `overlap_seconds`, so a receiver that accepts the
      * previous and the new secret together has no verification gap.
      */
-    async rotateCustomerEndpoint(projectId, environmentId, endpointId, request, options) {
+    async rotateCustomerEndpoint(projectId, environmentId, endpointId, request, options = {}) {
         const operation = "rotateCustomerEndpoint";
         assertInput(operation, request, validateRotateCustomerEndpointRequest);
         return this.#request({
@@ -2227,7 +2388,7 @@ export class WhooshBangClient {
             validator: validateChannelConnection,
         });
     }
-    async revokeMachineClientInEnvironment(projectId, environmentId, machineClientId, options) {
+    async revokeMachineClientInEnvironment(projectId, environmentId, machineClientId, options = {}) {
         const operation = "revokeMachineClientInEnvironment";
         return this.#request({
             idempotencyKey: options.idempotencyKey,
@@ -2293,7 +2454,7 @@ export class WhooshBangClient {
             validator: validateChannelConnectionCollection,
         });
     }
-    async createChannelConnection(projectId, environmentId, request, options) {
+    async createChannelConnection(projectId, environmentId, request, options = {}) {
         const operation = "createChannelConnection";
         assertInput(operation, request, validateCreateChannelConnectionRequest);
         return this.#request({
@@ -2379,7 +2540,7 @@ export class WhooshBangClient {
      * code is exchanged by WhooshBang and never enters the SDK request or
      * response, while the server pins completion to the recorded workspace.
      */
-    async reauthorizeChannelConnection(projectId, environmentId, connectionId, options) {
+    async reauthorizeChannelConnection(projectId, environmentId, connectionId, options = {}) {
         const operation = "reauthorizeChannelConnection";
         return this.#request({
             idempotencyKey: options.idempotencyKey,
@@ -2510,7 +2671,7 @@ export class WhooshBangClient {
      * refused, because a diagnostic that leaves no trace is exactly what a
      * failure history cannot afford.
      */
-    async createConnectionTest(projectId, environmentId, connectionId, request, options) {
+    async createConnectionTest(projectId, environmentId, connectionId, request, options = {}) {
         const operation = "createConnectionTest";
         assertInput(operation, request, validateCreateConnectionTestRequest);
         return this.#request({
@@ -2636,7 +2797,7 @@ export class WhooshBangClient {
      * and semantics are otherwise identical, so a caller that changes authority
      * changes which method it calls and nothing else.
      */
-    async createSubscriptionLinkInEnvironment(projectId, environmentId, request, options) {
+    async createSubscriptionLinkInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createSubscriptionLinkInEnvironment";
         assertInput(operation, request, validateCreateSubscriptionLinkRequest);
         return this.#request({
@@ -2662,7 +2823,7 @@ export class WhooshBangClient {
             validator: validateSubscriptionLink,
         });
     }
-    async createMessageInEnvironment(projectId, environmentId, request, options) {
+    async createMessageInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createMessageInEnvironment";
         assertInput(operation, request, validateCreateMessageRequest);
         return messageCreation(() => this.#request({
@@ -2702,7 +2863,7 @@ export class WhooshBangClient {
             validator: validateInteractionSummary,
         });
     }
-    async createMachineClientInEnvironment(projectId, environmentId, request, options) {
+    async createMachineClientInEnvironment(projectId, environmentId, request, options = {}) {
         const operation = "createMachineClientInEnvironment";
         assertInput(operation, request, validateCreateMachineClientRequest);
         return this.#request({
@@ -2727,7 +2888,7 @@ export class WhooshBangClient {
             validator: validateProviderCapabilitiesCollection,
         });
     }
-    async createMachineClient(request, options) {
+    async createMachineClient(request, options = {}) {
         assertInput("createMachineClient", request, validateCreateMachineClientRequest);
         return this.#request({
             body: request,
@@ -2757,7 +2918,7 @@ export class WhooshBangClient {
      * The readable secret never leaves the caller's process. See
      * `createMachineCredential` for the generator that produces the pair.
      */
-    async registerMachineCredential(machineClientId, request, options) {
+    async registerMachineCredential(machineClientId, request, options = {}) {
         const operation = "registerMachineCredential";
         assertInput(operation, request, validateRegisterMachineCredentialRequest);
         return this.#request({
@@ -2778,7 +2939,7 @@ export class WhooshBangClient {
      * authority that carries none of its own — an OAuth grant, or an organization
      * credential — can finish a bootstrap it started.
      */
-    async registerMachineCredentialInEnvironment(projectId, environmentId, machineClientId, request, options) {
+    async registerMachineCredentialInEnvironment(projectId, environmentId, machineClientId, request, options = {}) {
         const operation = "registerMachineCredentialInEnvironment";
         assertInput(operation, request, validateRegisterMachineCredentialRequest);
         return this.#request({
@@ -2793,7 +2954,7 @@ export class WhooshBangClient {
             validator: validateMachineCredential,
         });
     }
-    async revokeMachineCredential(machineClientId, credentialId, options) {
+    async revokeMachineCredential(machineClientId, credentialId, options = {}) {
         const operation = "revokeMachineCredential";
         return this.#request({
             idempotencyKey: options.idempotencyKey,
@@ -2806,7 +2967,7 @@ export class WhooshBangClient {
             validator: validateMachineCredential,
         });
     }
-    async revokeMachineClient(machineClientId, options) {
+    async revokeMachineClient(machineClientId, options = {}) {
         const operation = "revokeMachineClient";
         return this.#request({
             idempotencyKey: options.idempotencyKey,
@@ -2841,7 +3002,7 @@ export class WhooshBangClient {
             validator: validateMachineEventPollResponse,
         });
     }
-    async acknowledgeMachineEvent(eventId, request, options) {
+    async acknowledgeMachineEvent(eventId, request, options = {}) {
         const operation = "acknowledgeMachineEvent";
         assertInput(operation, request, validateMachineEventAckRequest);
         return this.#request({
@@ -2855,7 +3016,7 @@ export class WhooshBangClient {
             validator: validateMachineEventAckResponse,
         });
     }
-    async #createSubscriber(operation, root, request, options) {
+    async #createSubscriber(operation, root, request, options = {}) {
         assertInput(operation, request, validateCreateSubscriberRequest);
         return this.#request({
             body: request,
@@ -2912,7 +3073,7 @@ export class WhooshBangClient {
             validator: validateSubscriberGroupCollection,
         });
     }
-    async #createSubscriberGroup(operation, root, request, options) {
+    async #createSubscriberGroup(operation, root, request, options = {}) {
         assertInput(operation, request, validateCreateSubscriberGroupRequest);
         return this.#request({
             body: request,
@@ -3015,7 +3176,7 @@ export class WhooshBangClient {
             sideEffect: true,
         });
     }
-    async #createGroupBroadcast(operation, root, groupKey, request, options) {
+    async #createGroupBroadcast(operation, root, groupKey, request, options = {}) {
         assertInput(operation, request, validateCreateGroupBroadcastRequest);
         return this.#request({
             body: request,
@@ -3068,6 +3229,11 @@ export class WhooshBangClient {
      * own call site, where it is already unmissable.
      */
     async #request(descriptor) {
+        if (descriptor.sideEffect &&
+            Object.hasOwn(descriptor, "idempotencyKey") &&
+            descriptor.idempotencyKey === undefined) {
+            descriptor = { ...descriptor, idempotencyKey: crypto.randomUUID() };
+        }
         if (descriptor.idempotencyKey !== undefined) {
             assertIdempotencyKey(descriptor.operation, descriptor.idempotencyKey);
         }
@@ -3207,7 +3373,7 @@ export class WhooshBangRecipientSessionClient {
     #browserCapability;
     #fetch;
     constructor(options) {
-        this.#baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.#baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://api.whooshbang.com");
         validateRecipientCapability(options.browserCapability);
         this.#browserCapability = options.browserCapability;
         const runtimeFetch = options.fetch ?? globalThis.fetch;
@@ -3278,6 +3444,11 @@ export class WhooshBangRecipientSessionClient {
         });
     }
     async #request(descriptor) {
+        if (descriptor.sideEffect &&
+            Object.hasOwn(descriptor, "idempotencyKey") &&
+            descriptor.idempotencyKey === undefined) {
+            descriptor = { ...descriptor, idempotencyKey: crypto.randomUUID() };
+        }
         const resolved = resolveSignal(descriptor.operation, descriptor.options);
         const headers = new Headers({
             accept: "application/json, application/problem+json",