@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/electronic-signature.d.ts

@@ -0,0 +1,4 @@
+import "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import { a as AE_CONSENT_KEYS, c as ConsentKey, d as ElectronicSignatureVariant, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, h as getConsentKeys, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, o as AeConsentKey, p as QeConsentKey, r as createElectronicSignatureManager, s as ConsentChecks, t as ElectronicSignatureManager, u as ElectronicSignatureDocument } from "./index-BLKtMA0g.js";
+export { AE_CONSENT_KEYS, AeConsentKey, ConsentChecks, ConsentKey, ElectronicSignatureConfig, ElectronicSignatureDocument, ElectronicSignatureManager, ElectronicSignatureState, ElectronicSignatureVariant, QE_CONSENT_KEYS, QeConsentKey, areAllConsented, createElectronicSignatureManager, electronicSignatureMachine, getConsentKeys, getDefaultConsentChecks };

package/dist/electronic-signature.esm.js

@@ -0,0 +1,7 @@
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./xstate.esm-B70JrNqo.esm.js";
+import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, o as getConsentKeys, r as AE_CONSENT_KEYS, s as getDefaultConsentChecks, t as createElectronicSignatureManager } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+
+export { AE_CONSENT_KEYS, QE_CONSENT_KEYS, areAllConsented, createElectronicSignatureManager, electronicSignatureMachine, getConsentKeys, getDefaultConsentChecks };

package/dist/electronicSignatureManager-D9OHzTpG.esm.js

