@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/customFieldsManager-CzWZTkW-.esm.js

@@ -0,0 +1,264 @@
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
+import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+import { t as isoDateToMs } from "./dateUtils-CvG0FvK8.esm.js";
+//#region src/modules/custom-fields/customFieldsServices.ts
+async function submitCustomFields(params, signal) {
+	const res = await api.post(endpoints.addCustomFields, params.fields, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.ts
+const REQUIRED_FIELD_ERROR = "dynamicForms.fieldRequired";
+function transformFields(fields, customFields) {
+	const result = {};
+	for (const [key, value] of Object.entries(fields)) if (customFields.find((f) => f.name === key)?.type === "DATE" && typeof value === "string" && value !== "") result[key] = isoDateToMs(value);
+	else result[key] = value;
+	return result;
+}
+function isFormComplete(fields, customFields) {
+	return customFields.every((field) => {
+		if (field.type === "BOOLEAN") return true;
+		const value = fields[field.name];
+		return value !== void 0 && value !== "";
+	});
+}
+function validateRequiredFields(fields, customFields) {
+	const errors = {};
+	for (const field of customFields) {
+		if (field.type === "BOOLEAN") continue;
+		const value = fields[field.name];
+		if (value === void 0 || value === "") errors[field.name] = REQUIRED_FIELD_ERROR;
+	}
+	return Object.keys(errors).length > 0 ? errors : void 0;
+}
+const customFieldsMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitFields: fromPromise(async ({ input, signal }) => {
+		return submitCustomFields({ fields: transformFields(input.fields, input.customFields) }, signal);
+	}) },
+	actions: {
+		setField: assign(({ context, event }) => {
+			const e = event;
+			const validationErrors = { ...context.validationErrors };
+			delete validationErrors[e.name];
+			return {
+				fields: {
+					...context.fields,
+					[e.name]: e.value
+				},
+				validationErrors: Object.keys(validationErrors).length > 0 ? validationErrors : void 0
+			};
+		}),
+		setValidationErrors: assign(({ context }) => ({ validationErrors: validateRequiredFields(context.fields, context.config.customFields) })),
+		markSuccess: assign({ result: "success" }),
+		markFailed: assign({ result: "failed" })
+	},
+	guards: {
+		apiSucceeded: ({ event }) => event.output.success,
+		isFormComplete: ({ context }) => isFormComplete(context.fields, context.config.customFields)
+	}
+}).createMachine({
+	id: "customFields",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		fields: {},
+		validationErrors: void 0,
+		result: null
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "inputting" } } },
+		inputting: { on: {
+			FIELD_CHANGED: { actions: "setField" },
+			SUBMIT: [{
+				guard: "isFormComplete",
+				target: "submitting"
+			}, { actions: "setValidationErrors" }]
+		} },
+		submitting: { invoke: {
+			id: "submitFields",
+			src: "submitFields",
+			input: ({ context }) => ({
+				fields: context.fields,
+				customFields: context.config.customFields
+			}),
+			onDone: [{
+				target: "success",
+				guard: "apiSucceeded"
+			}, {
+				target: "finished",
+				actions: "markFailed"
+			}],
+			onError: {
+				target: "finished",
+				actions: "markFailed"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.ts
+function createCustomFieldsActor(options) {
+	return createActor(customFieldsMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.ts
+/**
+* Maps a custom-fields state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Returned strings are the Figma-verbatim absolute
+* analytics path emitted as-is on `event.screen` by
+* `createManagerInstrumentation`'s `getEventScreenName` path. See
+* `docs/patterns/INSTRUMENTATION.md`.
+*
+* Source of truth: Custom Fields Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/Fb4Jp6kal8clAD05Kh6l4e/Custom-fields---Latest-Design?node-id=2026-30075`).
+* The canvas mixes two casings — sections name the input surfaces
+* `Customfield.{empty,filled}` (capital `C`) and the post-input surfaces
+* `customfield.{processing,complete}` (lowercase `c`). Both spellings are
+* preserved verbatim as Figma is the source of truth.
+*
+* State → screen mapping rationale:
+*
+* - `idle`/`inputting` collapse to `Customfield.empty` — the SM stays in
+*   `inputting` throughout typing (field-level `FIELD_CHANGED` events are
+*   context-only and don't fire a new `screenOpened`). The Figma
+*   `Customfield.filled` surface is therefore a UI sub-state of `inputting`,
+*   not a discrete SM state, and collapses onto the section's primary
+*   `Customfield.empty` screen.
+* - `submitting` → `customfield.processing` — submit in-flight.
+* - `success` → `customfield.complete` — happy-path success surface (auto-
+*   advances to `finished` after 3 s).
+* - `finished` is intentionally unmapped: it is dual-outcome (success or
+*   failed — failures route here with `result: 'failed'` since the machine
+*   has no `error` state) and Figma defines no failure screen. Mapping
+*   `finished` onto `customfield.complete` would mis-report failures, so the
+*   adapter falls back to the generic `<module>.finished` default.
+*/
+function getCustomFieldsScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "idle":
+		case "inputting": return "Customfield.empty";
+		case "submitting": return "customfield.processing";
+		case "success": return "customfield.complete";
+		default: return;
+	}
+}
+function toDisplayLabel(field) {
+	if (field.alias) return field.alias;
+	return field.name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("inputting")) return {
+		status: "inputting",
+		title: context.config.title,
+		customFields: context.config.customFields.map((f) => ({
+			...f,
+			label: toDisplayLabel(f)
+		})),
+		validationErrors: context.validationErrors,
+		canSubmit: Object.keys(context.validationErrors ?? {}).length === 0
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.config.title
+	};
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	return {
+		status: "finished",
+		result: typedSnapshot.context.result
+	};
+}
+function createApi({ actor }) {
+	return {
+		/**
+		* Initializes the custom fields flow.
+		* Transitions from 'idle' to 'inputting'.
+		* Must be called before any other method.
+		*/
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		/**
+		* Updates the value of a single field.
+		* Should be called when state is 'inputting'.
+		*
+		* @param name - The field name (matches CustomField.name)
+		* @param value - The field value (string, number, or boolean)
+		*/
+		setField(name, value) {
+			actor.send({
+				type: "FIELD_CHANGED",
+				name,
+				value
+			});
+		},
+		/**
+		* Submits all custom field values to the backend.
+		* Transitions to 'submitting', then 'finished' regardless of outcome.
+		*/
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		}
+	};
+}
+/**
+* Creates a custom fields manager for headless or UI-driven usage.
+*
+* @param options - Configuration options
+* @param options.config - Custom fields configuration (title + field definitions)
+*
+* @returns Custom fields manager with state, API methods, and subscription
+*
+* @example Headless usage
+* ```typescript
+* const manager = createCustomFieldsManager({
+*   config: {
+*     title: 'Additional Information',
+*     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+*   },
+* });
+*
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* manager.setField('company', 'Incode');
+* manager.submit();
+* manager.stop();
+* ```
+*/
+function createCustomFieldsManager(options) {
+	return createManager({
+		actor: createCustomFieldsActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
+	});
+}
+function createCustomFieldsManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
+	});
+}
+//#endregion
+export { createCustomFieldsManagerFromActor as n, customFieldsMachine as r, createCustomFieldsManager as t };

