@incodetech/core 0.0.0-dev-20260409-09dfd52 → 0.0.0-dev-20260409-73c2599

package/dist/identity-reuse.esm.js

@@ -0,0 +1,273 @@
+import { t as api } from "./api-CqKwkjJ3.esm.js";
+import { _ as endpoints, n as eventModuleNames, o as createManagerInstrumentation } from "./events-CZ2ka3pu.esm.js";
+import { a as createActor, i as fromPromise, n as assign, o as createManager, t as setup } from "./xstate.esm-D7D6CGwY.esm.js";
+
+//#region src/modules/identity-reuse/identityReuseServices.ts
+/** Fetches candidate organizations for identity reuse. Throws on failure. */
+async function fetchCandidates(signal) {
+	const res = await api.get(endpoints.identityReuseCandidates, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.identityReuseCandidates} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
+	return res.data;
+}
+/** Submits the final reuse decision. Throws on failure. */
+async function submitDecision(params, signal) {
+	const res = await api.post(endpoints.identityReuseSubmit, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.identityReuseSubmit} failed: ${res.status} ${res.statusText} — ${JSON.stringify(res.data)}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/identity-reuse/identityReuseStateMachine.ts
+const identityReuseMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchCandidates: fromPromise(async ({ signal }) => {
+			return fetchCandidates(signal);
+		}),
+		submitContinue: fromPromise(async ({ signal }) => {
+			return submitDecision({ accepted: true }, signal);
+		}),
+		submitSkip: fromPromise(async ({ signal }) => {
+			return submitDecision({ accepted: false }, signal);
+		})
+	},
+	actions: {
+		setCandidates: assign(({ event }) => {
+			const output = event.output;
+			return {
+				currentOrganizationName: output.currentOrganizationName,
+				candidateOrganizationNames: output.candidateOrganizationNames
+			};
+		}),
+		setSelectedCandidate: assign(({ event }) => {
+			return { selectedOrganizationName: event.organizationName };
+		}),
+		autoSelectSingleCandidate: assign(({ context }) => ({ selectedOrganizationName: context.candidateOrganizationNames[0] })),
+		clearSelection: assign({ selectedOrganizationName: () => void 0 }),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 })
+	},
+	guards: {
+		hasMultipleCandidates: ({ event }) => {
+			return event.output.candidateOrganizationNames.length > 1;
+		},
+		hasOneCandidate: ({ event }) => {
+			return event.output.candidateOrganizationNames.length === 1;
+		},
+		hasChosenCandidate: ({ context }) => context.selectedOrganizationName !== void 0 && context.selectedOrganizationName.length > 0
+	}
+}).createMachine({
+	id: "identityReuse",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		currentOrganizationName: void 0,
+		candidateOrganizationNames: [],
+		selectedOrganizationName: void 0,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "loading" } } },
+		loading: { invoke: {
+			id: "fetchCandidates",
+			src: "fetchCandidates",
+			onDone: [
+				{
+					target: "multiCandidatesFound",
+					guard: "hasMultipleCandidates",
+					actions: "setCandidates"
+				},
+				{
+					target: "oneCandidateFound",
+					guard: "hasOneCandidate",
+					actions: "setCandidates"
+				},
+				{
+					target: "noCandidatesFound",
+					actions: "setCandidates"
+				}
+			],
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		multiCandidatesFound: {
+			initial: "noCandidateSelected",
+			states: {
+				noCandidateSelected: { on: { START_SELECTION: { target: "choosingCandidate" } } },
+				choosingCandidate: { on: { CANDIDATE_CHOSEN: {
+					target: "candidateSelected",
+					actions: "setSelectedCandidate"
+				} } },
+				candidateSelected: { on: { CHANGE_CANDIDATE: {
+					target: "choosingCandidate",
+					actions: "clearSelection"
+				} } }
+			},
+			on: {
+				SUBMIT_CANDIDATE: {
+					target: "submitContinue",
+					guard: "hasChosenCandidate"
+				},
+				SKIP: { target: "submitSkip" }
+			}
+		},
+		oneCandidateFound: {
+			entry: "autoSelectSingleCandidate",
+			on: {
+				SUBMIT_CANDIDATE: { target: "submitContinue" },
+				SKIP: { target: "submitSkip" }
+			}
+		},
+		noCandidatesFound: { on: { SKIP: { target: "submitSkip" } } },
+		submitContinue: { invoke: {
+			id: "submitContinue",
+			src: "submitContinue",
+			onDone: { target: "finished" },
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		submitSkip: { invoke: {
+			id: "submitSkip",
+			src: "submitSkip",
+			onDone: { target: "finished" },
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		finished: { type: "final" },
+		error: { on: {
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			},
+			SKIP: { target: "submitSkip" }
+		} }
+	}
+});
+
+//#endregion
+//#region src/modules/identity-reuse/identityReuseActor.ts
+/**
+* Creates and starts an IdentityReuse actor.
+*
+* The actor begins in 'idle' state, ready to receive events.
+*/
+function createIdentityReuseActor(options) {
+	return createActor(identityReuseMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/identity-reuse/identityReuseManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("multiCandidatesFound")) {
+		let selectionPhase = "noCandidateSelected";
+		if (snapshot.matches({ multiCandidatesFound: "candidateSelected" })) selectionPhase = "candidateSelected";
+		else if (snapshot.matches({ multiCandidatesFound: "choosingCandidate" })) selectionPhase = "choosingCandidate";
+		return {
+			status: "multiCandidatesFound",
+			currentOrganizationName: context.currentOrganizationName,
+			candidateOrganizationNames: context.candidateOrganizationNames,
+			selectedOrganizationName: context.selectedOrganizationName,
+			selectionPhase
+		};
+	}
+	if (snapshot.matches("oneCandidateFound")) return {
+		status: "oneCandidateFound",
+		currentOrganizationName: context.currentOrganizationName,
+		selectedOrganizationName: context.selectedOrganizationName
+	};
+	if (snapshot.matches("noCandidatesFound")) return {
+		status: "noCandidatesFound",
+		currentOrganizationName: context.currentOrganizationName
+	};
+	if (snapshot.matches("submitContinue")) return { status: "submitContinue" };
+	if (snapshot.matches("submitSkip")) return { status: "submitSkip" };
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "An error occurred"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		startSelection() {
+			trackElementClicked?.("startSelection");
+			actor.send({ type: "START_SELECTION" });
+		},
+		chooseCandidate(organizationName) {
+			trackElementClicked?.("chooseCandidate");
+			actor.send({
+				type: "CANDIDATE_CHOSEN",
+				organizationName
+			});
+		},
+		changeCandidate() {
+			trackElementClicked?.("changeCandidate");
+			actor.send({ type: "CHANGE_CANDIDATE" });
+		},
+		submitCandidate() {
+			trackElementClicked?.("submitCandidate");
+			actor.send({ type: "SUBMIT_CANDIDATE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		}
+	};
+}
+/**
+* Creates an IdentityReuse manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createIdentityReuseManager({ config: {} });
+* manager.subscribe((state) => {
+*   if (state.status === 'oneCandidateFound') manager.submitCandidate();
+*   if (state.status === 'finished') console.log('Done!');
+* });
+* manager.load();
+* ```
+*/
+function createIdentityReuseManager(options) {
+	return createManager({
+		actor: createIdentityReuseActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+	});
+}
+/**
+* Creates an IdentityReuse manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends or testing.
+*/
+function createIdentityReuseManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.identityReuse)
+	});
+}
+
+//#endregion
+export { createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import "./warmup-Ckb1hN85.js";
-import { a as reset, i as isConfigured, s as setup, t as SetupOptions } from "./setup-BYqwVLiv.js";
+import "./warmup-Cs0uqxUW.js";
+import { a as reset, i as isConfigured, s as setup, t as SetupOptions } from "./setup-Bz3Ffaoc.js";
 export { type SetupOptions, isConfigured, reset, setup };

package/dist/index.esm.js

@@ -1,10 +1,10 @@
-import { a as setup, n as isConfigured, r as reset } from "./setup-DLvhsDol.esm.js";
-import "./BaseWasmProvider-DoYDYH1z.esm.js";
-import "./WasmUtilProvider-mWSXzp7b.esm.js";
-import "./api-aa9Mx20l.esm.js";
-import "./events-W91zLpx4.esm.js";
-import "./session-B_rKSRql.esm.js";
-import "./BrowserEnvironmentProvider-BtKLxTx4.esm.js";
-import "./browserSimulation-DFqGKQAD.esm.js";
+import { a as setup, n as isConfigured, r as reset } from "./setup-Bh2S53NT.esm.js";
+import "./BaseWasmProvider-C73c2nV9.esm.js";
+import "./WasmUtilProvider-DRh0wrlm.esm.js";
+import "./api-CqKwkjJ3.esm.js";
+import "./events-CZ2ka3pu.esm.js";
+import "./session-DoI-X9FK.esm.js";
+import "./BrowserEnvironmentProvider-lxn4oxXn.esm.js";
+import "./browserSimulation-7W5-A3RV.esm.js";
 
 export { isConfigured, reset, setup };

package/dist/{lib-BzVJ-zxG.esm.js → lib-CxDxnzRd.esm.js}

@@ -1,4 +1,4 @@
-import { i as __toCommonJS, n as __esm, r as __export, t as __commonJS } from "./chunk-YGHKo4MY.esm.js";
+import { i as __toCommonJS, n as __esm, r as __export, t as __commonJS } from "./chunk-Qw4qVmMx.esm.js";
 
 //#region ../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js
 var require_jsnlog = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js": ((exports) => {

package/dist/mandatory-consent.d.ts

@@ -1,9 +1,9 @@
-import { t as Manager } from "./Manager-DcPMRgTm.js";
-import "./Actor-DbWH1K6E.js";
-import "./camera-DATT31my.js";
-import "./types-CYJ0Ish6.js";
-import { i as RegulationTypes } from "./types-DU8HmI5U.js";
-import * as xstate63 from "xstate";
+import { t as Manager } from "./Manager-Bcnemkyi.js";
+import "./Actor-BkPcZGke.js";
+import "./camera-CgnuDuxy.js";
+import "./types-CdlQrTiZ.js";
+import { i as RegulationTypes } from "./types-m43DfiSx.js";
+import * as xstate228 from "xstate";
 
 //#region src/modules/mandatory-consent/types.d.ts
 type MandatoryConsentConfig = {
@@ -30,7 +30,7 @@ type MandatoryConsentContext = {
 type MandatoryConsentInput = {
   config: MandatoryConsentConfig;
 };
-declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentContext, {
+declare const mandatoryConsentMachine: xstate228.StateMachine<MandatoryConsentContext, {
   type: "LOAD";
 } | {
   type: "TOGGLE";
@@ -43,53 +43,53 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
 } | {
   type: "RESET";
 }, {
-  [x: string]: xstate63.ActorRefFromLogic<xstate63.PromiseActorLogic<FetchMandatoryConsentResponse, {
+  [x: string]: xstate228.ActorRefFromLogic<xstate228.PromiseActorLogic<FetchMandatoryConsentResponse, {
     config: MandatoryConsentConfig;
-  }, xstate63.EventObject>> | xstate63.ActorRefFromLogic<xstate63.PromiseActorLogic<void, {
+  }, xstate228.EventObject>> | xstate228.ActorRefFromLogic<xstate228.PromiseActorLogic<void, {
     consentId: string;
     isSigned: boolean;
-  }, xstate63.EventObject>> | undefined;
-}, xstate63.Values<{
+  }, xstate228.EventObject>> | undefined;
+}, xstate228.Values<{
   fetchConsent: {
     src: "fetchConsent";
-    logic: xstate63.PromiseActorLogic<FetchMandatoryConsentResponse, {
+    logic: xstate228.PromiseActorLogic<FetchMandatoryConsentResponse, {
       config: MandatoryConsentConfig;
-    }, xstate63.EventObject>;
+    }, xstate228.EventObject>;
     id: string | undefined;
   };
   submitConsent: {
     src: "submitConsent";
-    logic: xstate63.PromiseActorLogic<void, {
+    logic: xstate228.PromiseActorLogic<void, {
       consentId: string;
       isSigned: boolean;
-    }, xstate63.EventObject>;
+    }, xstate228.EventObject>;
     id: string | undefined;
   };
-}>, xstate63.Values<{
+}>, xstate228.Values<{
   setError: {
     type: "setError";
-    params: xstate63.NonReducibleUnknown;
+    params: xstate228.NonReducibleUnknown;
   };
   clearError: {
     type: "clearError";
-    params: xstate63.NonReducibleUnknown;
+    params: xstate228.NonReducibleUnknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: xstate228.NonReducibleUnknown;
   };
   setConsent: {
     type: "setConsent";
-    params: xstate63.NonReducibleUnknown;
+    params: xstate228.NonReducibleUnknown;
   };
   toggleSigned: {
     type: "toggleSigned";
-    params: xstate63.NonReducibleUnknown;
-  };
-  resetContext: {
-    type: "resetContext";
-    params: xstate63.NonReducibleUnknown;
+    params: xstate228.NonReducibleUnknown;
   };
 }>, {
   type: "canSubmit";
   params: unknown;
-}, never, "error" | "idle" | "closed" | "finished" | "loading" | "display" | "submitting", string, MandatoryConsentInput, xstate63.NonReducibleUnknown, xstate63.EventObject, xstate63.MetaObject, {
+}, never, "error" | "idle" | "closed" | "finished" | "loading" | "display" | "submitting", string, MandatoryConsentInput, xstate228.NonReducibleUnknown, xstate228.EventObject, xstate228.MetaObject, {
   readonly id: "mandatoryConsent";
   readonly initial: "idle";
   readonly context: ({
@@ -98,70 +98,70 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
     spawn: {
       <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
         src: "fetchConsent";
-        logic: xstate63.PromiseActorLogic<FetchMandatoryConsentResponse, {
+        logic: xstate228.PromiseActorLogic<FetchMandatoryConsentResponse, {
           config: MandatoryConsentConfig;
-        }, xstate63.EventObject>;
+        }, xstate228.EventObject>;
         id: string | undefined;
       } extends infer T ? T extends {
         src: "fetchConsent";
-        logic: xstate63.PromiseActorLogic<FetchMandatoryConsentResponse, {
+        logic: xstate228.PromiseActorLogic<FetchMandatoryConsentResponse, {
           config: MandatoryConsentConfig;
-        }, xstate63.EventObject>;
+        }, xstate228.EventObject>;
         id: string | undefined;
       } ? T extends {
         src: TSrc;
-      } ? xstate63.ConditionalRequired<[options?: ({
+      } ? xstate228.ConditionalRequired<[options?: ({
         id?: T["id"] | undefined;
         systemId?: string;
-        input?: xstate63.InputFrom<T["logic"]> | undefined;
+        input?: xstate228.InputFrom<T["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate63.RequiredActorOptions<T>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredActorOptions<T>>> : never : never : never) | ({
+      } & { [K in xstate228.RequiredActorOptions<T>]: unknown }) | undefined], xstate228.IsNotNever<xstate228.RequiredActorOptions<T>>> : never : never : never) | ({
         src: "submitConsent";
-        logic: xstate63.PromiseActorLogic<void, {
+        logic: xstate228.PromiseActorLogic<void, {
           consentId: string;
           isSigned: boolean;
-        }, xstate63.EventObject>;
+        }, xstate228.EventObject>;
         id: string | undefined;
       } extends infer T_1 ? T_1 extends {
         src: "submitConsent";
-        logic: xstate63.PromiseActorLogic<void, {
+        logic: xstate228.PromiseActorLogic<void, {
           consentId: string;
           isSigned: boolean;
-        }, xstate63.EventObject>;
+        }, xstate228.EventObject>;
         id: string | undefined;
       } ? T_1 extends {
         src: TSrc;
-      } ? xstate63.ConditionalRequired<[options?: ({
+      } ? xstate228.ConditionalRequired<[options?: ({
         id?: T_1["id"] | undefined;
         systemId?: string;
-        input?: xstate63.InputFrom<T_1["logic"]> | undefined;
+        input?: xstate228.InputFrom<T_1["logic"]> | undefined;
         syncSnapshot?: boolean;
-      } & { [K_1 in xstate63.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredActorOptions<T_1>>> : never : never : never)): xstate63.ActorRefFromLogic<xstate63.GetConcreteByKey<xstate63.Values<{
+      } & { [K_1 in xstate228.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate228.IsNotNever<xstate228.RequiredActorOptions<T_1>>> : never : never : never)): xstate228.ActorRefFromLogic<xstate228.GetConcreteByKey<xstate228.Values<{
         fetchConsent: {
           src: "fetchConsent";
-          logic: xstate63.PromiseActorLogic<FetchMandatoryConsentResponse, {
+          logic: xstate228.PromiseActorLogic<FetchMandatoryConsentResponse, {
             config: MandatoryConsentConfig;
-          }, xstate63.EventObject>;
+          }, xstate228.EventObject>;
           id: string | undefined;
         };
         submitConsent: {
           src: "submitConsent";
-          logic: xstate63.PromiseActorLogic<void, {
+          logic: xstate228.PromiseActorLogic<void, {
             consentId: string;
             isSigned: boolean;
-          }, xstate63.EventObject>;
+          }, xstate228.EventObject>;
           id: string | undefined;
         };
       }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate63.AnyActorLogic>(src: TLogic, ...[options]: xstate63.ConditionalRequired<[options?: ({
+      <TLogic extends xstate228.AnyActorLogic>(src: TLogic, ...[options]: xstate228.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate63.InputFrom<TLogic> | undefined;
+        input?: xstate228.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate63.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredLogicInput<TLogic>>>): xstate63.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate228.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate228.IsNotNever<xstate228.RequiredLogicInput<TLogic>>>): xstate228.ActorRefFromLogic<TLogic>;
     };
     input: MandatoryConsentInput;
-    self: xstate63.ActorRef<xstate63.MachineSnapshot<MandatoryConsentContext, {
+    self: xstate228.ActorRef<xstate228.MachineSnapshot<MandatoryConsentContext, {
       type: "LOAD";
     } | {
       type: "TOGGLE";
@@ -173,7 +173,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
       type: "RETRY";
     } | {
       type: "RESET";
-    }, Record<string, xstate63.AnyActorRef | undefined>, xstate63.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate228.AnyActorRef | undefined>, xstate228.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "TOGGLE";
@@ -185,7 +185,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
       type: "RETRY";
     } | {
       type: "RESET";
-    }, xstate63.AnyEventObject>;
+    }, xstate228.AnyEventObject>;
   }) => {
     config: MandatoryConsentConfig;
     consent: undefined;
@@ -222,7 +222,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
           } | {
             type: "RESET";
           };
-          self: xstate63.ActorRef<xstate63.MachineSnapshot<MandatoryConsentContext, {
+          self: xstate228.ActorRef<xstate228.MachineSnapshot<MandatoryConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE";
@@ -234,7 +234,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate63.AnyActorRef>, xstate63.StateValue, string, unknown, any, any>, {
+          }, Record<string, xstate228.AnyActorRef>, xstate228.StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE";
@@ -246,7 +246,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate63.AnyEventObject>;
+          }, xstate228.AnyEventObject>;
         }) => {
           config: MandatoryConsentConfig;
         };
@@ -299,7 +299,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
           } | {
             type: "RESET";
           };
-          self: xstate63.ActorRef<xstate63.MachineSnapshot<MandatoryConsentContext, {
+          self: xstate228.ActorRef<xstate228.MachineSnapshot<MandatoryConsentContext, {
             type: "LOAD";
           } | {
             type: "TOGGLE";
@@ -311,7 +311,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
             type: "RETRY";
           } | {
             type: "RESET";
-          }, Record<string, xstate63.AnyActorRef>, xstate63.StateValue, string, unknown, any, any>, {
+          }, Record<string, xstate228.AnyActorRef>, xstate228.StateValue, string, unknown, any, any>, {
             type: "LOAD";
           } | {
             type: "TOGGLE";
@@ -323,7 +323,7 @@ declare const mandatoryConsentMachine: xstate63.StateMachine<MandatoryConsentCon
             type: "RETRY";
           } | {
             type: "RESET";
-          }, xstate63.AnyEventObject>;
+          }, xstate228.AnyEventObject>;
         }) => {
           consentId: string;
           isSigned: boolean;

package/dist/mandatory-consent.esm.js

@@ -1,7 +1,7 @@
-import "./api-aa9Mx20l.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
-import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
-import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-BZNBJ1fK.esm.js";
+import "./api-CqKwkjJ3.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CZ2ka3pu.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-D7D6CGwY.esm.js";
+import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-BMKi26Re.esm.js";
 
 //#region src/modules/mandatory-consent/mandatoryConsentActor.ts
 function createMandatoryConsentActor(options) {

package/dist/{mandatoryConsentStateMachine-BZNBJ1fK.esm.js → mandatoryConsentStateMachine-BMKi26Re.esm.js}

@@ -1,6 +1,6 @@
-import { t as api } from "./api-aa9Mx20l.esm.js";
-import { _ as endpoints } from "./events-W91zLpx4.esm.js";
-import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-B7FPE6br.esm.js";
+import { t as api } from "./api-CqKwkjJ3.esm.js";
+import { _ as endpoints } from "./events-CZ2ka3pu.esm.js";
+import { i as fromPromise, n as assign, t as setup } from "./xstate.esm-D7D6CGwY.esm.js";
 
 //#region src/modules/mandatory-consent/mandatoryConsentServices.ts
 async function fetchMandatoryConsent(regulationType, signal) {

package/dist/{openviduLazy-CLg_-u0m.esm.js → openviduLazy-B8tinh9W.esm.js}

@@ -1,10 +1,10 @@
-import { a as __toDynamicImportESM } from "./chunk-YGHKo4MY.esm.js";
+import { a as __toDynamicImportESM } from "./chunk-Qw4qVmMx.esm.js";
 
 //#region ../infra/src/providers/browser/openviduLazy.ts
 let openViduImport;
 async function loadOpenVidu() {
 	if (openViduImport) return openViduImport;
-	openViduImport = import("./lib-BzVJ-zxG.esm.js").then(__toDynamicImportESM(1));
+	openViduImport = import("./lib-CxDxnzRd.esm.js").then(__toDynamicImportESM(1));
 	return openViduImport;
 }
 

package/dist/openviduLazy-CItjpMfL.esm.js

@@ -0,0 +1,3 @@
+import { t as loadOpenVidu } from "./openviduLazy-B8tinh9W.esm.js";
+
+export { loadOpenVidu };

package/dist/{permissionServices-Cisv73eQ.esm.js → permissionServices-Cj120WaT.esm.js}

@@ -1,5 +1,5 @@
-import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DpPQS_-5.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-D90R4qwV.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-B-5traWf.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-BLnFo6My.esm.js";
 
 //#region ../infra/src/media/permissions.ts
 async function queryPermission(name) {

package/dist/phone.d.ts

@@ -1,4 +1,4 @@
-import "./Manager-DcPMRgTm.js";
-import "./Actor-DbWH1K6E.js";
-import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-Zwr-qCnC.js";
+import "./Manager-Bcnemkyi.js";
+import "./Actor-BkPcZGke.js";
+import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-CCMCkyYr.js";
 export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };

package/dist/phone.esm.js

@@ -1,8 +1,8 @@
-import "./api-aa9Mx20l.esm.js";
-import "./events-W91zLpx4.esm.js";
-import "./xstate.esm-B7FPE6br.esm.js";
-import "./BrowserTimerProvider-v7bpbrAk.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-Cc_w4tC0.esm.js";
-import { t as createPhoneManager } from "./phoneManager-DhC4obPF.esm.js";
+import "./api-CqKwkjJ3.esm.js";
+import "./events-CZ2ka3pu.esm.js";
+import "./xstate.esm-D7D6CGwY.esm.js";
+import "./BrowserTimerProvider-CSdm7__S.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-B1t1Z-Dd.esm.js";
+import { t as createPhoneManager } from "./phoneManager-Bvj6Jr4o.esm.js";
 
 export { createPhoneManager, phoneMachine };

package/dist/{phoneManager-DhC4obPF.esm.js → phoneManager-Bvj6Jr4o.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-W91zLpx4.esm.js";
-import { a as createActor, o as createManager } from "./xstate.esm-B7FPE6br.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-Cc_w4tC0.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CZ2ka3pu.esm.js";
+import { a as createActor, o as createManager } from "./xstate.esm-D7D6CGwY.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-B1t1Z-Dd.esm.js";
 
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {

package/dist/{phoneManager-Zwr-qCnC.d.ts → phoneManager-CCMCkyYr.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-DcPMRgTm.js";
-import { t as ActorRefFrom } from "./Actor-DbWH1K6E.js";
+import { t as Manager } from "./Manager-Bcnemkyi.js";
+import { t as ActorRefFrom } from "./Actor-BkPcZGke.js";
 
 //#region src/modules/phone/types.d.ts