@@ -0,0 +1,428 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region ../infra/src/http/externalFetch.ts
+async function externalFetch(config) {
+	const res = await fetch(config.url, {
+		method: config.method,
+		headers: config.headers,
+		body: config.body,
+		signal: config.signal
+	});
+	if (!res.ok) throw new Error(`${config.method} ${config.url} failed: ${res.status} ${res.statusText}`);
+	return res;
+}
+
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureServices.ts
+async function fetchUnsignedDocuments(signal) {
+	const res = await api.get(endpoints.aesUnsignedDocuments, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.aesUnsignedDocuments} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+function getSignEndpoint(variant) {
+	return variant === "qe" ? endpoints.qesSignDocument : endpoints.aesSignDocument;
+}
+async function signDocument(documentRef, variant, signal) {
+	const endpoint = getSignEndpoint(variant);
+	const res = await api.post(endpoint, {
+		documentRef,
+		userConsented: true
+	}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function generateUploadUrl(signal) {
+	const res = await api.post(endpoints.aesGenerateUploadUrl, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.aesGenerateUploadUrl} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function uploadDocumentFile(presignedUrl, data, signal) {
+	await externalFetch({
+		method: "PUT",
+		url: presignedUrl,
+		headers: { "Content-Type": "application/pdf" },
+		body: data,
+		signal
+	});
+}
+
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureActors.ts
+const fetchUnsignedDocsActor = fromPromise(async ({ signal }) => fetchUnsignedDocuments(signal));
+const signDocumentsActor = fromPromise(async ({ input, signal }) => {
+	return (await Promise.all(input.documents.map((doc) => signDocument(doc.documentRef, input.variant, signal)))).map((r) => ({ signedDocumentUrl: r.signedDocumentUrl }));
+});
+const uploadDocumentActor = fromPromise(async ({ input, signal }) => {
+	const fileData = input.getFileData();
+	if (!fileData) throw new Error("No file data available for upload");
+	const { preSignedUrl } = await generateUploadUrl(signal);
+	await uploadDocumentFile(preSignedUrl, fileData, signal);
+});
+
+//#endregion
+//#region src/modules/electronic-signature/types.ts
+const AE_CONSENT_KEYS = [
+	"terms",
+	"signElectronically",
+	"signDisplayed"
+];
+const QE_CONSENT_KEYS = [
+	"issuance",
+	"qesAcknowledgement",
+	"qscdConfirmation",
+	"termsAgreement",
+	"documentsReviewed"
+];
+function getConsentKeys(variant) {
+	return variant === "qe" ? QE_CONSENT_KEYS : AE_CONSENT_KEYS;
+}
+function getDefaultConsentChecks(variant) {
+	const keys = getConsentKeys(variant);
+	return Object.fromEntries(keys.map((k) => [k, false]));
+}
+function areAllConsented(checks) {
+	return Object.values(checks).every(Boolean);
+}
+
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureStateMachine.ts
+const electronicSignatureMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchUnsignedDocs: fetchUnsignedDocsActor,
+		signDocuments: signDocumentsActor,
+		uploadDocument: uploadDocumentActor
+	},
+	actions: {
+		setDocuments: assign(({ event }) => {
+			const { output } = event;
+			return { documents: output.documents ?? [] };
+		}),
+		setSignedDocuments: assign(({ event }) => {
+			const { output } = event;
+			return { signedDocuments: output };
+		}),
+		setFile: assign(({ event }) => {
+			const { fileName, fileSize, fileUrl } = event;
+			return {
+				fileName,
+				fileSize,
+				fileUrl
+			};
+		}),
+		updateConsent: assign(({ context, event }) => {
+			const { name, checked } = event;
+			return { consentChecks: {
+				...context.consentChecks,
+				[name]: checked
+			} };
+		}),
+		setViewingDocument: assign(({ event }) => ({ viewingDocumentUrl: event.url })),
+		clearViewingDocument: assign({ viewingDocumentUrl: () => null })
+	},
+	guards: {
+		errorFromUpload: ({ context }) => context.errorSource === "upload",
+		errorFromSigning: ({ context }) => context.errorSource === "signing",
+		shouldUpload: ({ context }) => context.config.uploadDocument === true,
+		shouldDownload: ({ context }) => context.config.downloadDocument === true,
+		allConsented: ({ context }) => areAllConsented(context.consentChecks),
+		hasDocuments: ({ event }) => {
+			const { output } = event;
+			return (output.documents?.length ?? 0) > 0;
+		},
+		allSigned: ({ event }) => {
+			const { output } = event;
+			return output.every((d) => !!d.signedDocumentUrl);
+		},
+		allSignedAndDownload: ({ context, event }) => {
+			const { output } = event;
+			return output.every((d) => !!d.signedDocumentUrl) && context.config.downloadDocument === true;
+		}
+	}
+}).createMachine({
+	id: "electronicSignature",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		getFileData: input.getFileData,
+		documents: [],
+		signedDocuments: [],
+		fileName: null,
+		fileSize: null,
+		fileUrl: null,
+		consentChecks: getDefaultConsentChecks(input.config.variant ?? "ae"),
+		viewingDocumentUrl: null,
+		errorMessage: "",
+		errorSource: null
+	}),
+	states: {
+		idle: { on: { LOAD: [{
+			target: "uploading",
+			guard: "shouldUpload"
+		}, { target: "fetchingDocs" }] } },
+		uploading: { on: {
+			SELECT_FILE: {
+				target: "reviewing",
+				actions: "setFile"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		reviewing: { on: {
+			REPLACE_FILE: {
+				target: "uploading",
+				actions: assign({
+					fileName: () => null,
+					fileSize: () => null,
+					fileUrl: () => null
+				})
+			},
+			CONFIRM_FILE: { target: "uploadingFile" },
+			CLOSE: { target: "closed" }
+		} },
+		uploadingFile: { invoke: {
+			id: "uploadDocument",
+			src: "uploadDocument",
+			input: ({ context }) => ({ getFileData: context.getFileData }),
+			onDone: { target: "fetchingDocs" },
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "upload"
+				}))
+			}
+		} },
+		fetchingDocs: { invoke: {
+			id: "fetchUnsignedDocs",
+			src: "fetchUnsignedDocs",
+			onDone: [{
+				target: "signing",
+				guard: "hasDocuments",
+				actions: "setDocuments"
+			}, {
+				target: "error",
+				actions: assign({
+					errorMessage: () => "aes.noDocuments",
+					errorSource: () => "fetchDocs"
+				})
+			}],
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "fetchDocs"
+				}))
+			}
+		} },
+		signing: { on: {
+			SET_CONSENT: { actions: "updateConsent" },
+			VIEW_DOCUMENT: { actions: "setViewingDocument" },
+			CLOSE_DOCUMENT_VIEW: { actions: "clearViewingDocument" },
+			SIGN: {
+				target: "processing",
+				guard: "allConsented"
+			},
+			CLOSE: { target: "closed" }
+		} },
+		processing: { invoke: {
+			id: "signDocuments",
+			src: "signDocuments",
+			input: ({ context }) => ({
+				documents: context.documents,
+				variant: context.config.variant ?? "ae"
+			}),
+			onDone: [
+				{
+					target: "successDownload",
+					guard: "allSignedAndDownload",
+					actions: "setSignedDocuments"
+				},
+				{
+					target: "success",
+					guard: "allSigned",
+					actions: "setSignedDocuments"
+				},
+				{
+					target: "error",
+					actions: assign({
+						errorMessage: () => "aes.signingFailed",
+						errorSource: () => "signing"
+					})
+				}
+			],
+			onError: {
+				target: "error",
+				actions: assign(({ event }) => ({
+					errorMessage: String(event.error ?? "aes.error"),
+					errorSource: "signing"
+				}))
+			}
+		} },
+		success: { after: { 3e3: "finished" } },
+		successDownload: { on: {
+			FINISH: { target: "finished" },
+			CLOSE: { target: "closed" }
+		} },
+		error: { on: {
+			RETRY: [
+				{
+					target: "uploading",
+					guard: "errorFromUpload",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null,
+						fileName: () => null,
+						fileSize: () => null,
+						fileUrl: () => null
+					})
+				},
+				{
+					target: "signing",
+					guard: "errorFromSigning",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null
+					})
+				},
+				{
+					target: "fetchingDocs",
+					actions: assign({
+						errorMessage: () => "",
+						errorSource: () => null
+					})
+				}
+			],
+			CLOSE: { target: "closed" }
+		} },
+		finished: { type: "final" },
+		closed: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureActor.ts
+function createElectronicSignatureActor(options) {
+	return createActor(electronicSignatureMachine, { input: {
+		config: options.config,
+		getFileData: options.getFileData
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/electronic-signature/electronicSignatureManager.ts
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle") || snapshot.matches("fetchingDocs") || snapshot.matches("uploadingFile")) return { status: "loading" };
+	if (snapshot.matches("uploading")) return {
+		status: "uploading",
+		fileName: context.fileName
+	};
+	if (snapshot.matches("reviewing")) return {
+		status: "reviewing",
+		fileName: context.fileName,
+		fileUrl: context.fileUrl
+	};
+	if (snapshot.matches("signing")) return {
+		status: "signing",
+		variant: context.config.variant ?? "ae",
+		documents: context.documents,
+		consentChecks: context.consentChecks,
+		allConsented: areAllConsented(context.consentChecks),
+		viewingDocumentUrl: context.viewingDocumentUrl
+	};
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("success") || snapshot.matches("successDownload")) return {
+		status: "success",
+		signedDocuments: context.signedDocuments,
+		downloadDocument: context.config.downloadDocument === true
+	};
+	if (snapshot.matches("error")) return {
+		status: "error",
+		errorMessage: context.errorMessage
+	};
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("closed")) return { status: "closed" };
+	throw new Error(`Unhandled electronic-signature state: ${JSON.stringify(snapshot.value)}`);
+}
+function createApi({ actor, trackElementClicked, fileDataRef }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setConsent(name, checked) {
+			actor.send({
+				type: "SET_CONSENT",
+				name,
+				checked
+			});
+		},
+		selectFile(fileName, fileData, fileUrl) {
+			fileDataRef.current = fileData;
+			actor.send({
+				type: "SELECT_FILE",
+				fileName,
+				fileSize: fileData.byteLength,
+				fileUrl
+			});
+		},
+		replaceFile() {
+			fileDataRef.current = null;
+			actor.send({ type: "REPLACE_FILE" });
+		},
+		confirmFile() {
+			trackElementClicked?.("confirmFile");
+			actor.send({ type: "CONFIRM_FILE" });
+		},
+		viewDocument(url) {
+			actor.send({
+				type: "VIEW_DOCUMENT",
+				url
+			});
+		},
+		closeDocumentView() {
+			actor.send({ type: "CLOSE_DOCUMENT_VIEW" });
+		},
+		sign() {
+			trackElementClicked?.("sign");
+			actor.send({ type: "SIGN" });
+		},
+		finish() {
+			trackElementClicked?.("finish");
+			actor.send({ type: "FINISH" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			fileDataRef.current = null;
+			actor.send({ type: "RETRY" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createElectronicSignatureManager(options) {
+	const fileDataRef = { current: null };
+	return createManager({
+		actor: createElectronicSignatureActor({
+			config: options.config,
+			getFileData: () => fileDataRef.current
+		}),
+		mapState,
+		createApi: (apiOptions) => createApi({
+			...apiOptions,
+			fileDataRef
+		}),
+		instrumentation: createManagerInstrumentation(options.config.variant === "qe" ? eventModuleNames.qeSignature : eventModuleNames.aeSignature)
+	});
+}
+
+//#endregion
+export { areAllConsented as a, QE_CONSENT_KEYS as i, electronicSignatureMachine as n, getConsentKeys as o, AE_CONSENT_KEYS as r, getDefaultConsentChecks as s, createElectronicSignatureManager as t };

package/dist/email.d.ts

@@ -1,264 +1,4 @@
-import { t as Manager } from "./Manager-BGfxEmyv.js";
-
-//#region src/modules/email/types.d.ts
-
-/**
- * Configuration options for email verification.
- *
- * @example Standard OTP verification
- * ```typescript
- * const config: EmailConfig = {
- *   otpVerification: true,
- *   otpExpirationInMinutes: 5,
- *   prefill: false,
- * };
- * ```
- *
- * @example With all options
- * ```typescript
- * const config: EmailConfig = {
- *   otpVerification: true,
- *   otpExpirationInMinutes: 10,
- *   prefill: true,
- *   maxOtpAttempts: 3,
- * };
- * ```
- */
-type EmailConfig = {
-  /**
-   * Whether to require OTP (email code) verification.
-   * If false, email is verified immediately after submission.
-   */
-  otpVerification: boolean;
-  /**
-   * How long the OTP code remains valid, in minutes.
-   * After expiration, user must request a new code.
-   */
-  otpExpirationInMinutes: number;
-  /**
-   * Whether to pre-populate with user's previously stored email address.
-   * Useful for returning users.
-   */
-  prefill: boolean;
-  /**
-   * Maximum number of OTP verification attempts before lockout.
-   * After exhausting attempts, user sees an error state.
-   * @default 3
-   */
-  maxOtpAttempts?: number;
-};
-//#endregion
-//#region src/modules/email/emailStateMachine.d.ts
-
-declare const emailMachine: any;
-//#endregion
-//#region src/modules/email/emailActor.d.ts
-type CreateEmailActorOptions = {
-  config: EmailConfig;
-};
-//#endregion
-//#region src/modules/email/emailManager.d.ts
-/** Email manager is in initial state, waiting for `load()` to be called */
-type EmailIdleState = {
-  status: 'idle';
-};
-/** Loading prefilled email address from backend (if prefill is enabled) */
-type EmailLoadingPrefillState = {
-  status: 'loadingPrefill';
-};
-/**
- * Ready for email input - use `setEmail()` and `submit()`
- * @property prefilledEmail - Pre-populated email address (if prefill enabled)
- * @property emailError - Validation error message if email was rejected
- */
-type EmailInputtingState = {
-  status: 'inputting';
-  prefilledEmail?: string;
-  emailError?: string;
-};
-/** Email address is being submitted to the backend */
-type EmailSubmittingState = {
-  status: 'submitting';
-};
-/** OTP is being sent to the email address */
-type EmailSendingOtpState = {
-  status: 'sendingOtp';
-};
-/**
- * Waiting for OTP code - use `submitOtp()`, `resendOtp()`, or `back()`
- * @property resendTimer - Seconds remaining before resend is allowed
- * @property canResend - Whether the resend button should be enabled
- * @property attemptsRemaining - Number of OTP verification attempts left
- */
-type EmailAwaitingOtpState = {
-  status: 'awaitingOtp';
-  resendTimer: number;
-  canResend: boolean;
-  attemptsRemaining: number;
-};
-/** OTP code is being verified against the backend */
-type EmailVerifyingOtpState = {
-  status: 'verifyingOtp';
-};
-/**
- * OTP verification failed - user can retry with `submitOtp()`
- * @property error - Error message describing why verification failed
- * @property attemptsRemaining - Number of remaining attempts before lockout
- */
-type EmailOtpErrorState = {
-  status: 'otpError';
-  error: string;
-  attemptsRemaining: number;
-};
-/** Email verification completed successfully - call `reset()` to start over */
-type EmailSuccessState = {
-  status: 'success';
-};
-/**
- * Fatal error occurred - call `reset()` to start over
- * @property error - Error message describing what went wrong
- */
-type EmailErrorState = {
-  status: 'error';
-  error: string;
-};
-/**
- * Union of all possible email manager states.
- * Use discriminated union pattern to narrow the type:
- *
- * @example
- * ```typescript
- * const state = emailManager.getState();
- * if (state.status === 'inputting') {
- *   // TypeScript knows state has prefilledEmail, emailError, etc.
- *   console.log(state.prefilledEmail);
- * }
- * ```
- */
-type EmailState = EmailIdleState | EmailLoadingPrefillState | EmailInputtingState | EmailSubmittingState | EmailSendingOtpState | EmailAwaitingOtpState | EmailVerifyingOtpState | EmailOtpErrorState | EmailSuccessState | EmailErrorState;
-/**
- * Creates an email verification manager for headless or UI-driven usage.
- *
- * The manager provides a state machine-based API for email address verification
- * with optional OTP (one-time password) verification.
- *
- * @param options - Configuration options
- * @param options.config - Email verification configuration
- * @param options.config.otpVerification - Whether to require OTP verification
- * @param options.config.otpExpirationInMinutes - How long the OTP is valid
- * @param options.config.prefill - Whether to fetch a pre-filled email address
- * @param options.config.maxOtpAttempts - Maximum OTP verification attempts (default: 3)
- *
- * @returns Email manager with state, API methods, and subscription
- *
- * @example Headless usage
- * ```typescript
- * const manager = createEmailManager({
- *   config: { otpVerification: true, otpExpirationInMinutes: 5, prefill: false },
- * });
- *
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * manager.setEmail('user@example.com', true);
- * manager.submit();
- * // ... wait for 'awaitingOtp' state ...
- * manager.submitOtp('ABC123');
- * manager.stop();
- * ```
- *
- * @example With React/Preact UI hook
- * ```tsx
- * const [state, manager] = useManager(() => createEmailManager({ config }));
- *
- * if (state.status === 'inputting') {
- *   return <input onChange={(e) => manager.setEmail(e.target.value, true)} />;
- * }
- * ```
- */
-declare function createEmailManager(options: CreateEmailActorOptions): Manager<EmailState> & {
-  /**
-   * Initializes the email verification flow.
-   * Transitions from 'idle' to 'loadingPrefill' or 'inputting'.
-   * Must be called before any other method.
-   */
-  load(): void;
-  /**
-   * Sets the email address for verification.
-   * Should be called when state is 'inputting'.
-   *
-   * @param email - Email address (e.g., 'user@example.com')
-   * @param isValid - Whether the email address passes validation
-   *
-   * @example
-   * ```typescript
-   * // Using regex for validation
-   * const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-   * const email = 'user@example.com';
-   * emailManager.setEmail(email, emailRegex.test(email));
-   * ```
-   */
-  setEmail(email: string, isValid: boolean): void;
-  /**
-   * Submits the email address for verification.
-   * Requires a valid email address to be set via `setEmail()`.
-   * Transitions to 'submitting', then to 'sendingOtp' or 'success' (if no OTP).
-   */
-  submit(): void;
-  /**
-   * Sets the OTP code without submitting.
-   * Use this for controlled input components.
-   *
-   * @param code - The OTP code entered by the user
-   */
-  setOtpCode(code: string): void;
-  /**
-   * Sets and submits the OTP code in one call.
-   * Should be called when state is 'awaitingOtp' or 'otpError'.
-   *
-   * @param code - The complete OTP code (typically 6 alphanumeric characters)
-   *
-   * @example
-   * ```typescript
-   * // Submit OTP when user completes entry
-   * emailManager.submitOtp('HH36LP');
-   * ```
-   */
-  submitOtp(code: string): void;
-  /**
-   * Requests a new OTP code to be sent.
-   * Only works when state is 'awaitingOtp' and `canResend` is true.
-   * Resets the resend timer.
-   */
-  resendOtp(): void;
-  /**
-   * Returns to the email input screen from OTP entry.
-   * Allows the user to change their email address.
-   * Transitions from 'awaitingOtp' or 'otpError' back to 'inputting'.
-   */
-  back(): void;
-  /**
-   * Resets the manager to initial state.
-   * Can be called from 'success' or 'error' states to start over.
-   * Clears all stored data including email address and OTP.
-   */
-  reset(): void;
-};
-/**
- * Type representing an email manager instance.
- * Includes state access, API methods, and lifecycle management.
- *
- * @property getState - Returns the current EmailState
- * @property subscribe - Subscribes to state changes, returns unsubscribe function
- * @property stop - Stops the manager and cleans up resources
- * @property load - Initializes the verification flow
- * @property setEmail - Sets the email address
- * @property submit - Submits the email address
- * @property setOtpCode - Sets OTP code without submitting
- * @property submitOtp - Sets and submits OTP code
- * @property resendOtp - Requests new OTP code
- * @property back - Returns to email input from OTP screen
- * @property reset - Resets to initial state
- */
-type EmailManager = ReturnType<typeof createEmailManager>;
-//#endregion
+import "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import { a as emailMachine, n as EmailState, o as EmailConfig, r as createEmailManager, t as EmailManager } from "./emailManager-DIfnS5g1.js";
 export { type EmailConfig, type EmailManager, type EmailState, createEmailManager, emailMachine };