@incodetech/core 0.0.0-dev-20260407-2c382da → 0.0.0-dev-20260407-ebd92aa

package/dist/MotionSensorProvider-BTDLt08l.esm.js

@@ -0,0 +1,254 @@
+//#region ../infra/src/providers/browser/MotionSensorProvider.ts
+var MotionSensorProvider = class {
+	constructor(thresholds) {
+		this._isRunning = false;
+		this._hasPermission = true;
+		this.acl = null;
+		this.gyro = null;
+		this.minNumberOfFrames = 3;
+		this.maxFrequency = 60;
+		this.emptyParams = {
+			meanX: 0,
+			meanY: 0,
+			meanZ: 0,
+			m2X: 0,
+			m2Y: 0,
+			m2Z: 0,
+			cumulativeAbsErrorX: 0,
+			cumulativeAbsErrorY: 0,
+			cumulativeAbsErrorZ: 0,
+			ptsNum: 0
+		};
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+		this.deviceMotionListener = (event) => {
+			if (event.accelerationIncludingGravity) {
+				const accGrVal = {
+					x: event.accelerationIncludingGravity.x,
+					y: event.accelerationIncludingGravity.y,
+					z: event.accelerationIncludingGravity.z
+				};
+				if (this.checkFields(accGrVal)) {
+					this.paramsAccGrOld.ptsNum += 1;
+					this.updateParams(this.paramsAccGrOld, accGrVal);
+				}
+			}
+			if (event.acceleration) {
+				const accVal = {
+					x: event.acceleration.x,
+					y: event.acceleration.y,
+					z: event.acceleration.z
+				};
+				if (this.checkFields(accVal)) {
+					this.paramsAccOld.ptsNum += 1;
+					this.updateParams(this.paramsAccOld, accVal);
+				}
+			}
+			if (event.rotationRate) {
+				const gyroVal = {
+					x: event.rotationRate.alpha,
+					y: event.rotationRate.beta,
+					z: event.rotationRate.gamma
+				};
+				if (this.checkFields(gyroVal)) {
+					this.paramsGyroscopeOld.ptsNum += 1;
+					this.updateParams(this.paramsGyroscopeOld, gyroVal);
+				}
+			}
+		};
+		this.deviceOrientationListener = (event) => {
+			const orientationVal = {
+				x: event.alpha,
+				y: event.beta,
+				z: event.gamma
+			};
+			if (this.checkFields(orientationVal)) {
+				this.paramsOrientationOld.ptsNum += 1;
+				this.updateParams(this.paramsOrientationOld, orientationVal);
+			}
+		};
+		this.thresholds = {
+			accThreshold: thresholds?.accThreshold ?? .3,
+			gyroThreshold: thresholds?.gyroThreshold ?? .3,
+			accGrOldThreshold: thresholds?.accGrOldThreshold ?? .3,
+			accOldThreshold: thresholds?.accOldThreshold ?? .3,
+			gyroscopeOldThreshold: thresholds?.gyroscopeOldThreshold ?? 10,
+			orientationOldThreshold: thresholds?.orientationOldThreshold ?? 10,
+			maeAccThreshold: thresholds?.maeAccThreshold ?? .3,
+			maeGyroThreshold: thresholds?.maeGyroThreshold ?? .3,
+			maeAccGrOldThreshold: thresholds?.maeAccGrOldThreshold ?? .3,
+			maeAccOldThreshold: thresholds?.maeAccOldThreshold ?? .3,
+			maeGyroscopeOldThreshold: thresholds?.maeGyroscopeOldThreshold ?? 10,
+			maeOrientationOldThreshold: thresholds?.maeOrientationOldThreshold ?? 10
+		};
+	}
+	get isRunning() {
+		return this._isRunning;
+	}
+	get hasPermission() {
+		return this._hasPermission;
+	}
+	async requestPermission() {
+		if (typeof DeviceMotionEvent !== "undefined" && typeof DeviceMotionEvent.requestPermission === "function") {
+			sessionStorage.setItem("motionSensorsPermissionsRequested", String(true));
+			try {
+				if (await DeviceMotionEvent.requestPermission() !== "granted") {
+					this._hasPermission = false;
+					return "denied";
+				}
+				return "granted";
+			} catch {
+				this._hasPermission = false;
+				return "denied";
+			}
+		}
+		return "not-required";
+	}
+	initializeAccelerometer() {
+		if (!("Accelerometer" in window)) return;
+		try {
+			const AccelerometerConstructor = window.Accelerometer;
+			if (AccelerometerConstructor) {
+				this.acl = new AccelerometerConstructor({ frequency: this.maxFrequency });
+				this.acl.addEventListener("reading", () => this.updateAcc());
+			}
+		} catch {}
+	}
+	initializeGyroscope() {
+		if (!("Gyroscope" in window)) return;
+		try {
+			const GyroscopeConstructor = window.Gyroscope;
+			if (GyroscopeConstructor) {
+				this.gyro = new GyroscopeConstructor({ frequency: this.maxFrequency });
+				this.gyro.addEventListener("reading", () => this.updateGyro());
+			}
+		} catch {}
+	}
+	async start() {
+		if (this._isRunning || !this._hasPermission) return;
+		try {
+			this.initializeAccelerometer();
+			if (this.acl) this.acl.start();
+		} catch {}
+		try {
+			this.initializeGyroscope();
+			if (this.gyro) this.gyro.start();
+		} catch {}
+		window.addEventListener("devicemotion", this.deviceMotionListener);
+		window.addEventListener("deviceorientation", this.deviceOrientationListener);
+		this._isRunning = true;
+	}
+	stop() {
+		this._isRunning = false;
+		if (this.acl) this.acl.stop();
+		if (this.gyro) this.gyro.stop();
+		window.removeEventListener("devicemotion", this.deviceMotionListener);
+		window.removeEventListener("deviceorientation", this.deviceOrientationListener);
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+	}
+	updateAcc() {
+		if (!this._isRunning || !this.acl) return;
+		this.paramsAcc.ptsNum += 1;
+		const val = {
+			x: this.acl.x,
+			y: this.acl.y,
+			z: this.acl.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsAcc, val);
+	}
+	updateGyro() {
+		if (!this._isRunning || !this.gyro) return;
+		this.paramsGyro.ptsNum += 1;
+		const val = {
+			x: this.gyro.x,
+			y: this.gyro.y,
+			z: this.gyro.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsGyro, val);
+	}
+	check() {
+		if (!this._hasPermission) return "UNCLEAR";
+		const result = this.checkStability();
+		return result === null ? "UNCLEAR" : result ? "FAIL" : "PASS";
+	}
+	checkStability() {
+		if (!this._isRunning) return null;
+		const filteredStdChecks = [
+			this.gyro ? this.isBelowStdThreshold(this.paramsGyro, this.thresholds.gyroThreshold) : null,
+			this.acl ? this.isBelowStdThreshold(this.paramsAcc, this.thresholds.accThreshold) : null,
+			this.isBelowStdThreshold(this.paramsAccGrOld, this.thresholds.accGrOldThreshold),
+			this.isBelowStdThreshold(this.paramsAccOld, this.thresholds.accOldThreshold),
+			this.isBelowStdThreshold(this.paramsGyroscopeOld, this.thresholds.gyroscopeOldThreshold),
+			this.isBelowStdThreshold(this.paramsOrientationOld, this.thresholds.orientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalStdCheck = filteredStdChecks.length > 0 ? filteredStdChecks.every((check) => check) : null;
+		const filteredMaeChecks = [
+			this.gyro ? this.isBelowMaeThreshold(this.paramsGyro, this.thresholds.maeGyroThreshold) : null,
+			this.acl ? this.isBelowMaeThreshold(this.paramsAcc, this.thresholds.maeAccThreshold) : null,
+			this.isBelowMaeThreshold(this.paramsAccGrOld, this.thresholds.maeAccGrOldThreshold),
+			this.isBelowMaeThreshold(this.paramsAccOld, this.thresholds.maeAccOldThreshold),
+			this.isBelowMaeThreshold(this.paramsGyroscopeOld, this.thresholds.maeGyroscopeOldThreshold),
+			this.isBelowMaeThreshold(this.paramsOrientationOld, this.thresholds.maeOrientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalMaeCheck = filteredMaeChecks.length > 0 ? filteredMaeChecks.every((check) => check) : null;
+		return finalStdCheck === null ? finalMaeCheck === null ? null : finalMaeCheck : finalMaeCheck !== null ? finalStdCheck && finalMaeCheck : finalStdCheck;
+	}
+	updateParams(params, val) {
+		const deltaX = val.x - params.meanX;
+		const deltaY = val.y - params.meanY;
+		const deltaZ = val.z - params.meanZ;
+		params.meanX += deltaX / params.ptsNum;
+		params.meanY += deltaY / params.ptsNum;
+		params.meanZ += deltaZ / params.ptsNum;
+		params.m2X += deltaX * (val.x - params.meanX);
+		params.m2Y += deltaY * (val.y - params.meanY);
+		params.m2Z += deltaZ * (val.z - params.meanZ);
+		params.cumulativeAbsErrorX += Math.abs(val.x - params.meanX);
+		params.cumulativeAbsErrorY += Math.abs(val.y - params.meanY);
+		params.cumulativeAbsErrorZ += Math.abs(val.z - params.meanZ);
+	}
+	calculateStd(params) {
+		const variance = {
+			x: params.m2X / params.ptsNum,
+			y: params.m2Y / params.ptsNum,
+			z: params.m2Z / params.ptsNum
+		};
+		return {
+			x: Math.sqrt(variance.x),
+			y: Math.sqrt(variance.y),
+			z: Math.sqrt(variance.z)
+		};
+	}
+	calculateMae(params) {
+		return {
+			x: params.cumulativeAbsErrorX / params.ptsNum,
+			y: params.cumulativeAbsErrorY / params.ptsNum,
+			z: params.cumulativeAbsErrorZ / params.ptsNum
+		};
+	}
+	checkFields(point) {
+		return point.x !== null && point.y !== null && point.z !== null;
+	}
+	isBelowStdThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const std = this.calculateStd(params);
+		return std.x < threshold && std.y < threshold && std.z < threshold;
+	}
+	isBelowMaeThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const mae = this.calculateMae(params);
+		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
+	}
+};
+
+//#endregion
+export { MotionSensorProvider as t };

package/dist/OpenViduRecordingProvider-PvkEhhDq.esm.js

@@ -0,0 +1,87 @@
+import { t as loadOpenVidu } from "./openviduLazy-BdsxPGgp.esm.js";
+
+//#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
+function createHiddenContainer() {
+	const id = `inc_rec_${Math.random().toString(36).slice(2)}`;
+	const existing = document.getElementById(id);
+	if (existing) return {
+		id,
+		element: existing
+	};
+	const div = document.createElement("div");
+	div.id = id;
+	div.style.display = "none";
+	document.body.appendChild(div);
+	return {
+		id,
+		element: div
+	};
+}
+var OpenViduRecordingProvider = class {
+	async connect(params) {
+		const { OpenVidu } = await loadOpenVidu();
+		const container = createHiddenContainer();
+		const ov = new OpenVidu();
+		const session = ov.initSession();
+		const videoTrack = params.stream.getVideoTracks()[0];
+		const audioTrack = params.stream.getAudioTracks()[0];
+		const hasAudio = audioTrack !== void 0;
+		const publisher = ov.initPublisher(container.id, {
+			publishAudio: hasAudio,
+			audioSource: hasAudio ? audioTrack : false,
+			videoSource: videoTrack ?? false,
+			frameRate: 30
+		});
+		session.on("exception", (event) => {
+			const e = event;
+			params.events?.onSessionException?.({
+				name: e?.name,
+				message: e?.message,
+				sessionId: session.sessionId
+			});
+		});
+		publisher.on("streamCreated", () => {
+			params.events?.onPublisherCreated?.({
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+		});
+		await session.connect(params.sessionToken);
+		params.events?.onSessionConnected?.(session.sessionId);
+		try {
+			await session.publish(publisher);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			params.events?.onPublisherError?.({
+				message,
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+			throw error;
+		}
+		return {
+			sessionId: session.sessionId,
+			publisher: {
+				getStreamId: () => publisher.stream?.streamId,
+				replaceVideoTrack: async (track) => {
+					await publisher.replaceTrack(track);
+				},
+				destroy: () => {}
+			},
+			disconnect: async () => {
+				try {
+					session.disconnect();
+					params.stream.getTracks().forEach((t) => {
+						t.stop();
+					});
+				} finally {
+					params.events?.onSessionDisconnected?.(session.sessionId);
+					if (container.element.parentNode) container.element.parentNode.removeChild(container.element);
+				}
+			}
+		};
+	}
+};
+
+//#endregion
+export { OpenViduRecordingProvider };

package/dist/StateMachine-DU1S4Cik.d.ts

@@ -0,0 +1,2 @@
+import { AnyStateMachine, StateMachine, fromPromise } from "xstate";
+export { StateMachine as n, fromPromise as r, AnyStateMachine as t };

package/dist/{WasmUtilProvider-BonqBWdj.esm.js → WasmUtilProvider-C45HStLj.esm.js}

@@ -1,4 +1,4 @@
-import { l as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider--AzPfwOm.esm.js";
+import { r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-CQgeReKV.esm.js";
 
 //#region ../infra/src/providers/wasm/WasmUtilProvider.ts
 var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {

package/dist/{addressSearch-B8Fo4v9V.esm.js → addressSearch-C5qzDvkN.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { x as fromCallback } from "./Manager-C6AGXEq_.esm.js";
-import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CIqH6hJp.esm.js";
+import { t as api } from "./api-CyI8qTie.esm.js";
+import { _ as endpoints } from "./events-BlVGS-8F.esm.js";
+import { r as fromCallback } from "./xstate.esm-BXrcOcSC.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CkHEwJFa.esm.js";
 
 //#region src/shared/usStates.ts
 const usStates = {

package/dist/antifraud.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-CCT_-HuZ.js";
+import { t as Manager } from "./Manager-N01KfnVA.js";
 
 //#region src/modules/antifraud/antifraudManager.d.ts
 type AntifraudIdleState = {

package/dist/antifraud.esm.js

@@ -1,6 +1,6 @@
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { C as createActor, S as fromPromise, r as eventModuleNames, s as createManagerInstrumentation, t as createManager, y as setup } from "./Manager-C6AGXEq_.esm.js";
-import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
+import { t as api } from "./api-CyI8qTie.esm.js";
+import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-BlVGS-8F.esm.js";
+import { a as createActor, i as fromPromise, o as createManager, t as setup } from "./xstate.esm-BXrcOcSC.esm.js";
 
 //#region src/modules/antifraud/antifraudServices.ts
 async function processAntifraud(signal) {

package/dist/authentication.d.ts

@@ -1,10 +1,12 @@
-import "./StateMachine-CM_aOfNL.js";
-import "./Actor-By8WNHi-.js";
-import "./deepsightService-Ciu0atv5.js";
-import "./camera-6XJdOeBF.js";
-import "./types-CiLyvJGb.js";
-import "./types-D8Y1faI5.js";
-import "./Manager-CCT_-HuZ.js";
-import { _ as AuthenticationConfig, b as authenticationMachine, g as createAuthenticationActor, h as CreateAuthenticationActorOptions, m as AuthenticationActor } from "./faceCaptureManagerFactory-CdwpYykv.js";
-import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-Bd10YGSO.js";
+import "./warmup-yzJJKXFi.js";
+import "./Manager-N01KfnVA.js";
+import "./Actor-Cz_KnN47.js";
+import "./StateMachine-DU1S4Cik.js";
+import { _ as AuthenticationConfig, b as authenticationMachine, g as createAuthenticationActor, h as CreateAuthenticationActorOptions, m as AuthenticationActor } from "./faceCaptureManagerFactory-Bp_mC9b2.js";
+import "./camera-BcVDCZxW.js";
+import "./types-DcqFYowa.js";
+import "./types-DufUK-_f.js";
+import "./deepsightService-CyEcAH-I.js";
+import "./types-UPqCMQKa.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-CXTPgE_2.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -1,15 +1,20 @@
-import "./platform-DdhkonXk.esm.js";
-import "./BaseWasmProvider--AzPfwOm.esm.js";
-import "./StreamCanvasCapture-DkpkIgyL.esm.js";
-import "./browserSimulation-DYAk0Ipe.esm.js";
-import "./api-C2uzxrpN.esm.js";
-import "./Manager-C6AGXEq_.esm.js";
-import "./endpoints-CI5-28jT.esm.js";
-import "./camera-DAuRUvnp.esm.js";
-import "./stats-BVigf5Rn.esm.js";
-import "./backCameraStream-DF_d7hTz.esm.js";
-import "./WasmUtilProvider-BonqBWdj.esm.js";
-import "./faceCaptureSetup-DbXgtcp7.esm.js";
-import { i as authenticationMachine, r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-B4gSCgrO.esm.js";
+import "./BaseWasmProvider-CQgeReKV.esm.js";
+import "./WasmUtilProvider-C45HStLj.esm.js";
+import "./api-CyI8qTie.esm.js";
+import "./events-BlVGS-8F.esm.js";
+import "./browserSimulation-yzDdWSBf.esm.js";
+import "./xstate.esm-BXrcOcSC.esm.js";
+import "./faceCaptureSetup-DzlTPjT9.esm.js";
+import "./recordingService-BDx_6XR9.esm.js";
+import "./deepsightService-C3gQ_9Ml.esm.js";
+import "./camera-CsT06Zqy.esm.js";
+import "./getBrowser-B800KRAi.esm.js";
+import "./stats-BZ1kFW4p.esm.js";
+import "./MotionSensorProvider-BTDLt08l.esm.js";
+import "./permissionServices-CDqkkway.esm.js";
+import "./platform-Dcuv6w60.esm.js";
+import "./backCameraStream-CUo1USCT.esm.js";
+import "./getDeviceClass-BKd2FOAf.esm.js";
+import { i as authenticationMachine, r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-D4esVx-z.esm.js";
 
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-Bd10YGSO.d.ts → authenticationManager-CXTPgE_2.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-CCT_-HuZ.js";
-import { h as CreateAuthenticationActorOptions, m as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CdwpYykv.js";
+import { t as Manager } from "./Manager-N01KfnVA.js";
+import { h as CreateAuthenticationActorOptions, m as AuthenticationActor, n as FaceCaptureManagerState, t as FaceCaptureManager } from "./faceCaptureManagerFactory-Bp_mC9b2.js";
 
 //#region src/modules/authentication/authenticationManager.d.ts
 type AuthenticationState = FaceCaptureManagerState;

package/dist/{authenticationManager-B4gSCgrO.esm.js → authenticationManager-D4esVx-z.esm.js}

@@ -1,9 +1,10 @@
-import { f as BrowserStorageProvider, p as getDeviceClass } from "./StreamCanvasCapture-DkpkIgyL.esm.js";
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { C as createActor, S as fromPromise, b as assign, r as eventModuleNames } from "./Manager-C6AGXEq_.esm.js";
-import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-BonqBWdj.esm.js";
-import { a as createFaceCaptureManagerFromActor, i as FACE_ERROR_CODES, t as faceCaptureMachine } from "./faceCaptureSetup-DbXgtcp7.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-C45HStLj.esm.js";
+import { t as api } from "./api-CyI8qTie.esm.js";
+import { _ as endpoints, n as eventModuleNames } from "./events-BlVGS-8F.esm.js";
+import { a as createActor, i as fromPromise, n as assign } from "./xstate.esm-BXrcOcSC.esm.js";
+import { n as createFaceCaptureManagerFromActor, t as faceCaptureMachine } from "./faceCaptureSetup-DzlTPjT9.esm.js";
+import { v as FACE_ERROR_CODES, y as BrowserStorageProvider } from "./recordingService-BDx_6XR9.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-BKd2FOAf.esm.js";
 
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {

package/dist/{backCameraStream-DF_d7hTz.esm.js → backCameraStream-CUo1USCT.esm.js}

@@ -1,5 +1,5 @@
-import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-DdhkonXk.esm.js";
-import { i as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-DAuRUvnp.esm.js";
+import { i as stopCameraStream, n as enumerateVideoDevices, r as requestCameraAccess, t as applyTrackConstraints } from "./camera-CsT06Zqy.esm.js";
+import { a as isIPhone14OrHigher, o as isSafari, r as isIOS, t as isAndroid } from "./platform-Dcuv6w60.esm.js";
 
 //#region ../infra/src/capabilities/ITimerCapability.ts
 function sleep(ms) {

package/dist/camera.d.ts

@@ -0,0 +1,16 @@
+import { n as PermissionStatus, t as PermissionResult } from "./types-UPqCMQKa.js";
+
+//#region src/internal/permissions/permissionServices.d.ts
+
+/**
+ * Checks the current camera permission state without prompting the user.
+ */
+declare function checkPermission(): Promise<PermissionResult>;
+/**
+ * Requests camera permission by attempting to access the camera, then immediately
+ * stops the obtained stream. Also requests motion sensor permission (required on iOS
+ * to be called during a user gesture). This function does not keep or return the stream.
+ */
+declare function requestPermission(): Promise<PermissionResult>;
+//#endregion
+export { type PermissionResult, type PermissionStatus, checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/camera.esm.js

@@ -0,0 +1,5 @@
+import "./camera-CsT06Zqy.esm.js";
+import "./MotionSensorProvider-BTDLt08l.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-CDqkkway.esm.js";
+
+export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };