@sendly/node 3.29.0 → 3.31.0

package/README.md

@@ -185,8 +185,8 @@ const preview = await sendly.messages.previewBatch({
     { to: '+447700900123', text: 'Hello UK!' }
   ]
 });
-console.log(`Total credits needed: ${preview.totalCredits}`);
-console.log(`Valid: ${preview.valid}, Invalid: ${preview.invalid}`);
+console.log(`Credits needed: ${preview.creditsNeeded}`);
+console.log(`Will send: ${preview.willSend}, Blocked: ${preview.blocked}`);
 ```
 
 ### Rate Limit Information
@@ -233,7 +233,7 @@ const webhook = await sendly.webhooks.create({
 });
 
 console.log(`Webhook ID: ${webhook.id}`);
-console.log(`Secret: ${webhook.secret}`); // Store this securely!
+console.log(`Secret: ${webhook.secret}`); // Only returned at creation - store securely!
 
 // List all webhooks
 const webhooks = await sendly.webhooks.list();
@@ -275,10 +275,11 @@ const webhooks = new Webhooks('your_webhook_secret');
 // In your webhook handler
 app.post('/webhooks/sendly', (req, res) => {
   const signature = req.headers['x-sendly-signature'];
+  const timestamp = req.headers['x-sendly-timestamp'];
   const payload = req.body;
 
   try {
-    const event = webhooks.verifyAndParse(payload, signature);
+    const event = webhooks.parse(payload, signature, timestamp);
     
     switch (event.type) {
       case 'message.delivered':
@@ -311,13 +312,13 @@ console.log(`Reserved (scheduled): ${credits.reservedBalance} credits`);
 console.log(`Total: ${credits.balance} credits`);
 
 // View credit transaction history
-const { data: transactions } = await sendly.account.getCreditTransactions();
+const transactions = await sendly.account.getCreditTransactions();
 for (const tx of transactions) {
   console.log(`${tx.type}: ${tx.amount} credits - ${tx.description}`);
 }
 
 // List API keys
-const { data: keys } = await sendly.account.listApiKeys();
+const keys = await sendly.account.listApiKeys();
 for (const key of keys) {
   console.log(`${key.name}: ${key.prefix}*** (${key.type})`);
 }
@@ -328,12 +329,9 @@ console.log(`Messages sent: ${usage.messagesSent}`);
 console.log(`Credits used: ${usage.creditsUsed}`);
 
 // Create a new API key
-const newKey = await sendly.account.createApiKey({
-  name: 'Production Key',
-  type: 'live',
-  scopes: ['sms:send', 'sms:read']
-});
-console.log(`New key: ${newKey.key}`); // Only shown once!
+const { apiKey, key } = await sendly.account.createApiKey('Production Key');
+console.log(`New key: ${key}`); // Only shown once!
+console.log(`Key ID: ${apiKey.id}`);
 
 // Revoke an API key
 await sendly.account.revokeApiKey('key_xxx');
@@ -525,11 +523,11 @@ List scheduled messages.
 
 Get a scheduled message by ID.
 
-#### `cancelScheduled(id: string): Promise<CancelScheduledMessageResponse>`
+#### `cancelScheduled(id: string): Promise<CancelledMessageResponse>`
 
 Cancel a scheduled message and refund credits.
 
-#### `sendBatch(request: SendBatchRequest): Promise<BatchMessageResponse>`
+#### `sendBatch(request: BatchMessageRequest): Promise<BatchMessageResponse>`
 
 Send multiple messages in one API call.
 
@@ -543,9 +541,9 @@ List all batches.
 
 ### `sendly.webhooks`
 
-#### `create(request: CreateWebhookRequest): Promise<Webhook>`
+#### `create(options: CreateWebhookOptions): Promise<WebhookCreatedResponse>`
 
-Create a new webhook endpoint.
+Create a new webhook endpoint. The returned object includes a one-time `secret`.
 
 #### `list(): Promise<Webhook[]>`
 
@@ -555,7 +553,7 @@ List all webhooks.
 
 Get a webhook by ID.
 
-#### `update(id: string, request: UpdateWebhookRequest): Promise<Webhook>`
+#### `update(id: string, options: UpdateWebhookOptions): Promise<Webhook>`
 
 Update a webhook.
 
@@ -589,11 +587,11 @@ Get account information.
 
 Get credit balance.
 
-#### `getCreditTransactions(): Promise<CreditTransactionListResponse>`
+#### `getCreditTransactions(options?: { limit?: number; offset?: number }): Promise<CreditTransaction[]>`
 
 Get credit transaction history.
 
-#### `listApiKeys(): Promise<ApiKeyListResponse>`
+#### `listApiKeys(): Promise<ApiKey[]>`
 
 List API keys.
 
@@ -662,25 +660,27 @@ await client.enterprise.workspaces.delete('ws_xxx');
 // Submit full verification
 await client.enterprise.workspaces.submitVerification('ws_xxx', {
   businessName: 'Acme Insurance LLC',
-  businessType: 'llc',
-  ein: '12-3456789',
-  address: '100 Main St',
-  city: 'Austin',
-  state: 'TX',
-  zip: '78701',
+  website: 'https://acme.com',
+  entityType: 'PRIVATE_PROFIT',
+  brn: '12-3456789',
+  brnType: 'EIN',
+  brnCountry: 'US',
+  address: { street: '100 Main St', city: 'Austin', state: 'TX', zip: '78701', country: 'US' },
+  contact: { firstName: 'Jane', lastName: 'Doe', email: 'jane@acme.com', phone: '+15551234567' },
   useCase: 'Policy renewal reminders',
-  sampleMessages: ['Your policy renews on 3/15.']
+  sampleMessages: 'Your policy renews on 3/15.'
 });
 
-// Inherit from verified workspace
+// Inherit from verified workspace (shares toll-free number)
 await client.enterprise.workspaces.inheritVerification('ws_new', {
   sourceWorkspaceId: 'ws_verified'
 });
 
-// Inherit with new number
-await client.enterprise.workspaces.inheritVerification('ws_new', {
+// Inherit + new number: use provision() with inheritWithNewNumber instead
+await client.enterprise.provision({
+  name: 'Acme Insurance - Austin',
   sourceWorkspaceId: 'ws_verified',
-  purchaseNewNumber: true
+  inheritWithNewNumber: true
 });
 ```
 

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
      *
