@sendly/node 3.29.0 → 3.30.0

package/dist/index.d.mts

@@ -978,6 +978,72 @@ interface UpdateWebhookOptions {
     /** Custom metadata */
     metadata?: Record<string, unknown>;
 }
+/**
+ * Options for replaying webhook deliveries
+ */
+interface WebhookRedeliverOptions {
+    /** Earliest delivery created_at to consider, ISO-8601 (default: now − 24h) */
+    since?: string;
+    /** Latest delivery created_at to consider, ISO-8601 (default: now) */
+    until?: string;
+    /** Filter by event type (default: all) */
+    eventTypes?: WebhookEventType[];
+    /** Replay deliveries in any of these statuses (default: ['failed', 'cancelled']) */
+    statuses?: DeliveryStatus[];
+    /** Maximum number of deliveries to requeue (default: 1000, max 10000) */
+    limit?: number;
+}
+/**
+ * Result of replaying webhook deliveries
+ */
+interface WebhookRedeliverResult {
+    message: string;
+    /** Number of deliveries that were re-queued */
+    requeued: number;
+    /** Number of deliveries that failed to re-queue */
+    skipped: number;
+    /** True if the matching set was larger than `limit` */
+    truncated: boolean;
+    /** Total number of matching deliveries before the limit was applied */
+    windowSize: number;
+    /** IDs of the new delivery records created by the replay */
+    deliveryIds: string[];
+    since: string;
+    until: string;
+    limit: number;
+}
+/**
+ * Options for backfilling missed webhook deliveries from the message log
+ */
+interface WebhookBackfillOptions {
+    /** Earliest message created_at to consider, ISO-8601 (default: now − 24h) */
+    since?: string;
+    /** Latest message created_at to consider, ISO-8601 (default: now) */
+    until?: string;
+    /** Filter by event type (default: subscribed message events) */
+    eventTypes?: WebhookEventType[];
+    /** Maximum number of events to synthesize (default: 1000, max 10000) */
+    limit?: number;
+}
+/**
+ * Result of backfilling missed webhook deliveries
+ */
+interface WebhookBackfillResult {
+    message: string;
+    /** Number of deliveries synthesized and dispatched */
+    synthesized: number;
+    /** Synthesized count grouped by event type */
+    byType: Record<string, number>;
+    /** True if there were more eligible events than `limit` */
+    truncated: boolean;
+    /** Total number of messages scanned for the window */
+    candidatesScanned: number;
+    /** IDs of the new delivery records */
+    deliveryIds: string[];
+    since: string;
+    until: string;
+    limit: number;
+}
 /**
  * A webhook delivery attempt
  */
@@ -2651,6 +2717,62 @@ declare class WebhooksResource {
         message: string;
         webhook: Webhook;
     }>;
+    /**
+     * Replay failed or cancelled webhook deliveries from the audit log.
+     *
+     * Use after a customer endpoint has recovered from an outage to re-fire
+     * deliveries that we recorded but couldn't deliver. Each replay creates
+     * a new delivery row preserving the original `event_id` so customers can
+     * dedupe.
+     *
+     * Rejects with HTTP 409 if the circuit is currently open — call
+     * {@link WebhooksResource.resetCircuit} first.
+     *
+     * @param id - Webhook ID
+     * @param options - Window and filter options
+     * @returns Counts of requeued deliveries plus the new delivery IDs
+     *
+     * @example
+     * ```typescript
+     * await sendly.webhooks.resetCircuit('whk_xxx');
+     * const result = await sendly.webhooks.redeliver('whk_xxx', {
+     *   since: '2026-05-01T00:00:00Z',
+     *   eventTypes: ['message.delivered', 'message.failed'],
+     *   limit: 5000,
+     * });
+     * console.log(`Requeued ${result.requeued} deliveries`);
+     * ```
+     */
+    redeliver(id: string, options?: WebhookRedeliverOptions): Promise<WebhookRedeliverResult>;
+    /**
+     * Backfill missed webhook events from the underlying message log.
+     *
+     * Use this when a circuit-breaker outage left events with no audit row
+     * (the case `redeliver` cannot recover). The endpoint scans the
+     * `messages` table for the window and synthesizes a webhook delivery
+     * for any message whose `message.sent` / `message.delivered` /
+     * `message.failed` event has not been successfully delivered yet.
+     *
+     * Synthesized events have fresh IDs — your endpoint should dedupe by
+     * `event.data.object.id` (the message ID).
+     *
+     * Rejects with HTTP 409 if the circuit is currently open — call
+     * {@link WebhooksResource.resetCircuit} first.
+     *
+     * @param id - Webhook ID
+     * @param options - Window and filter options
+     * @returns Counts grouped by event type plus the new delivery IDs
+     *
+     * @example
+     * ```typescript
+     * const result = await sendly.webhooks.backfill('whk_xxx', {
+     *   since: '2026-05-01T00:00:00Z',
+     *   eventTypes: ['message.delivered', 'message.failed'],
+     * });
+     * console.log(`Synthesized ${result.synthesized} events`, result.byType);
+     * ```
+     */
+    backfill(id: string, options?: WebhookBackfillOptions): Promise<WebhookBackfillResult>;
     /**
      * Rotate the webhook signing secret
      *

package/dist/index.d.ts

@@ -978,6 +978,72 @@ interface UpdateWebhookOptions {
     /** Custom metadata */
     metadata?: Record<string, unknown>;
 }
