@signalhousellc/sdk 1.0.53 → 1.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalhousellc/sdk",
-  "version": "1.0.53",
+  "version": "1.0.54",
   "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/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)