@@ -3773,6 +3895,49 @@ declare class MediaResource {
     upload(file: Buffer | NodeJS.ReadableStream, options?: MediaUploadOptions): Promise<MediaFile>;
 }
 
+/**
+ * Verification submit/resubmit payload. All fields optional for resubmits
+ * (server merges with existing record). For initial provision via
+ * `submitVerification` (no existing record), the validator requires:
+ * businessName, website, address, contact, useCase, useCaseSummary,
+ * sampleMessages, optInWorkflow.
+ */
+interface VerificationSubmitInput {
+    businessName?: string;
+    doingBusinessAs?: string;
+    website?: string;
+    address?: {
+        street?: string;
+        address1?: string;
+        address2?: string | null;
+        city?: string;
+        state?: string;
+        zip?: string;
+        country?: string;
+    };
+    contact?: {
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        phone?: string;
+    };
+    brn?: string | null;
+    brnType?: "EIN" | "SSN" | "DUNS" | "CRA" | "VAT" | "LEI" | "OTHER" | null;
+    brnCountry?: string | null;
+    entityType?: "SOLE_PROPRIETOR" | "PRIVATE_PROFIT" | "PUBLIC_PROFIT" | "NON_PROFIT" | "GOVERNMENT";
+    useCase?: string;
+    useCaseSummary?: string;
+    sampleMessages?: string;
+    optInWorkflow?: string;
+    optInImageUrls?: string;
+    monthlyVolume?: string;
+    additionalInformation?: string;
+    ageGatedContent?: boolean;
+    isvReseller?: string;
+    privacyUrl?: string;
+    termsUrl?: string;
+}
+
 declare class WorkspacesSubResource {
     private readonly http;
     constructor(http: HttpClient);
@@ -3797,18 +3962,46 @@ declare class WorkspacesSubResource {
     }>;
     get(workspaceId: string): Promise<EnterpriseWorkspaceDetail>;
     delete(workspaceId: string): Promise<void>;
-    submitVerification(workspaceId: string, data: {
-        businessName: string;
-        businessType: string;
-        ein: string;
-        address: string;
-        city: string;
-        state: string;
-        zip: string;
-        useCase: string;
-        sampleMessages: string[];
-        monthlyVolume?: number;
-    }): Promise<unknown>;
+    /**
+     * Submit (or resubmit) a verification for an enterprise workspace.
+     *
+     * Partial-update friendly (May 2026): for resubmit on an existing
+     * workspace, you only need to send the fields you want to change —
+     * everything else is preserved from the existing record. Hosted page
+     * URLs (`/biz/`, `/opt-in/`, `/legal/`) generated during provision
+     * are auto-preserved.
+     *
+     * For sole proprietors, leave `brn`, `brnType`, `brnCountry` undefined
+     * — the server strips them before forwarding to the carrier.
+     *
+     * @example Full submit
+     * ```ts
+     * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+     *   businessName: "Acme LLC",
+     *   website: "https://acme.com",
+     *   address: { street: "...", city: "...", state: "California", zip: "90001", country: "US" },
+     *   contact: { firstName: "...", lastName: "...", email: "...", phone: "+15551234567" },
+     *   useCase: "Insurance Services",
+     *   useCaseSummary: "...",
+     *   sampleMessages: "...",
+     *   optInWorkflow: "...",
+     *   entityType: "SOLE_PROPRIETOR",
+     * });
+     * ```
+     *
+     * @example Partial-update resubmit (only changing email)
+     * ```ts
+     * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+     *   contact: { email: "new@email.com" },
+     * });
+     * ```
+     */
+    submitVerification(workspaceId: string, data: VerificationSubmitInput): Promise<unknown>;
+    /**
+     * Convenience alias for resubmits. Reads more naturally when you only
+     * want to update a few fields after a rejection.
+     */
+    resubmitVerification(workspaceId: string, partialUpdates: VerificationSubmitInput): Promise<unknown>;
     inheritVerification(workspaceId: string, options: {
         sourceWorkspaceId: string;
     }): Promise<unknown>;

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
      *
@@ -3773,6 +3895,49 @@ declare class MediaResource {
     upload(file: Buffer | NodeJS.ReadableStream, options?: MediaUploadOptions): Promise<MediaFile>;
 }
 
+/**
+ * Verification submit/resubmit payload. All fields optional for resubmits
+ * (server merges with existing record). For initial provision via
+ * `submitVerification` (no existing record), the validator requires:
+ * businessName, website, address, contact, useCase, useCaseSummary,
+ * sampleMessages, optInWorkflow.
+ */
+interface VerificationSubmitInput {
+    businessName?: string;
+    doingBusinessAs?: string;
+    website?: string;
+    address?: {
+        street?: string;
+        address1?: string;
+        address2?: string | null;
+        city?: string;
+        state?: string;
+        zip?: string;
+        country?: string;
+    };
+    contact?: {
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        phone?: string;
+    };
+    brn?: string | null;
+    brnType?: "EIN" | "SSN" | "DUNS" | "CRA" | "VAT" | "LEI" | "OTHER" | null;
+    brnCountry?: string | null;
+    entityType?: "SOLE_PROPRIETOR" | "PRIVATE_PROFIT" | "PUBLIC_PROFIT" | "NON_PROFIT" | "GOVERNMENT";
+    useCase?: string;
+    useCaseSummary?: string;
+    sampleMessages?: string;
+    optInWorkflow?: string;
+    optInImageUrls?: string;
+    monthlyVolume?: string;
+    additionalInformation?: string;
+    ageGatedContent?: boolean;
+    isvReseller?: string;
+    privacyUrl?: string;
+    termsUrl?: string;
+}
+
 declare class WorkspacesSubResource {
     private readonly http;
     constructor(http: HttpClient);
@@ -3797,18 +3962,46 @@ declare class WorkspacesSubResource {
     }>;
     get(workspaceId: string): Promise<EnterpriseWorkspaceDetail>;
     delete(workspaceId: string): Promise<void>;
-    submitVerification(workspaceId: string, data: {
-        businessName: string;
-        businessType: string;
-        ein: string;
-        address: string;
-        city: string;
-        state: string;
-        zip: string;
-        useCase: string;
-        sampleMessages: string[];
-        monthlyVolume?: number;
-    }): Promise<unknown>;
+    /**
+     * Submit (or resubmit) a verification for an enterprise workspace.
+     *
+     * Partial-update friendly (May 2026): for resubmit on an existing
+     * workspace, you only need to send the fields you want to change —
+     * everything else is preserved from the existing record. Hosted page
+     * URLs (`/biz/`, `/opt-in/`, `/legal/`) generated during provision
+     * are auto-preserved.
+     *
+     * For sole proprietors, leave `brn`, `brnType`, `brnCountry` undefined
+     * — the server strips them before forwarding to the carrier.
+     *
+     * @example Full submit
+     * ```ts
+     * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+     *   businessName: "Acme LLC",
+     *   website: "https://acme.com",
+     *   address: { street: "...", city: "...", state: "California", zip: "90001", country: "US" },
+     *   contact: { firstName: "...", lastName: "...", email: "...", phone: "+15551234567" },
+     *   useCase: "Insurance Services",
+     *   useCaseSummary: "...",
+     *   sampleMessages: "...",
+     *   optInWorkflow: "...",
+     *   entityType: "SOLE_PROPRIETOR",
+     * });
+     * ```
+     *
+     * @example Partial-update resubmit (only changing email)
+     * ```ts
+     * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+     *   contact: { email: "new@email.com" },
+     * });
+     * ```
+     */
+    submitVerification(workspaceId: string, data: VerificationSubmitInput): Promise<unknown>;
+    /**
+     * Convenience alias for resubmits. Reads more naturally when you only
+     * want to update a few fields after a rejection.
+     */
+    resubmitVerification(workspaceId: string, partialUpdates: VerificationSubmitInput): Promise<unknown>;
     inheritVerification(workspaceId: string, options: {
         sourceWorkspaceId: string;
     }): Promise<unknown>;

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
    *
@@ -2988,25 +3075,59 @@ var WorkspacesSubResource = class {
       path: `/enterprise/workspaces/${encodeURIComponent(workspaceId)}`
     });
   }
