@messagebird/sdk 0.49.0 → 0.51.0

package/dist/index.d.mts

@@ -1057,16 +1057,21 @@ type EmailMessageSendRequest = {
    */
   attachments?: Array<EmailAttachment>;
   /**
-   * Schedule the message to send at a future time instead of immediately. Must be at least 30 seconds and at most 30 days ahead. Outside that range the request is rejected with `422`. The message returns with status `accepted` and shows as `scheduled` on reads until it sends. Cancel it before then with the message cancel endpoint. Scheduled sends count against your plan's monthly scheduled-email allowance. Exceeding it is rejected with a `422`. A scheduled message has inline content: `scheduled_at` and `template` are mutually exclusive, and combining them is rejected with a `422`. This field is accepted only on a single send. Batch items reject it.
+   * Schedule the message to send at a future time instead of immediately. Must be at least 30 seconds and at most 30 days ahead. Outside that range the request is rejected with `422`. The message returns with status `accepted` and shows as `scheduled` on reads until it sends. Cancel it before then with the message cancel endpoint. Scheduled sends count against your plan's monthly scheduled-email allowance. Exceeding it is rejected with a `422`. A scheduled message has inline content: `scheduled_at` and `template` are mutually exclusive, and combining them is rejected with a `422`. Batch items take this field too, so one batch can mix scheduled and immediate messages.
    *
    */
   scheduled_at?: string;
 };
 /**
- * Batch of email message send requests. All items are validated before any are queued. Attachments are allowed on individual messages. Each message must stay within the 20 MB estimated generated message-size cap. The serialized JSON request body for the batch has a hard 20 MB cap.
- *
+ * Batch of email message send requests.
  */