package/dist/customWatchlistManager-DWTED5Ur.esm.js

@@ -0,0 +1,73 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { t as customWatchlistMachine } from "./customWatchlistStateMachine-DOQou6TW.esm.js";
+//#region src/modules/custom-watchlist/customWatchlistActor.ts
+function createCustomWatchlistActor() {
+	return createActor(customWatchlistMachine).start();
+}
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistManager.ts
+/**
+* Maps a Custom Watchlist state-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: Watchlist | Custom Watchlist
+* Figma file (`https://www.figma.com/design/Xm4BgXotNwdi5iRdHTIX0N/Watchlist-%7C-Custom-Watchlist----Latest-Design?node-id=3031-82920`).
+* Family is `watchlist.*`, shared with the global watchlist manager — both
+* keep their own module token (`watchlist` vs `customWatchlist`) per the
+* AdSign/QSign precedent.
+*
+* `idle` and `finished` are intentionally unmapped — the Figma canvas does
+* not define screens for them; `finished` collapses into `moduleClosed`.
+*/
+function getCustomWatchlistScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "processing": return "watchlist.processing";
+		case "success": return "watchlist.success";
+		default: return;
+	}
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: typedSnapshot.context.result ?? "skipped"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { 
+	/**
+	* Kicks off the custom watchlist check.
+	* Transitions from 'idle' to 'processing'.
+	*/
+load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+/**
+* Creates a custom watchlist manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createCustomWatchlistManager();
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* ```
+*/
+function createCustomWatchlistManager() {
+	return createCustomWatchlistManagerFromActor(createCustomWatchlistActor());
+}
+function createCustomWatchlistManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.customWatchList, { getEventScreenName: getCustomWatchlistScreenName })
+	});
+}
+//#endregion
+export { createCustomWatchlistManagerFromActor as n, createCustomWatchlistManager as t };