+  /**
+   * Submit (or resubmit) a verification for an enterprise workspace.
+   *
+   * Partial-update friendly (May 2026): for resubmit on an existing
+   * workspace, you only need to send the fields you want to change —
+   * everything else is preserved from the existing record. Hosted page
+   * URLs (`/biz/`, `/opt-in/`, `/legal/`) generated during provision
+   * are auto-preserved.
+   *
+   * For sole proprietors, leave `brn`, `brnType`, `brnCountry` undefined
+   * — the server strips them before forwarding to the carrier.
+   *
+   * @example Full submit
+   * ```ts
+   * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+   *   businessName: "Acme LLC",
+   *   website: "https://acme.com",
+   *   address: { street: "...", city: "...", state: "California", zip: "90001", country: "US" },
+   *   contact: { firstName: "...", lastName: "...", email: "...", phone: "+15551234567" },
+   *   useCase: "Insurance Services",
+   *   useCaseSummary: "...",
+   *   sampleMessages: "...",
+   *   optInWorkflow: "...",
+   *   entityType: "SOLE_PROPRIETOR",
+   * });
+   * ```
+   *
+   * @example Partial-update resubmit (only changing email)
+   * ```ts
+   * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+   *   contact: { email: "new@email.com" },
+   * });
+   * ```
+   */
   async submitVerification(workspaceId, data) {
+    const body = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (v !== void 0) body[k] = v;
+    }
     const response = await this.http.request({
       method: "POST",
       path: `/enterprise/workspaces/${encodeURIComponent(workspaceId)}/verification/submit`,
-      body: {
-        business_name: data.businessName,
-        business_type: data.businessType,
-        ein: data.ein,
-        address: data.address,
-        city: data.city,
-        state: data.state,
-        zip: data.zip,
-        use_case: data.useCase,
-        sample_messages: data.sampleMessages,
-        ...data.monthlyVolume && { monthly_volume: data.monthlyVolume }
-      }
+      body
     });
     return transformKeys(response);
   }