+/**
+ * Options for replaying webhook deliveries
+ */
+interface WebhookRedeliverOptions {
+    /** Earliest delivery created_at to consider, ISO-8601 (default: now − 24h) */
+    since?: string;
+    /** Latest delivery created_at to consider, ISO-8601 (default: now) */
+    until?: string;
+    /** Filter by event type (default: all) */
+    eventTypes?: WebhookEventType[];
+    /** Replay deliveries in any of these statuses (default: ['failed', 'cancelled']) */
+    statuses?: DeliveryStatus[];
+    /** Maximum number of deliveries to requeue (default: 1000, max 10000) */
+    limit?: number;
+}
+/**
+ * Result of replaying webhook deliveries
+ */
+interface WebhookRedeliverResult {
+    message: string;
+    /** Number of deliveries that were re-queued */
+    requeued: number;
+    /** Number of deliveries that failed to re-queue */
+    skipped: number;
+    /** True if the matching set was larger than `limit` */
+    truncated: boolean;
+    /** Total number of matching deliveries before the limit was applied */
+    windowSize: number;
+    /** IDs of the new delivery records created by the replay */
+    deliveryIds: string[];
+    since: string;
+    until: string;
+    limit: number;
+}
+/**
+ * Options for backfilling missed webhook deliveries from the message log
+ */
+interface WebhookBackfillOptions {
+    /** Earliest message created_at to consider, ISO-8601 (default: now − 24h) */
+    since?: string;
+    /** Latest message created_at to consider, ISO-8601 (default: now) */
+    until?: string;
+    /** Filter by event type (default: subscribed message events) */
+    eventTypes?: WebhookEventType[];
+    /** Maximum number of events to synthesize (default: 1000, max 10000) */
+    limit?: number;
+}
+/**
+ * Result of backfilling missed webhook deliveries
+ */
+interface WebhookBackfillResult {
+    message: string;
+    /** Number of deliveries synthesized and dispatched */
+    synthesized: number;
+    /** Synthesized count grouped by event type */
+    byType: Record<string, number>;
+    /** True if there were more eligible events than `limit` */
+    truncated: boolean;
+    /** Total number of messages scanned for the window */
+    candidatesScanned: number;
+    /** IDs of the new delivery records */
+    deliveryIds: string[];
+    since: string;
+    until: string;
+    limit: number;
+}
 /**
  * A webhook delivery attempt
  */
@@ -2651,6 +2717,62 @@ declare class WebhooksResource {
         message: string;
         webhook: Webhook;
     }>;
