@zavudev/sdk 0.56.0 → 0.57.0

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/internal/utils/query.ts

@@ -1,23 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { ZavudevError } from '../../core/error';
+import * as qs from '../qs/stringify';
 
-/**
- * Basic re-implementation of `qs.stringify` for primitive types.
- */
 export function stringifyQuery(query: object | Record<string, unknown>) {
-  return Object.entries(query)
-    .filter(([_, value]) => typeof value !== 'undefined')
-    .map(([key, value]) => {
-      if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-      }
-      if (value === null) {
-        return `${encodeURIComponent(key)}=`;
-      }
-      throw new ZavudevError(
-        `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
-      );
-    })
-    .join('&');
+  return qs.stringify(query, { arrayFormat: 'comma' });
 }

package/src/resources/broadcasts/broadcasts.ts

@@ -182,15 +182,22 @@ export class Broadcasts extends APIResource {
   /**
    * Start sending the broadcast immediately or schedule for later.
    *
-   * **Verification is required to send, except on WhatsApp.** On every channel other
-   * than `whatsapp`, the team must have completed both identity verification (KYC)
-   * and business verification (KYB); passing one is not enough. A `whatsapp`
-   * broadcast requires neither: it can only be built on a template, and Meta vets
-   * the business and the content when it approves that template, so an unapproved
-   * template is refused instead. `smart` is not exempt — it can route a contact to
-   * SMS or email. Drafts can be created, edited and kept without any check. Every
-   * send path — dashboard, API and CLI alike — enforces the same rule, returning
-   * `403` with code `kyc_required` or `kyb_required` for whichever is outstanding.
+   * **The account must be past the unverified level to send, except on WhatsApp.**
+   * An account that has verified nothing is refused with `403` and code
+   * `kyc_required` on every channel other than `whatsapp`. Any one of these lifts
+   * it: identity verification (KYC), a saved payment method, a settled deposit, or a
+   * paid plan. Business verification (KYB) is not required to broadcast; it gates
+   * 10DLC registration only. A `whatsapp` broadcast is exempt: it can only be built
+   * on a template, and Meta vets the business and the content when it approves that
+   * template, so an unapproved template is refused instead. `smart` is not exempt,
+   * since it can route a contact to SMS or email. Drafts can be created, edited and
+   * kept without any check. Every send path (dashboard, API and CLI) enforces the
+   * same rule.
+   *
+   * **Daily ceilings apply per recipient.** Each message a broadcast sends counts
+   * against the channel's daily ceiling (see `POST /v1/messages`). Once the ceiling
+   * is reached, the remaining recipients are marked `failed` with `errorCode`
+   * `DAILY_LIMIT_EXCEEDED`; they are not retried the next day.
    *
    * **Review depends on the channel, and cannot be bypassed.** A draft is submitted
    * to automated content review here; it does not go straight out. A WhatsApp

package/src/resources/calls.ts

@@ -16,6 +16,15 @@ export class Calls extends APIResource {
    * **Requirements:**
    *
    * - The Voice Agents feature must be enabled for your team (otherwise `403`).
+   * - An account that has verified nothing may only call the phone numbers the
+   *   project has verified (`403` with code `destination_not_verified`, and
+   *   `details.verifiedNumbers` lists them), and at most 5 calls a day (`429` with
+   *   code `daily_limit_exceeded`). A number is verified from the dashboard's
+   *   Sandbox screen by sending the pre-filled WhatsApp message from that phone; the
+   *   same verification covers SMS and calls. Verify your identity, add a payment
+   *   method, settle a deposit or subscribe to call any destination. That raises the
+   *   ceiling to 50 calls a day on Free; paid plans have no daily call ceiling. Full
+   *   reference: https://docs.zavu.dev/concepts/sending-limits
    * - The sender's agent must have `voice.enabled` set to `true`.
    * - Not available with test-mode API keys.
    *

package/src/resources/contacts/contacts.ts

@@ -104,21 +104,6 @@ export class Contacts extends APIResource {
     });
   }
 
-  /**
-   * Dismiss the merge suggestion for a contact.
-   *
-   * @example
-   * ```ts
-   * await client.contacts.dismissMergeSuggestion('contactId');
-   * ```
-   */
-  dismissMergeSuggestion(contactID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.delete(path`/v1/contacts/${contactID}/merge-suggestion`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
-  }
-
   /**
    * Merge a source contact into this contact. All channels from the source contact
    * will be moved to the target contact, and the source contact will be marked as
@@ -206,11 +191,6 @@ export interface Contact {
    */
   profileName?: string | null;
 
-  /**
-   * ID of a contact suggested for merging.
-   */
-  suggestedMergeWith?: string;
-
   updatedAt?: string;
 }
 
@@ -339,11 +319,46 @@ export interface ContactUpdateParams {
    */
   defaultChannel?: 'sms' | 'whatsapp' | 'telegram' | 'email' | 'instagram' | 'messenger' | 'voice' | null;
 
+  /**
+   * Human-readable name for this contact. Set to null to clear it and fall back to
+   * the contact's identifier. Contacts created automatically from an inbound message
+   * have no display name until you set one.
+   */
+  displayName?: string | null;
+
   metadata?: { [key: string]: string };
 }
 
 export interface ContactListParams extends CursorParams {
+  /**
+   * Exact match on the contact's primary phone number, in E.164.
+   */
   phoneNumber?: string;
+
+  /**
+   * Free-text match over the contact's name (`displayName` and the WhatsApp profile
+   * name), phone numbers and email addresses. Case- and accent-insensitive. A phone
+   * number matches on a trailing fragment too, so `5551234` finds `+14155551234`.
+   *
+   * Contacts created automatically from an inbound message have no `displayName` —
+   * they are matched by their identifier until you set one with
+   * `PATCH /v1/contacts/{contactId}`.
+   *
+   * Results come back in relevance order rather than newest-first. `cursor` is
+   * opaque in both modes; pass back exactly what the previous response returned, and
+   * start a new pagination run when the search term changes.
+   */
+  search?: string;
+
+  /**
+   * Tag name. Repeatable: `?tag=vip&tag=chile` returns contacts carrying **every**
+   * tag given, not any of them — the same rule the dashboard filter applies.
+   *
+   * Tags are matched by name, case-insensitively. An unknown tag returns 400 rather
+   * than being ignored, because a typo that silently matched every contact would be
+   * a worse answer than an error.
+   */
+  tag?: Array<string>;
 }
 
 export interface ContactMergeParams {

package/src/resources/messages.ts

@@ -115,6 +115,36 @@ export class Messages extends APIResource {
    *   100/day. Teams on earlier plans keep their original email quotas instead
    * - SMS and voice are billed per message from your balance on every plan
    *
+   * **Account verification and daily limits:**
+   *
+   * - A brand-new account can send on every channel immediately, but `sms`,
+   *   `sms_oneway` and `voice` reach only the phone numbers the project has
+   *   verified. Sending elsewhere returns `403` with code
+   *   `destination_not_verified`; `details.verifiedNumbers` lists the numbers that
+   *   are reachable. A number is verified from the dashboard's Sandbox screen:
+   *   generate a code and send the pre-filled WhatsApp message from that phone to
+   *   Zavu's sandbox number. One verification covers WhatsApp, SMS and calls, up to
+   *   5 numbers per project. To send to any destination, do any one of these: verify
+   *   your identity, add a payment method, settle a deposit, or subscribe to a paid
+   *   plan. Business verification (KYB) is never required to send
+   * - Daily ceilings apply per channel group and rise with verification. An account
+   *   that has verified nothing: 25/day across `sms` + `sms_oneway`, 5/day for
+   *   `voice`, 100/day across WhatsApp, Telegram, Instagram and Messenger combined.
+   *   Past that floor: 200/day for SMS, or 10,000/day once identity or business
+   *   verification is approved (or a higher limit agreed for your account); 50/day
+   *   voice and 250/day conversational on Free. **Paid plans have no voice or
+   *   conversational daily ceiling.** Over a ceiling, sends return `429` with code
+   *   `daily_limit_exceeded` and `details.limit`; the count resets at 00:00 UTC
+   * - The daily ceiling never reduces the monthly allowance: 100/day on the
+   *   conversational group still reaches the 2,000 monthly A2P messages Free
+   *   includes
+   * - Email needs no account verification here: a sender with a verified domain
+   *   sends from day one, within the plan quota (100/day and 3,000/month on Free).
+   *   Over the daily quota it returns `429` with code `daily_limit_exceeded`. Email
+   *   broadcasts are the exception: they need the account past the unverified level,
+   *   see `POST /v1/broadcasts/{broadcastId}/send`
+   * - Full reference: https://docs.zavu.dev/concepts/sending-limits
+   *
    * **Email recipient pre-flight:** Email messages are validated automatically
    * before dispatch. Sends that would be a guaranteed hard bounce are failed instead
    * of sent, protecting your bounce rate: the message transitions to `failed`
@@ -202,6 +232,12 @@ export interface Message {
 
   createdAt: string;
 
+  /**
+   * Who sent the message. Needed to render a thread: `status` cannot tell the two
+   * apart, because an inbound message is also stored as `delivered`.
+   */
+  direction: 'inbound' | 'outbound';
+
   /**
    * Type of message. Non-text types are supported by WhatsApp and Telegram (varies
    * by type).

package/src/resources/number-10dlc/brands.ts

@@ -115,11 +115,16 @@ export class Brands extends APIResource {
 
   /**
    * Submit a draft brand to The Campaign Registry (TCR) for vetting. The brand must
-   * be in draft status. TCR's one-time $4 brand registration fee is charged from
-   * your balance at submission (passed through at cost) and refunded if the carrier
-   * rejects the registration. A team that already paid this fee through the
-   * compliance flow is not charged again. Campaign registration is billed separately
-   * when a campaign is submitted.
+   * be in draft status, and the team must have an approved Business Verification
+   * (KYB) — carriers register a brand against a vetted legal entity, so submitting
+   * without one returns `403` with code `kyb_required`.
+   *
+   * TCR's one-time $4 brand registration fee is charged from your balance at
+   * submission (passed through at cost) and refunded if the carrier rejects the
+   * registration. The fee is per BRAND: a team registering a second legal entity
+   * pays it again. A brand already paid for through the compliance flow is not
+   * charged twice. Campaign registration is billed separately when a campaign is
+   * submitted.
    *
    * @example
    * ```ts

package/src/resources/number-10dlc/campaigns/campaigns.ts

@@ -116,13 +116,14 @@ export class Campaigns extends APIResource {
   }
 
   /**
-   * Submit a draft campaign for carrier review. The campaign must be in draft status
-   * and its brand must be verified. TCR's one-time registration fee is charged from
-   * your balance at submission ($15 for standard use cases, $2 for LOW_VOLUME),
-   * passed through at cost and refunded if the carrier rejects it. Once approved,
-   * the campaign's monthly TCR fee ($10 standard, $2 LOW_VOLUME) is charged from
-   * your balance while the campaign is active — see registrationCostCents and
-   * monthlyFeeCents on the campaign object.
+   * The team must have an approved Business Verification (KYB): submitting without
+   * one returns `403` with code `kyb_required`. Submit a draft campaign for carrier
+   * review. The campaign must be in draft status and its brand must be verified.
+   * TCR's one-time registration fee is charged from your balance at submission ($15
+   * for standard use cases, $2 for LOW_VOLUME), passed through at cost and refunded
+   * if the carrier rejects it. Once approved, the campaign's monthly TCR fee ($10
+   * standard, $2 LOW_VOLUME) is charged from your balance while the campaign is
+   * active — see registrationCostCents and monthlyFeeCents on the campaign object.
    *
    * @example
    * ```ts

package/src/resources/phone-numbers.ts

@@ -229,7 +229,12 @@ export interface PhoneNumberPricing {
 
 export type PhoneNumberStatus = 'active' | 'suspended' | 'pending';
 
-export type PhoneNumberType = 'local' | 'national' | 'tollFree';
+/**
+ * Type of phone number. `mobile` is stocked in countries where no geographic
+ * (`local`) or non-geographic (`national`) inventory exists, and in several
+ * markets it is the only type that can receive SMS.
+ */
+export type PhoneNumberType = 'local' | 'national' | 'tollFree' | 'mobile';
 
 /**
  * A group of requirements for a specific country/phone type combination.

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.56.0'; // x-release-please-version
+export const VERSION = '0.57.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.56.0";
+export declare const VERSION = "0.57.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.56.0";
+export declare const VERSION = "0.57.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.56.0'; // x-release-please-version
+exports.VERSION = '0.57.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.56.0'; // x-release-please-version
+export const VERSION = '0.57.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map