@incodetech/core 0.0.0-dev-20260323-d5fdccb → 0.0.0-dev-20260324-90ddcfd

package/dist/mandatory-consent.d.ts

@@ -0,0 +1,411 @@
+import { t as Manager } from "./Manager-BWqHEUjI.js";
+import "./camera-BCRgkMoe.js";
+import "./types-BYFeUhw0.js";
+import { i as RegulationTypes } from "./types-0A1THNYO.js";
+import * as xstate417 from "xstate";
+
+//#region src/modules/mandatory-consent/types.d.ts
+type MandatoryConsentConfig = {
+  consentType: RegulationTypes;
+};
+type MandatoryConsent = {
+  id: string;
+  title: string;
+  text: string;
+  description?: string;
+  consentType: string;
+};
+type FetchMandatoryConsentResponse = {
+  consents: MandatoryConsent[];
+};
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentStateMachine.d.ts
+type MandatoryConsentContext = {
+  config: MandatoryConsentConfig;
+  consent: MandatoryConsent | undefined;
+  isSigned: boolean;
+  error: string | undefined;
+};
+type MandatoryConsentInput = {
+  config: MandatoryConsentConfig;
+};
+declare const mandatoryConsentMachine: xstate417.StateMachine<MandatoryConsentContext, {
+  type: "LOAD";
+} | {
+  type: "TOGGLE";
+} | {
+  type: "SUBMIT";
+} | {
+  type: "CANCEL";
+} | {
+  type: "RETRY";
+} | {
+  type: "RESET";
+}, {
+  [x: string]: xstate417.ActorRefFromLogic<xstate417.PromiseActorLogic<FetchMandatoryConsentResponse, {
+    config: MandatoryConsentConfig;
+  }, xstate417.EventObject>> | xstate417.ActorRefFromLogic<xstate417.PromiseActorLogic<void, {
+    consentId: string;
+    isSigned: boolean;
+  }, xstate417.EventObject>> | undefined;
+}, xstate417.Values<{
+  fetchConsent: {
+    src: "fetchConsent";
+    logic: xstate417.PromiseActorLogic<FetchMandatoryConsentResponse, {
+      config: MandatoryConsentConfig;
+    }, xstate417.EventObject>;
+    id: string | undefined;
+  };
+  submitConsent: {
+    src: "submitConsent";
+    logic: xstate417.PromiseActorLogic<void, {
+      consentId: string;
+      isSigned: boolean;
+    }, xstate417.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate417.Values<{
+  clearError: {
+    type: "clearError";
+    params: xstate417.NonReducibleUnknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: xstate417.NonReducibleUnknown;
+  };
+  setError: {
+    type: "setError";
+    params: xstate417.NonReducibleUnknown;
+  };
+  setConsent: {
+    type: "setConsent";
+    params: xstate417.NonReducibleUnknown;
+  };
+  toggleSigned: {
+    type: "toggleSigned";
+    params: xstate417.NonReducibleUnknown;
+  };
+}>, {
+  type: "canSubmit";
+  params: unknown;
+}, never, "error" | "finished" | "closed" | "idle" | "loading" | "display" | "submitting", string, MandatoryConsentInput, xstate417.NonReducibleUnknown, xstate417.EventObject, xstate417.MetaObject, {
+  readonly id: "mandatoryConsent";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
+        src: "fetchConsent";
+        logic: xstate417.PromiseActorLogic<FetchMandatoryConsentResponse, {
+          config: MandatoryConsentConfig;
+        }, xstate417.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchConsent";
+        logic: xstate417.PromiseActorLogic<FetchMandatoryConsentResponse, {
+          config: MandatoryConsentConfig;
+        }, xstate417.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate417.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate417.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate417.RequiredActorOptions<T>]: unknown }) | undefined], xstate417.IsNotNever<xstate417.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitConsent";
+        logic: xstate417.PromiseActorLogic<void, {
+          consentId: string;
+          isSigned: boolean;
+        }, xstate417.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitConsent";
+        logic: xstate417.PromiseActorLogic<void, {
+          consentId: string;
+          isSigned: boolean;
+        }, xstate417.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate417.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate417.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate417.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate417.IsNotNever<xstate417.RequiredActorOptions<T_1>>> : never : never : never)): xstate417.ActorRefFromLogic<xstate417.GetConcreteByKey<xstate417.Values<{
+        fetchConsent: {
+          src: "fetchConsent";
+          logic: xstate417.PromiseActorLogic<FetchMandatoryConsentResponse, {
+            config: MandatoryConsentConfig;
+          }, xstate417.EventObject>;
+          id: string | undefined;
+        };
+        submitConsent: {
+          src: "submitConsent";
+          logic: xstate417.PromiseActorLogic<void, {
+            consentId: string;
+            isSigned: boolean;
+          }, xstate417.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate417.AnyActorLogic>(src: TLogic, ...[options]: xstate417.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate417.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate417.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate417.IsNotNever<xstate417.RequiredLogicInput<TLogic>>>): xstate417.ActorRefFromLogic<TLogic>;
+    };
+    input: MandatoryConsentInput;
+    self: xstate417.ActorRef<xstate417.MachineSnapshot<MandatoryConsentContext, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE";
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "CANCEL";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate417.AnyActorRef | undefined>, xstate417.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE";
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "CANCEL";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, xstate417.AnyEventObject>;
+  }) => {
+    config: MandatoryConsentConfig;
+    consent: undefined;
+    isSigned: false;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchConsent";
+        readonly src: "fetchConsent";
+        readonly input: ({
+          context
+        }: {
+          context: MandatoryConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate417.ActorRef<xstate417.MachineSnapshot<MandatoryConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate417.AnyActorRef>, xstate417.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate417.AnyEventObject>;
+        }) => {
+          config: MandatoryConsentConfig;
+        };
+        readonly onDone: {
+          readonly target: "display";
+          readonly actions: "setConsent";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly display: {
+      readonly on: {
+        readonly TOGGLE: {
+          readonly actions: "toggleSigned";
+        };
+        readonly SUBMIT: {
+          readonly target: "submitting";
+          readonly guard: "canSubmit";
+        };
+        readonly CANCEL: {
+          readonly target: "closed";
+        };
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitConsent";
+        readonly src: "submitConsent";
+        readonly input: ({
+          context
+        }: {
+          context: MandatoryConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate417.ActorRef<xstate417.MachineSnapshot<MandatoryConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate417.AnyActorRef>, xstate417.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE";
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "CANCEL";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate417.AnyEventObject>;
+        }) => {
+          consentId: string;
+          isSigned: boolean;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "display";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly CANCEL: {
+          readonly target: "closed";
+        };
+        readonly RESET: {
+          readonly target: "idle";
+          readonly actions: "resetContext";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentActor.d.ts
+type CreateMandatoryConsentActorOptions = {
+  config: MandatoryConsentConfig;
+};
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentManager.d.ts
+type MandatoryConsentIdleState = {
+  status: 'idle';
+};
+type MandatoryConsentLoadingState = {
+  status: 'loading';
+};
+type MandatoryConsentDisplayState = {
+  status: 'display';
+  title: string;
+  text: string;
+  isSigned: boolean;
+  canSubmit: boolean;
+  error?: string;
+};
+type MandatoryConsentSubmittingState = {
+  status: 'submitting';
+  title: string;
+  text: string;
+  isSigned: boolean;
+  canSubmit: false;
+};
+type MandatoryConsentFinishedState = {
+  status: 'finished';
+};
+type MandatoryConsentClosedState = {
+  status: 'closed';
+};
+type MandatoryConsentErrorState = {
+  status: 'error';
+  error: string;
+};
+type MandatoryConsentState = MandatoryConsentIdleState | MandatoryConsentLoadingState | MandatoryConsentDisplayState | MandatoryConsentSubmittingState | MandatoryConsentFinishedState | MandatoryConsentClosedState | MandatoryConsentErrorState;
+declare function createMandatoryConsentManager(options: CreateMandatoryConsentActorOptions): Manager<MandatoryConsentState> & {
+  load(): void;
+  toggle(): void;
+  submit(): void;
+  cancel(): void;
+  retry(): void;
+  reset(): void;
+};
+type MandatoryConsentManager = ReturnType<typeof createMandatoryConsentManager>;
+//#endregion
+export { type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, mandatoryConsentMachine };

package/dist/mandatory-consent.esm.js

@@ -0,0 +1,198 @@
+import { S as createActor, n as eventModuleNames, o as createManagerInstrumentation, v as setup, x as fromPromise, y as assign } from "./events-CbNkXF2Q.esm.js";
+import { A as createManager } from "./src-BX-m0lbm.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-b2PxFIku.esm.js";
+
+//#region src/modules/mandatory-consent/mandatoryConsentServices.ts
+async function fetchMandatoryConsent(regulationType, signal) {
+	const res = await api.get(endpoints.getConsents, {
+		signal,
+		query: {
+			type: "MANDATORY",
+			language: "en",
+			regulationType
+		}
+	});
+	if (!res.ok) throw new Error(`GET ${endpoints.getConsents} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function submitMandatoryConsent(params, signal) {
+	const res = await api.post(endpoints.submitMlConsent, params, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.submitMlConsent} failed: ${res.status} ${res.statusText}`);
+}
+
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentStateMachine.ts
+const mandatoryConsentMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchConsent: fromPromise(async ({ input, signal }) => fetchMandatoryConsent(input.config.consentType, signal)),
+		submitConsent: fromPromise(async ({ input, signal }) => submitMandatoryConsent({ consents: [{
+			id: input.consentId,
+			isSigned: input.isSigned
+		}] }, signal))
+	},
+	actions: {
+		setConsent: assign(({ event }) => {
+			return {
+				consent: event.output.consents[0],
+				isSigned: false,
+				error: void 0
+			};
+		}),
+		toggleSigned: assign(({ context }) => ({ isSigned: !context.isSigned })),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		clearError: assign({ error: () => void 0 }),
+		resetContext: assign(({ context }) => ({
+			config: context.config,
+			consent: void 0,
+			isSigned: false,
+			error: void 0
+		}))
+	},
+	guards: { canSubmit: ({ context }) => Boolean(context.consent?.id) && context.isSigned }
+}).createMachine({
+	id: "mandatoryConsent",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		consent: void 0,
+		isSigned: false,
+		error: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: {
+			target: "loading",
+			actions: "clearError"
+		} } },
+		loading: { invoke: {
+			id: "fetchConsent",
+			src: "fetchConsent",
+			input: ({ context }) => ({ config: context.config }),
+			onDone: {
+				target: "display",
+				actions: "setConsent"
+			},
+			onError: {
+				target: "error",
+				actions: "setError"
+			}
+		} },
+		display: { on: {
+			TOGGLE: { actions: "toggleSigned" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "canSubmit"
+			},
+			CANCEL: { target: "closed" },
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitConsent",
+			src: "submitConsent",
+			input: ({ context }) => ({
+				consentId: context.consent?.id ?? "",
+				isSigned: context.isSigned
+			}),
+			onDone: { target: "finished" },
+			onError: {
+				target: "display",
+				actions: "setError"
+			}
+		} },
+		error: { on: {
+			RETRY: {
+				target: "loading",
+				actions: "clearError"
+			},
+			CANCEL: { target: "closed" },
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentActor.ts
+function createMandatoryConsentActor(options) {
+	return createActor(mandatoryConsentMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	const canSubmit = Boolean(context.isSigned && context.consent?.id);
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("display")) return {
+		status: "display",
+		title: context.consent?.title ?? "",
+		text: context.consent?.text ?? "",
+		isSigned: context.isSigned,
+		canSubmit,
+		error: context.error
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.consent?.title ?? "",
+		text: context.consent?.text ?? "",
+		isSigned: context.isSigned,
+		canSubmit: false
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		toggle() {
+			actor.send({ type: "TOGGLE" });
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		cancel() {
+			trackElementClicked?.("cancel");
+			actor.send({ type: "CANCEL" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createMandatoryConsentManager(options) {
+	return createManager({
+		actor: createMandatoryConsentActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.mlConsent)
+	});
+}
+
+//#endregion
+export { createMandatoryConsentManager, mandatoryConsentMachine };

package/dist/phone.d.ts

@@ -1,4 +1,4 @@
-import "./Manager-CVDYGoSq.js";
-import "./Actor-D6rhGxJy.js";
-import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-pTIOvlCD.js";
+import "./Manager-BWqHEUjI.js";
+import "./Actor-By8WNHi-.js";
+import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-B0MT8wYz.js";
 export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };

package/dist/phone.esm.js

@@ -1,7 +1,7 @@
-import "./events-DzHYCTUI.esm.js";
-import "./src-Cmpz4Jmw.esm.js";
-import "./api-3fZO5bmj.esm.js";
-import "./endpoints-Bydn-Ave.esm.js";
-import { r as phoneMachine, t as createPhoneManager } from "./phoneManager-BwBW-tRA.esm.js";
+import "./events-CbNkXF2Q.esm.js";
+import "./src-BX-m0lbm.esm.js";
+import "./api-C2uzxrpN.esm.js";
+import "./endpoints-b2PxFIku.esm.js";
+import { r as phoneMachine, t as createPhoneManager } from "./phoneManager-Cvp5LFN7.esm.js";
 
 export { createPhoneManager, phoneMachine };

package/dist/{phoneManager-pTIOvlCD.d.ts → phoneManager-B0MT8wYz.d.ts}

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-CVDYGoSq.js";
-import { t as ActorRefFrom } from "./Actor-D6rhGxJy.js";
+import { t as Manager } from "./Manager-BWqHEUjI.js";
+import { t as ActorRefFrom } from "./Actor-By8WNHi-.js";
 
 //#region src/modules/phone/types.d.ts
 

package/dist/{phoneManager-BwBW-tRA.esm.js → phoneManager-Cvp5LFN7.esm.js}

@@ -1,7 +1,7 @@
-import { S as createActor, b as fromCallback, n as eventModuleNames, o as createManagerInstrumentation, v as setup, x as fromPromise, y as assign } from "./events-DzHYCTUI.esm.js";
-import { A as createManager, g as BrowserTimerProvider } from "./src-Cmpz4Jmw.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-Bydn-Ave.esm.js";
+import { S as createActor, b as fromCallback, n as eventModuleNames, o as createManagerInstrumentation, v as setup, x as fromPromise, y as assign } from "./events-CbNkXF2Q.esm.js";
+import { A as createManager, g as BrowserTimerProvider } from "./src-BX-m0lbm.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-b2PxFIku.esm.js";
 
 //#region src/modules/phone/phoneServices.ts
 async function fetchPhone(signal) {

package/dist/{recordingsRepository-DVPWOR9j.esm.js → recordingsRepository-DGWSMj-_.esm.js}

@@ -1,6 +1,6 @@
-import { C as queryCameraPermission, M as getDeviceInfo, O as requestCameraAccess, P as getUserAgent, R as isIPad, f as MotionSensorProvider, k as stopCameraStream } from "./src-Cmpz4Jmw.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-Bydn-Ave.esm.js";
+import { C as queryCameraPermission, M as getDeviceInfo, O as requestCameraAccess, P as getUserAgent, R as isIPad, f as MotionSensorProvider, k as stopCameraStream } from "./src-BX-m0lbm.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-b2PxFIku.esm.js";
 
 //#region src/internal/device/getBrowser.ts
 function getBrowser() {

package/dist/redirect-to-mobile.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-CVDYGoSq.js";
+import { t as Manager } from "./Manager-BWqHEUjI.js";
 
 //#region src/modules/redirect-to-mobile/types.d.ts
 type RedirectToMobileConfig = {

package/dist/redirect-to-mobile.esm.js

@@ -1,7 +1,7 @@
-import { S as createActor, b as fromCallback, n as eventModuleNames, o as createManagerInstrumentation, v as setup, x as fromPromise, y as assign } from "./events-DzHYCTUI.esm.js";
-import { A as createManager, g as BrowserTimerProvider } from "./src-Cmpz4Jmw.esm.js";
-import { t as api } from "./api-3fZO5bmj.esm.js";
-import { t as endpoints } from "./endpoints-Bydn-Ave.esm.js";
+import { S as createActor, b as fromCallback, n as eventModuleNames, o as createManagerInstrumentation, v as setup, x as fromPromise, y as assign } from "./events-CbNkXF2Q.esm.js";
+import { A as createManager, g as BrowserTimerProvider } from "./src-BX-m0lbm.esm.js";
+import { t as api } from "./api-C2uzxrpN.esm.js";
+import { t as endpoints } from "./endpoints-b2PxFIku.esm.js";
 
 //#region ../infra/src/url/urlUtils.ts
 function getUrlSearchParam(url, param) {