+    /**
+     * Replay failed or cancelled webhook deliveries from the audit log.
+     *
+     * Use after a customer endpoint has recovered from an outage to re-fire
+     * deliveries that we recorded but couldn't deliver. Each replay creates
+     * a new delivery row preserving the original `event_id` so customers can
+     * dedupe.
+     *
+     * Rejects with HTTP 409 if the circuit is currently open — call
+     * {@link WebhooksResource.resetCircuit} first.
+     *
+     * @param id - Webhook ID
+     * @param options - Window and filter options
+     * @returns Counts of requeued deliveries plus the new delivery IDs
+     *
+     * @example
+     * ```typescript
+     * await sendly.webhooks.resetCircuit('whk_xxx');
+     * const result = await sendly.webhooks.redeliver('whk_xxx', {
+     *   since: '2026-05-01T00:00:00Z',
+     *   eventTypes: ['message.delivered', 'message.failed'],
+     *   limit: 5000,
+     * });
+     * console.log(`Requeued ${result.requeued} deliveries`);
+     * ```
+     */
+    redeliver(id: string, options?: WebhookRedeliverOptions): Promise<WebhookRedeliverResult>;
+    /**
+     * Backfill missed webhook events from the underlying message log.
+     *
+     * Use this when a circuit-breaker outage left events with no audit row
+     * (the case `redeliver` cannot recover). The endpoint scans the
+     * `messages` table for the window and synthesizes a webhook delivery
+     * for any message whose `message.sent` / `message.delivered` /
+     * `message.failed` event has not been successfully delivered yet.
+     *
+     * Synthesized events have fresh IDs — your endpoint should dedupe by
+     * `event.data.object.id` (the message ID).
+     *
+     * Rejects with HTTP 409 if the circuit is currently open — call
+     * {@link WebhooksResource.resetCircuit} first.
+     *
+     * @param id - Webhook ID
+     * @param options - Window and filter options
+     * @returns Counts grouped by event type plus the new delivery IDs
+     *
+     * @example
+     * ```typescript
+     * const result = await sendly.webhooks.backfill('whk_xxx', {
+     *   since: '2026-05-01T00:00:00Z',
+     *   eventTypes: ['message.delivered', 'message.failed'],
+     * });
+     * console.log(`Synthesized ${result.synthesized} events`, result.byType);
+     * ```
+     */
+    backfill(id: string, options?: WebhookBackfillOptions): Promise<WebhookBackfillResult>;
     /**
      * Rotate the webhook signing secret
      *

package/dist/index.js

@@ -1316,6 +1316,93 @@ var WebhooksResource = class {
     });
     return transformKeys(response);
   }
+  /**
+   * Replay failed or cancelled webhook deliveries from the audit log.
+   *
+   * Use after a customer endpoint has recovered from an outage to re-fire
+   * deliveries that we recorded but couldn't deliver. Each replay creates
+   * a new delivery row preserving the original `event_id` so customers can
+   * dedupe.
+   *
+   * Rejects with HTTP 409 if the circuit is currently open — call
+   * {@link WebhooksResource.resetCircuit} first.
+   *
+   * @param id - Webhook ID
+   * @param options - Window and filter options
+   * @returns Counts of requeued deliveries plus the new delivery IDs
+   *
+   * @example
+   * ```typescript
+   * await sendly.webhooks.resetCircuit('whk_xxx');
+   * const result = await sendly.webhooks.redeliver('whk_xxx', {
+   *   since: '2026-05-01T00:00:00Z',
+   *   eventTypes: ['message.delivered', 'message.failed'],
+   *   limit: 5000,
+   * });
+   * console.log(`Requeued ${result.requeued} deliveries`);
+   * ```
+   */
+  async redeliver(id, options = {}) {
+    if (!id || !id.startsWith("whk_")) {
+      throw new Error("Invalid webhook ID format");
+    }
+    const body = {};
+    if (options.since !== void 0) body.since = options.since;
+    if (options.until !== void 0) body.until = options.until;
+    if (options.eventTypes !== void 0) body.event_types = options.eventTypes;
+    if (options.statuses !== void 0) body.statuses = options.statuses;
+    if (options.limit !== void 0) body.limit = options.limit;
+    const response = await this.http.request({
+      method: "POST",
+      path: `/webhooks/${encodeURIComponent(id)}/redeliver`,
+      body
+    });
+    return transformKeys(response);
+  }
+  /**
+   * Backfill missed webhook events from the underlying message log.
+   *
+   * Use this when a circuit-breaker outage left events with no audit row
+   * (the case `redeliver` cannot recover). The endpoint scans the
+   * `messages` table for the window and synthesizes a webhook delivery
+   * for any message whose `message.sent` / `message.delivered` /
+   * `message.failed` event has not been successfully delivered yet.
+   *
+   * Synthesized events have fresh IDs — your endpoint should dedupe by
+   * `event.data.object.id` (the message ID).
+   *
+   * Rejects with HTTP 409 if the circuit is currently open — call
+   * {@link WebhooksResource.resetCircuit} first.
+   *
+   * @param id - Webhook ID
+   * @param options - Window and filter options
+   * @returns Counts grouped by event type plus the new delivery IDs
+   *
+   * @example
+   * ```typescript
+   * const result = await sendly.webhooks.backfill('whk_xxx', {
+   *   since: '2026-05-01T00:00:00Z',
+   *   eventTypes: ['message.delivered', 'message.failed'],
+   * });
+   * console.log(`Synthesized ${result.synthesized} events`, result.byType);
+   * ```
+   */
+  async backfill(id, options = {}) {
+    if (!id || !id.startsWith("whk_")) {
+      throw new Error("Invalid webhook ID format");
+    }
+    const body = {};
+    if (options.since !== void 0) body.since = options.since;
+    if (options.until !== void 0) body.until = options.until;
+    if (options.eventTypes !== void 0) body.event_types = options.eventTypes;
+    if (options.limit !== void 0) body.limit = options.limit;
+    const response = await this.http.request({
+      method: "POST",
+      path: `/webhooks/${encodeURIComponent(id)}/backfill`,
+      body
+    });
+    return transformKeys(response);
+  }
   /**
    * Rotate the webhook signing secret
    *

package/dist/index.mjs

@@ -1256,6 +1256,93 @@ var WebhooksResource = class {
     });
     return transformKeys(response);
   }
+  /**
+   * Replay failed or cancelled webhook deliveries from the audit log.
+   *
+   * Use after a customer endpoint has recovered from an outage to re-fire
+   * deliveries that we recorded but couldn't deliver. Each replay creates
+   * a new delivery row preserving the original `event_id` so customers can
+   * dedupe.
+   *
+   * Rejects with HTTP 409 if the circuit is currently open — call
+   * {@link WebhooksResource.resetCircuit} first.
+   *
+   * @param id - Webhook ID
+   * @param options - Window and filter options
+   * @returns Counts of requeued deliveries plus the new delivery IDs
+   *
+   * @example
+   * ```typescript
+   * await sendly.webhooks.resetCircuit('whk_xxx');
+   * const result = await sendly.webhooks.redeliver('whk_xxx', {
+   *   since: '2026-05-01T00:00:00Z',
+   *   eventTypes: ['message.delivered', 'message.failed'],
+   *   limit: 5000,
+   * });
+   * console.log(`Requeued ${result.requeued} deliveries`);
+   * ```
+   */
+  async redeliver(id, options = {}) {
+    if (!id || !id.startsWith("whk_")) {
+      throw new Error("Invalid webhook ID format");
+    }
+    const body = {};
+    if (options.since !== void 0) body.since = options.since;
+    if (options.until !== void 0) body.until = options.until;
+    if (options.eventTypes !== void 0) body.event_types = options.eventTypes;
+    if (options.statuses !== void 0) body.statuses = options.statuses;
+    if (options.limit !== void 0) body.limit = options.limit;
+    const response = await this.http.request({
+      method: "POST",
+      path: `/webhooks/${encodeURIComponent(id)}/redeliver`,
+      body
+    });
+    return transformKeys(response);
+  }
+  /**
+   * Backfill missed webhook events from the underlying message log.
+   *
+   * Use this when a circuit-breaker outage left events with no audit row
+   * (the case `redeliver` cannot recover). The endpoint scans the
+   * `messages` table for the window and synthesizes a webhook delivery
+   * for any message whose `message.sent` / `message.delivered` /
+   * `message.failed` event has not been successfully delivered yet.
+   *
+   * Synthesized events have fresh IDs — your endpoint should dedupe by
+   * `event.data.object.id` (the message ID).
+   *
+   * Rejects with HTTP 409 if the circuit is currently open — call
+   * {@link WebhooksResource.resetCircuit} first.
+   *
+   * @param id - Webhook ID
+   * @param options - Window and filter options
+   * @returns Counts grouped by event type plus the new delivery IDs
+   *
+   * @example
+   * ```typescript
+   * const result = await sendly.webhooks.backfill('whk_xxx', {
+   *   since: '2026-05-01T00:00:00Z',
+   *   eventTypes: ['message.delivered', 'message.failed'],
+   * });
+   * console.log(`Synthesized ${result.synthesized} events`, result.byType);
+   * ```
+   */
+  async backfill(id, options = {}) {
+    if (!id || !id.startsWith("whk_")) {
+      throw new Error("Invalid webhook ID format");
+    }
+    const body = {};
+    if (options.since !== void 0) body.since = options.since;
+    if (options.until !== void 0) body.until = options.until;
+    if (options.eventTypes !== void 0) body.event_types = options.eventTypes;
+    if (options.limit !== void 0) body.limit = options.limit;
+    const response = await this.http.request({
+      method: "POST",
+      path: `/webhooks/${encodeURIComponent(id)}/backfill`,
+      body
+    });
+    return transformKeys(response);
+  }
   /**
    * Rotate the webhook signing secret
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendly/node",
-  "version": "3.29.0",
+  "version": "3.30.0",
   "description": "Official Sendly Node.js SDK for SMS messaging",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",