+  /**
+   * Convenience alias for resubmits. Reads more naturally when you only
+   * want to update a few fields after a rejection.
+   */
+  async resubmitVerification(workspaceId, partialUpdates) {
+    return this.submitVerification(workspaceId, partialUpdates);
+  }
   async inheritVerification(workspaceId, options) {
     const response = await this.http.request({
       method: "POST",

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
    *
@@ -2928,25 +3015,59 @@ var WorkspacesSubResource = class {
       path: `/enterprise/workspaces/${encodeURIComponent(workspaceId)}`
     });
   }
+  /**
+   * Submit (or resubmit) a verification for an enterprise workspace.
+   *
+   * Partial-update friendly (May 2026): for resubmit on an existing
+   * workspace, you only need to send the fields you want to change —
+   * everything else is preserved from the existing record. Hosted page
+   * URLs (`/biz/`, `/opt-in/`, `/legal/`) generated during provision
+   * are auto-preserved.
+   *
+   * For sole proprietors, leave `brn`, `brnType`, `brnCountry` undefined
+   * — the server strips them before forwarding to the carrier.
+   *
+   * @example Full submit
+   * ```ts
+   * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+   *   businessName: "Acme LLC",
+   *   website: "https://acme.com",
+   *   address: { street: "...", city: "...", state: "California", zip: "90001", country: "US" },
+   *   contact: { firstName: "...", lastName: "...", email: "...", phone: "+15551234567" },
+   *   useCase: "Insurance Services",
+   *   useCaseSummary: "...",
+   *   sampleMessages: "...",
+   *   optInWorkflow: "...",
+   *   entityType: "SOLE_PROPRIETOR",
+   * });
+   * ```
+   *
+   * @example Partial-update resubmit (only changing email)
+   * ```ts
+   * await sendly.enterprise.workspaces.submitVerification(workspaceId, {
+   *   contact: { email: "new@email.com" },
+   * });
+   * ```
+   */
   async submitVerification(workspaceId, data) {
+    const body = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (v !== void 0) body[k] = v;
+    }
     const response = await this.http.request({
       method: "POST",
       path: `/enterprise/workspaces/${encodeURIComponent(workspaceId)}/verification/submit`,
-      body: {
-        business_name: data.businessName,
-        business_type: data.businessType,
-        ein: data.ein,
-        address: data.address,
-        city: data.city,
-        state: data.state,
-        zip: data.zip,
-        use_case: data.useCase,
-        sample_messages: data.sampleMessages,
-        ...data.monthlyVolume && { monthly_volume: data.monthlyVolume }
-      }
+      body
     });
     return transformKeys(response);
   }
+  /**
+   * Convenience alias for resubmits. Reads more naturally when you only
+   * want to update a few fields after a rejection.
+   */
+  async resubmitVerification(workspaceId, partialUpdates) {
+    return this.submitVerification(workspaceId, partialUpdates);
+  }
   async inheritVerification(workspaceId, options) {
     const response = await this.http.request({
       method: "POST",

package/package.json

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