-type EmailMessageBatchRequest = Array<EmailMessageSendRequest>;
+type EmailMessageBatchRequest = {
+  /**
+   * Email message send requests, up to 100. All items are validated before any are queued. Attachments are allowed on individual messages. Each message must stay within the 20 MB estimated generated message-size cap. The serialized JSON request body for the batch has a hard 20 MB cap.
+   *
+   */
+  messages: Array<EmailMessageSendRequest>;
+};
 type EmailMessageBatchItem = {
   /**
    * Message ID assigned to this batch item.
@@ -1885,9 +1890,14 @@ type SmsMessageSendRequest = unknown & {
   };
 };
 /**
- * Batch of SMS message send requests. All items are validated before any are queued.
+ * Batch of SMS message send requests.
  */
-type SmsMessageBatchRequest = Array<SmsMessageSendRequest>;
+type SmsMessageBatchRequest = {
+  /**
+   * SMS message send requests, up to 100. Each is an independent send; all are validated before any is queued.
+   */
+  messages: Array<SmsMessageSendRequest>;
+};
 /**
  * Aggregate result for an SMS batch.
  */
@@ -13061,8 +13071,10 @@ type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type DefaultedKeys<D> = D extends object ? Extract<keyof D, keyof EmailMessageSendRequest> : never;
 /** `send` params with defaulted fields made optional. */
 type EmailSend<D> = PartialBy<EmailMessageSendRequest, DefaultedKeys<D>>;
-/** `sendBatch` params — every item relaxed the same way `send` is. */
-type EmailSendBatch<D> = Array<EmailSend<D>>;
+/** `sendBatch` params — every item under `messages` relaxed the same way `send` is. */
+type EmailSendBatch<D> = {
+  messages: Array<EmailSend<D>>;
+};
 //#endregion
 //#region src/resources/emailStats.gen.d.ts
 type EmailStatsSummaryQuery = NonNullable<GetEmailStatsSummaryData["query"]>;
@@ -13615,24 +13627,29 @@ declare class EmailResource<D extends EmailChannelDefaults | undefined = undefin
    * is accepted (the API's 202). Channel defaults are applied per item, so a
    * field set as a default may be omitted from every item (per-item value wins).
    *
+   * Passing a bare array of sends is deprecated — wrap them in
+   * `{ messages: [...] }`.
+   *
    * @example Send a batch of messages
-   * const batch = await bird.email.sendBatch([
-   *   {
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["alice@example.com"],
-   *     subject: "Your receipt",
-   *     html: "<p>Thanks, Alice.</p>",
-   *   },
-   *   {
-   *     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-   *     to: ["bob@example.com"],
-   *     subject: "Your receipt",
-   *     html: "<p>Thanks, Bob.</p>",
-   *   },
-   * ]);
+   * const batch = await bird.email.sendBatch({
+   *   messages: [
+   *     {
+   *       from: { email: "onboarding@messagebird.dev", name: "Bird" },
+   *       to: ["alice@example.com"],
+   *       subject: "Your receipt",
+   *       html: "<p>Thanks, Alice.</p>",
+   *     },
+   *     {
+   *       from: { email: "onboarding@messagebird.dev", name: "Bird" },
+   *       to: ["bob@example.com"],
+   *       subject: "Your receipt",
+   *       html: "<p>Thanks, Bob.</p>",
+   *     },
+   *   ],
+   * });
    * for (const item of batch.data) console.log(item.id, item.status);
    */
-  sendBatch(params: EmailSendBatch<D>, options?: RequestOptions): APIPromise<EmailSendBatchResult>;
+  sendBatch(params: EmailSendBatch<D> | Array<EmailSend<D>>, options?: RequestOptions): APIPromise<EmailSendBatchResult>;
 }
 //#endregion
 //#region src/resources/audiences.gen.d.ts
@@ -14284,26 +14301,32 @@ declare class SmsResource extends SmsResourceBase {
    */
   send(params: SmsSendParams, options?: RequestOptions): APIPromise<SmsMessage>;
   /**
-   * Send up to 100 independent SMS messages in one call. Each item is a full send
-   * (free text or template); all items are validated before any are queued.
+   * Send up to 100 independent SMS messages in one call. Each item under
+   * `messages` is a full send (free text or template); all items are validated
+   * before any are queued.
+   *
+   * Passing a bare array of sends is deprecated — wrap them in
+   * `{ messages: [...] }`.
    *
    * @example
-   * const result = await bird.sms.sendBatch([
-   *   {
-   *     from: "+15557654321",
-   *     to: "+15551111111",
-   *     text: "Hi Alice!",
-   *     category: "marketing",
-   *   },
-   *   {
-   *     from: "+15557654321",
-   *     to: "+15552222222",
-   *     text: "Hi Bob!",
-   *     category: "marketing",
-   *   },
-   * ]);
+   * const result = await bird.sms.sendBatch({
+   *   messages: [
+   *     {
+   *       from: "+15557654321",
+   *       to: "+15551111111",
+   *       text: "Hi Alice!",
+   *       category: "marketing",
+   *     },
+   *     {
+   *       from: "+15557654321",
+   *       to: "+15552222222",
+   *       text: "Hi Bob!",
+   *       category: "marketing",
+   *     },
+   *   ],
+   * });
    */
-  sendBatch(params: SmsSendBatchParams, options?: RequestOptions): APIPromise<SmsSendBatchResult>;
+  sendBatch(params: SmsSendBatchParams | SmsSendParams[], options?: RequestOptions): APIPromise<SmsSendBatchResult>;
 }
 //#endregion
 //#region src/resources/smsKeywordRules.gen.d.ts

package/dist/index.mjs

@@ -1502,7 +1502,7 @@ const createEmailMessage = (options) => (options.client ?? client).post({
 /**
 * Create a batch of email messages
 *
-* Accepts up to 100 independent email messages and queues them for delivery. All items are validated before any are queued: if one fails validation, the entire batch is rejected. Field-level validation failures and business-rule failures, such as sending from a domain that is not verified, both return `422`. None of the items can set `scheduled_at`; schedule a single message with [Create an email message](/docs/api/reference/create-email-message) instead. Suppression is evaluated per recipient after acceptance, never as a synchronous error. The `202` response returns one entry per message in submission order, each with its own `id` you can use to fetch that message or match it against webhook events. Attachments are allowed per message. Each message must stay within the 20 MB estimated generated message-size cap, and the serialized JSON request body for the whole batch has a hard 20 MB cap.
+* Accepts up to 100 independent email messages and queues them for delivery. All items are validated before any are queued: if one fails validation, the entire batch is rejected. Field-level validation failures and business-rule failures, such as sending from a domain that is not verified, both return `422`. An item can set `scheduled_at` to send it later, on the same terms as a single scheduled send, and one batch can mix scheduled and immediate messages. Cancel a scheduled item before it sends with [Cancel an email message](/docs/api/reference/cancel-email-message). Suppression is evaluated per recipient after acceptance, never as a synchronous error. The `202` response returns one entry per message in submission order, each with its own `id` you can use to fetch that message or match it against webhook events. Attachments are allowed per message. Each message must stay within the 20 MB estimated generated message-size cap, and the serialized JSON request body for the whole batch has a hard 20 MB cap.
 *
 */
 const createEmailMessageBatch = (options) => (options.client ?? client).post({
@@ -5427,25 +5427,30 @@ var EmailResource = class extends EmailResourceBase {
 	* is accepted (the API's 202). Channel defaults are applied per item, so a
 	* field set as a default may be omitted from every item (per-item value wins).
 	*
+	* Passing a bare array of sends is deprecated — wrap them in
+	* `{ messages: [...] }`.
+	*
 	* @example Send a batch of messages
-	* const batch = await bird.email.sendBatch([
-	*   {
-	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-	*     to: ["alice@example.com"],
-	*     subject: "Your receipt",
-	*     html: "<p>Thanks, Alice.</p>",
-	*   },
-	*   {
-	*     from: { email: "onboarding@messagebird.dev", name: "Bird" },
-	*     to: ["bob@example.com"],
-	*     subject: "Your receipt",
-	*     html: "<p>Thanks, Bob.</p>",
-	*   },
-	* ]);
+	* const batch = await bird.email.sendBatch({
+	*   messages: [
+	*     {
+	*       from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*       to: ["alice@example.com"],
+	*       subject: "Your receipt",
+	*       html: "<p>Thanks, Alice.</p>",
+	*     },
+	*     {
+	*       from: { email: "onboarding@messagebird.dev", name: "Bird" },
+	*       to: ["bob@example.com"],
+	*       subject: "Your receipt",
+	*       html: "<p>Thanks, Bob.</p>",
+	*     },
+	*   ],
+	* });
 	* for (const item of batch.data) console.log(item.id, item.status);
 	*/
 	sendBatch(params, options) {
-		const body = params.map((item) => withDefaults(this.#defaults, item));
+		const body = { messages: (Array.isArray(params) ? params : params.messages).map((item) => withDefaults(this.#defaults, item)) };
 		return this.call("POST", options, ({ signal, headers }) => createEmailMessageBatch({
 			client: this.client,
 			body,
@@ -6465,29 +6470,36 @@ var SmsResource = class extends SmsResourceBase {
 		}));
 	}
 	/**
-	* Send up to 100 independent SMS messages in one call. Each item is a full send
-	* (free text or template); all items are validated before any are queued.
+	* Send up to 100 independent SMS messages in one call. Each item under
+	* `messages` is a full send (free text or template); all items are validated
+	* before any are queued.
+	*
+	* Passing a bare array of sends is deprecated — wrap them in
+	* `{ messages: [...] }`.
 	*
 	* @example
-	* const result = await bird.sms.sendBatch([
-	*   {
-	*     from: "+15557654321",
-	*     to: "+15551111111",
-	*     text: "Hi Alice!",
-	*     category: "marketing",
-	*   },
-	*   {
-	*     from: "+15557654321",
-	*     to: "+15552222222",
-	*     text: "Hi Bob!",
-	*     category: "marketing",
-	*   },
-	* ]);
+	* const result = await bird.sms.sendBatch({
+	*   messages: [
+	*     {
+	*       from: "+15557654321",
+	*       to: "+15551111111",
+	*       text: "Hi Alice!",
+	*       category: "marketing",
+	*     },
+	*     {
+	*       from: "+15557654321",
+	*       to: "+15552222222",
+	*       text: "Hi Bob!",
+	*       category: "marketing",
+	*     },
+	*   ],
+	* });
 	*/
 	sendBatch(params, options) {
+		const body = Array.isArray(params) ? { messages: params } : params;
 		return this.call("POST", options, ({ signal, headers }) => createSmsMessageBatch({
 			client: this.client,
-			body: params,
+			body,
 			headers,
 			signal
 		}));
@@ -7927,9 +7939,9 @@ var BirdClient = class {
 		this.#headers = {
 			...opts.defaultHeaders,
 			...opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : {},
-			"User-Agent": `bird-sdk-js/0.49.0`,
+			"User-Agent": `bird-sdk-js/0.51.0`,
 			"Bird-Surface": "sdk-js",
-			"Bird-Version": "0.49.0"
+			"Bird-Version": "0.51.0"
 		};
 		const caller = detectCaller();
 		if (caller) this.#headers["Bird-Caller"] = caller;