@signalhousellc/sdk 1.0.53 → 1.0.55

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalhousellc/sdk",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "description": "Signal House SDK for use with the Signal House platform",
   "type": "module",
   "main": "src/SignalHouseSDK.js",

package/src/domains/Brands.js

@@ -198,6 +198,29 @@ export class Brands {
 		return this.client(`/brand/externalvetting/${safeBrandId}`, { method: "POST", ...options });
 	}
 
+	/**
+	 * Import an existing external vetting record for a brand
+	 *
+	 * Unlike createExternalVetting (which orders a new, billable vetting), this attaches a vetting the
+	 * brand already completed directly with the provider, using the provider-issued vettingId and
+	 * vettingToken. It is synchronous and not billable.
+	 * @async
+	 * @roles api, admin, developer, billing, user
+	 * @param {Object} params - The parameters for importing external vetting
+	 * @param {string} params.brandId - The ID of the brand to import external vetting for
+	 * @param {string} params.vettingProviderId - The external vetting provider (AEGIS, WMC, CV)
+	 * @param {string} params.vettingId - The provider-issued vetting / transaction ID to import
+	 * @param {string} [params.vettingToken] - The provider-issued vetting token (required by some providers, e.g. AEGIS)
+	 * @param {import('../SignalHouseSDK').RequestOptions} [params.options] - Additional options for the request
+	 * @throws {Error} Throws an error if brandId, vettingProviderId, or vettingId is missing
+	 * @returns {Promise<Object>} The response from the server
+	 */
+	async importExternalVetting({ brandId, vettingProviderId, vettingId, vettingToken, options = {} }) {
+		this.client._require({ brandId, vettingProviderId, vettingId });
+		const safeBrandId = encodeURIComponent(brandId);
+		return this.client(`/brand/externalvetting/import/${safeBrandId}`, { method: "POST", body: { vettingProviderId, vettingId, vettingToken }, ...options });
+	}
+
 	/**
 	 * Update a brand's information
 	 * @async

package/src/domains/Messages.js

@@ -18,6 +18,8 @@ export class Messages {
 	 * @param {string} [params.status] - Filter messages by their status (ENQUEUED, DEQUEUED, SENT, FAILED, DELIVERED)
 	 * @param {string} [params.direction] - Filter messages by their direction (INBOUND, OUTBOUND)
 	 * @param {string|string[]} [params.messageType] - Filter messages by their type. Accepts a single value or an array (e.g. ["SMS", "MMS"]). Allowed values: SMS, MMS, RCS, WHATSAPP, VIBER, P2P. When omitted, defaults to all non-P2P types.
+	 * @param {string|string[]} [params.channel] - Filter messages by messaging channel. Accepts a single value or an array (cumulative). Allowed values: TEN_DLC, TOLL_FREE, P2P. Channel is derived on read from the associated campaign/brand registrationType (or messageType "P2P"); it is not stored on the message. Ignored when matchAny is true (matchAny takes precedence).
+	 * @param {boolean} [params.matchAny] - When true, the provided campaignId/brandId/phoneNumber filters are OR'd (a message matches ANY of them) instead of the default most-specific-single behavior. subgroupId stays an AND scope. Opt-in/additive.
 	 * @param {string} [params.carrier] - Filter messages by the carrier used for sending
 	 * @param {string} [params.senderPhoneNumber] - Filter messages by the sender's phone number
 	 * @param {string} [params.recipientPhoneNumber] - Filter messages by the recipient's phone number
@@ -42,6 +44,8 @@ export class Messages {
 		status,
 		direction,
 		messageType,
+		channel,
+		matchAny,
 		carrier,
 		startDate,
 		endDate,
@@ -51,7 +55,7 @@ export class Messages {
 		limit,
 		options = {},
 	}) {
-		const filters = { id, campaignId, brandId, subgroupId, groupId, phoneNumber, senderPhoneNumber, recipientPhoneNumber, status, direction, messageType, carrier, startDate, endDate, sortField, sortOrder, page, limit };
+		const filters = { id, campaignId, brandId, subgroupId, groupId, phoneNumber, senderPhoneNumber, recipientPhoneNumber, status, direction, messageType, channel, matchAny, carrier, startDate, endDate, sortField, sortOrder, page, limit };
 		const queryString = this.client._getQueryString(filters);
 		return this.client(`/message${queryString}`, { method: "GET", ...options });
 	}
@@ -89,11 +93,13 @@ export class Messages {
 	 * @param {string} [params.carrier] - Filter analytics by the carrier used for sending
 	 * @param {string} [params.startDate] - ISO-8601 date or timestamp; normalized to start-of-UTC-day (inclusive)
 	 * @param {string} [params.endDate] - ISO-8601 date or timestamp; normalized to end-of-UTC-day (inclusive). Hourly resolution is not supported
+	 * @param {boolean} [params.matchAny] - When true, the provided campaignId/brandId/phoneNumber filters are OR'd (match ANY) instead of the default most-specific-single behavior. subgroupId stays an AND scope. Opt-in/additive.
+	 * @param {string|string[]} [params.channel] - Filter analytics by messaging channel (TEN_DLC, TOLL_FREE). Derived on read from the campaign/brand registrationType; resolves to the channel's campaigns so the analytics count matches the channel-filtered message list. Accepts a single value or array (cumulative). Ignored when matchAny is true (matchAny takes precedence).
 	 * @param {import('../SignalHouseSDK').RequestOptions} [params.options] - Additional options for the request
 	 * @returns {Promise<Object>} - A promise that resolves to the analytics data
 	 */