package/dist/customWatchlistManager-PBWHr_oM.d.ts

@@ -0,0 +1,64 @@
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/custom-watchlist/customWatchlistStateMachine.d.ts
+type CustomWatchlistResult = 'success' | 'skipped';
+declare const customWatchlistMachine: any;
+type CustomWatchlistMachine = typeof customWatchlistMachine;
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistActor.d.ts
+type CustomWatchlistActor = ActorRefFrom<CustomWatchlistMachine>;
+//#endregion
+//#region src/modules/custom-watchlist/customWatchlistManager.d.ts
+type CustomWatchlistIdleState = {
+  status: 'idle';
+};
+type CustomWatchlistProcessingState = {
+  status: 'processing';
+};
+type CustomWatchlistSuccessState = {
+  status: 'success';
+};
+type CustomWatchlistFinishedState = {
+  status: 'finished';
+  result: CustomWatchlistResult;
+};
+/**
+ * Union of all possible custom watchlist manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = customWatchlistManager.getState();
+ * if (state.status === 'finished') {
+ *   console.log('Custom watchlist check complete');
+ * }
+ * ```
+ */
+type CustomWatchlistState = CustomWatchlistIdleState | CustomWatchlistProcessingState | CustomWatchlistSuccessState | CustomWatchlistFinishedState;
+/**
+ * Creates a custom watchlist manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createCustomWatchlistManager();
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * ```
+ */
+declare function createCustomWatchlistManager(): Manager<CustomWatchlistState> & {
+  /**
+   * Kicks off the custom watchlist check.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+declare function createCustomWatchlistManagerFromActor(actor: CustomWatchlistActor): Manager<CustomWatchlistState> & {
+  /**
+   * Kicks off the custom watchlist check.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+type CustomWatchlistManager = ReturnType<typeof createCustomWatchlistManager>;
+//#endregion
+export { CustomWatchlistActor as a, createCustomWatchlistManagerFromActor as i, CustomWatchlistState as n, customWatchlistMachine as o, createCustomWatchlistManager as r, CustomWatchlistManager as t };

package/dist/{customWatchlistStateMachine-YWSgKLbF.esm.js → customWatchlistStateMachine-DOQou6TW.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 //#region src/modules/custom-watchlist/customWatchlistServices.ts

package/dist/{deepsightLoader--wMKWECS.esm.js → deepsightLoader-DDv3vhXU.esm.js}

@@ -1,17 +1,15 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { l as trueSightLog } from "./trueSightService---iW2KKJ.esm.js";
-import { g as getThumbmarkId, h as IpifyProvider, n as getFingerprintEnabled, p as isBrowserSimulation, t as getDisableIpify, v as BrowserEnvironmentProvider } from "./sessionInitializer-dlfDehHk.esm.js";
-import "./trueSight-B_icM8r2.esm.js";
-import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
-import { t as getParsedUserAgent } from "./getParsedUserAgent-pJjATANs.esm.js";
-import { t as getUserAgent } from "./getBrowser-Cb8Zgrgp.esm.js";
-import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-BqUCwLY8.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-DGiV77J_.esm.js";
-import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { l as trueSightLog } from "./trueSightService-BN-Hzw82.esm.js";
+import { _ as IpifyProvider, b as BrowserEnvironmentProvider, h as isBrowserSimulation, n as getFingerprintEnabled, t as getDisableIpify, v as getThumbmarkId } from "./sessionInitializer-BFk33E67.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-BZh6dj53.esm.js";
+import { t as getParsedUserAgent } from "./getParsedUserAgent-B2iFDql1.esm.js";
+import { t as getUserAgent } from "./getBrowser-CBiibsL-.esm.js";
+import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-B2e8p268.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-BgTYwg9L.esm.js";
+import { i as requestCameraAccess, o as stopCameraStream } from "./camera-sIa9ceW2.esm.js";
 import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
 import { t as getDeviceInfo } from "./getDeviceClass-CeBiEayS.esm.js";
+import { n as runVirtualCameraCheck } from "./virtualCameraCheck-Cjab7FTI.esm.js";
 //#region src/internal/deepsight/metadataService.ts
 function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
 	return {
@@ -134,49 +132,17 @@ function createMotionStatusService(motionSensor) {
 	};
 }
 //#endregion
-//#region src/internal/virtualCameraCheck.ts
-/**
-* Sends the analyzed frame image to the backend for logging.
-*/
-async function logFrame({ source, base64Image, token }) {
-	try {
-		return (await api.post("/omni/log/frame/v2", { base64Image }, {
-			query: { source },
-			headers: { "X-Incode-Hardware-Id": token }
-		})).data;
-	} catch {
-		return;
-	}
-}
-/**
-* Runs the WASM virtual camera check and handles logging and stats.
-*/
-async function runVirtualCameraCheck({ wasmUtil, source, token }) {
-	const output = {
-		canvas: null,
-		itr: null,
-		skipped: null
-	};
-	await wasmUtil.poc(output);
-	if (output.skipped !== false) return;
-	if (output.canvas && token) {
-		const base64Image = new IncodeCanvas(output.canvas).getBase64Image();
-		if (base64Image) await logFrame({
-			source,
-			base64Image,
-			token
-		});
-	}
-	if (output.itr === true) {
-		addDeviceStats({ virtualCameraDetected: true });
-		wasmUtil.setZc("FAIL");
-	} else if (output.itr === false) wasmUtil.setZc("PASS");
-}
-//#endregion
 //#region src/internal/deepsight/deepsightService.ts
 function createDeepsightService(config) {
 	const metadata = createMetadataService(config.wasmUtil, config.visibility, config.browserEnv, config.ipLookup);
 	const motion = createMotionStatusService(config.motionSensor);
+	const finalizeCaptureMetadata = () => {
+		metadata.preparePipelineState();
+		const motionStatus = motion.check();
+		metadata.setMotionStatus(motionStatus);
+		metadata.getCheck();
+		metadata.setBackgroundMode(false);
+	};
 	return {
 		metadata,
 		motion,
@@ -190,10 +156,6 @@ function createDeepsightService(config) {
 		async startMotionSensors() {
 			await motion.start();
 		},
-		async primeWasmMotionSensor() {
-			await config.wasmUtil.rsp();
-			config.wasmUtil.ssl();
-		},
 		stopMotionSensors() {
 			motion.stop();
 		},
@@ -221,11 +183,11 @@ function createDeepsightService(config) {
 		async analyzeFrame(imageData) {
 			await motion.start();
 			await metadata.analyzeFrame(imageData);
-			metadata.preparePipelineState();
-			const motionStatus = motion.check();
-			metadata.setMotionStatus(motionStatus);
-			metadata.getCheck();
-			metadata.setBackgroundMode(false);
+			finalizeCaptureMetadata();
+		},
+		async finalizeProtectedCaptureMetadata() {
+			await motion.start();
+			finalizeCaptureMetadata();
 		},
 		getMetadata() {
 			return metadata.getMetadata();
@@ -267,7 +229,6 @@ var VisibilityProvider = class {
 };
 //#endregion
 //#region src/internal/deepsight/deepsightLoader.ts
-const SDK_VERSION = "2.0.0";
 async function loadDeepsightSession(options) {
 	try {
 		return await loadDeepsightSessionInternal(options);
@@ -278,18 +239,13 @@ async function loadDeepsightSession(options) {
 }
 async function loadDeepsightSessionInternal(options) {
 	setWasmDsFlagSync(options.ds === true);
-	const wasmUtil = await WasmUtilProvider.getInstance();
-	const visibility = new VisibilityProvider();
-	const browserEnv = new BrowserEnvironmentProvider();
-	const motionSensor = new MotionSensorProvider();
-	const ipLookup = new IpifyProvider();
 	const service = createDeepsightService({
 		sdkVersion: SDK_VERSION,
-		wasmUtil,
-		visibility,
-		browserEnv,
-		motionSensor,
-		ipLookup
+		wasmUtil: await WasmUtilProvider.getInstance(),
+		visibility: new VisibilityProvider(),
+		browserEnv: new BrowserEnvironmentProvider(),
+		motionSensor: new MotionSensorProvider(),
+		ipLookup: new IpifyProvider()
 	});
 	const disableIpify = options.disableIpify ?? getDisableIpify();
 	const disableFingerprint = options.disableFingerprint ?? !getFingerprintEnabled();

package/dist/device.d.ts

@@ -27,9 +27,32 @@ declare class ScreenOrientationProvider implements IScreenOrientationCapability
 }
 //#endregion
 //#region src/internal/device/getBrowser.d.ts
-type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera' | 'other' | 'samsung_browser';
+type Browser = 'chrome' | 'firefox' | 'safari' | 'edge' | 'opera' | 'other' | 'samsung_browser' | 'miui_browser';
 declare function getBrowser(): Browser;
 //#endregion
+//#region src/internal/device/browserSupportClassification.d.ts
+/** iOS/iPadOS/macOS — the only platforms where Safari is a supported option. */
+declare function isApplePlatform(): boolean;
+/**
+ * Whether capture/WASM are known to work in the current browser.
+ *
+ * Native Android and iOS WebViews are supported; third-party in-app browsers
+ * are not, on either platform. Outside a WebView, only Chrome is supported on
+ * every platform and Safari is supported on Apple platforms.
+ *
+ * The rejections run first, because a browser that is unsupported on its own is
+ * still unsupported when it hosts the page as a WebView (ENG-51674).
+ *
+ * Identity comes from the user agent, plus `navigator.brave`/`navigator.island`
+ * and Client Hint brands where available. `navigator.island` is load-bearing:
+ * Island can be configured (or itself strip) the "Island Browser" UA token and
+ * still report Chrome-only Client Hint brands, so the UA and brands alone are
+ * not sufficient (ENG-51674). A browser that spoofs a Chrome user agent, exposes
+ * no Client Hints, and identifies itself nowhere else cannot be distinguished
+ * here.
+ */
+declare function isSupportedBrowser(): boolean;
+//#endregion
 //#region src/internal/device/getDeviceClass.d.ts
 type DeviceClass = 'ios' | 'android' | 'desktop';
 declare function getDeviceClass(): DeviceClass;
@@ -51,4 +74,4 @@ type ScreenOrientationObserver = {
 };
 declare function createScreenOrientationObserver(provider: IScreenOrientationCapability, deviceClass: DeviceClass): ScreenOrientationObserver;
 //#endregion
-export { type Browser, type DeviceClass, type ScreenOrientationObserver, ScreenOrientationProvider, createScreenOrientationObserver, getBrowser, getDeviceClass, isDesktopDeviceEmulation, isDesktopOrEmulated, isIPad };
+export { type Browser, type DeviceClass, type ScreenOrientationObserver, ScreenOrientationProvider, createScreenOrientationObserver, getBrowser, getDeviceClass, isApplePlatform, isDesktopDeviceEmulation, isDesktopOrEmulated, isIPad, isSupportedBrowser };