-	async getAnalytics({ groupId, subgroupId, brandId, campaignId, phoneNumber, carrier, startDate, endDate, options = {} }) {
-		const filters = { groupId, subgroupId, brandId, campaignId, phoneNumber, carrier, startDate, endDate };
+	async getAnalytics({ groupId, subgroupId, brandId, campaignId, phoneNumber, carrier, startDate, endDate, channel, matchAny, options = {} }) {
+		const filters = { groupId, subgroupId, brandId, campaignId, phoneNumber, carrier, startDate, endDate, channel, matchAny };
 		const queryString = this.client._getQueryString(filters);
 		return this.client(`/message/analytics${queryString}`, { method: "GET", ...options });
 	}
@@ -267,13 +273,17 @@ export class Messages {
 	 * @param {string[]} params.recipientPhoneNumbers - The phone number(s) to send the message to
 	 * @param {string} params.messageBody - The body of the P2P message
 	 * @param {string} [params.statusCallbackUrl] - The URL to receive status callbacks
+	 * @param {boolean} [params.useSignalHouseShortlinks] - When false, SignalHouse applies no link-shortening
+	 *   or text-spin and your pre-spun links/content are sent verbatim (bring-your-own spinner). Defaults to
+	 *   true server-side (the SignalHouse shortlink system, which mints unique per-recipient links).
 	 * @param {import('../SignalHouseSDK').RequestOptions} [params.options] - Additional options for the request
 	 * @returns {Promise<Object>} - A promise that resolves to the response data from the server
 	 */
-	async sendP2P({ recipientPhoneNumbers, messageBody, statusCallbackUrl, options = {} }) {
+	async sendP2P({ recipientPhoneNumbers, messageBody, statusCallbackUrl, useSignalHouseShortlinks, options = {} }) {
 		this.client._require({ recipientPhoneNumbers, messageBody });
 		const body = { recipientPhoneNumber: recipientPhoneNumbers, messageBody };
 		if (statusCallbackUrl) body.statusCallbackUrl = statusCallbackUrl;
+		if (typeof useSignalHouseShortlinks === "boolean") body.useSignalHouseShortlinks = useSignalHouseShortlinks;
 		return this.client(`/message/p2p`, {
 			method: "POST",
 			body,

package/src/domains/Numbers.js

@@ -134,15 +134,16 @@ export class Numbers {
 	/**
 	 * Read the outcome of a Toll-Free number purchase by the `orderId` returned from
 	 * {@link Numbers#purchaseTollFreeNumbers}. Reports per-number status as ready / provisioning / failed
-	 * counts (plus failure reasons) so a client can poll until the order reaches a terminal state. The
-	 * provisioned numbers themselves appear in the regular numbers list as they materialize.
+	 * counts (plus failure reasons) so a client can poll until the order reaches a terminal state, and
+	 * returns the provisioned phone numbers for the order so a client can act on exactly those numbers.
+	 * `numbers` is empty until each number is provisioned (it fills in as the order completes).
 	 * @async
 	 * @roles api, admin, developer, billing, user
 	 * @param {Object} params - The parameters for reading the order status
 	 * @param {string} params.orderId - The order id returned by `purchaseTollFreeNumbers`
 	 * @param {import('../SignalHouseSDK').RequestOptions} [params.options] - Additional options for the request
 	 * @throws {Error} Throws an error if the orderId parameter is missing
-	 * @returns {Promise<Object>} A promise that resolves to `{ orderId, counts: { ready, provisioning, failed }, failures: [{ reason }] }`.
+	 * @returns {Promise<Object>} A promise that resolves to `{ orderId, counts: { ready, provisioning, failed }, failures: [{ reason }], numbers: string[] }`.
 	 */
 	async getTollFreeOrderStatus({ orderId, options = {} }) {
 		this.client._require({ orderId });

package/src/domains/voice/browser/Call.js

@@ -141,6 +141,104 @@ export class Call {
 		}
 	}
 
+	/**
+	 * Mute or unmute the local microphone. Twilio-shape: pass `true` to mute,
+	 * `false` to unmute. Stops/resumes sending audio RTP at the media layer —
+	 * no SIP signaling, so it works regardless of server support.
+	 * @param {boolean} [shouldMute=true]
+	 */
+	mute(shouldMute = true) {
+		if (this.status !== "in_progress") {
+			console.warn(`[Call.mute] no-op: call is not in_progress (status=${this.status})`);
+			return;
+		}
+		try {
+			if (shouldMute) this._session.mute({ audio: true });
+			else this._session.unmute({ audio: true });
+		} catch (err) {
+			console.warn(`[Call.mute] threw: ${err?.message || err}`);
+		}
+	}
+
+	/** Unmute the local microphone. Convenience for `mute(false)`. */
+	unmute() {
+		this.mute(false);
+	}
+
+	/**
+	 * @returns {boolean} whether the local microphone is currently muted.
+	 */
+	isMuted() {
+		try {
+			return Boolean(this._session.isMuted?.()?.audio);
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Put the call on hold, or resume it. Sends a re-INVITE with the audio
+	 * direction set to sendonly (hold) / sendrecv (resume); the media server
+	 * (rtpengine) handles it. Pass `false` to resume.
+	 * @param {boolean} [shouldHold=true]
+	 * @returns {boolean} whether the (un)hold was initiated.
+	 */
+	hold(shouldHold = true) {
+		if (this.status !== "in_progress") {
+			console.warn(`[Call.hold] no-op: call is not in_progress (status=${this.status})`);
+			return false;
+		}
+		try {
+			return shouldHold ? this._session.hold() : this._session.unhold();
+		} catch (err) {
+			console.warn(`[Call.hold] threw: ${err?.message || err}`);
+			return false;
+		}
+	}
+
+	/** Resume a held call. Convenience for `hold(false)`. */
+	unhold() {
+		return this.hold(false);
+	}
+
+	/**
+	 * @returns {boolean} whether this leg is locally on hold.
+	 */
+	isOnHold() {
+		try {
+			return Boolean(this._session.isOnHold?.()?.local);
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Blind-transfer (cold transfer) the call to another destination via SIP
+	 * REFER. The far end is re-routed to `target` and this leg ends once the
+	 * transfer is accepted. `target` may be a phone number (E.164 or bare
+	 * digits) or a full SIP URI — bare numbers are normalized against the
+	 * registered SIP domain by the underlying stack.
+	 *
+	 * NOTE: completing the transfer requires the SIP server to honor the REFER
+	 * (route the new leg / bridge the parties). The client only initiates it.
+	 * @param {string} target - Destination number or SIP URI.
+	 */
+	transfer(target) {
+		if (this.status !== "in_progress") {
+			console.warn(`[Call.transfer] no-op: call is not in_progress (status=${this.status})`);
+			return;
+		}
+		if (!target) {
+			console.warn("[Call.transfer] no-op: a transfer target is required");
+			return;
+		}
+		try {
+			this._session.refer(target);
+		} catch (err) {
+			console.warn(`[Call.transfer] refer threw: ${err?.message || err}`);
+		}
+	}
+
 	/**
 	 * Attach an event listener. Events:
 	 *   "accepted"  — 200 OK received (outbound) or sent (inbound after accept)