@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/addressSearch-BpTbTWCa.esm.js

@@ -0,0 +1,430 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { i as fromCallback } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/shared/usStates.ts
+const usStates = {
+	AL: {
+		code: "AL",
+		name: "Alabama"
+	},
+	AK: {
+		code: "AK",
+		name: "Alaska"
+	},
+	AZ: {
+		code: "AZ",
+		name: "Arizona"
+	},
+	AR: {
+		code: "AR",
+		name: "Arkansas"
+	},
+	CA: {
+		code: "CA",
+		name: "California"
+	},
+	CO: {
+		code: "CO",
+		name: "Colorado"
+	},
+	CT: {
+		code: "CT",
+		name: "Connecticut"
+	},
+	DE: {
+		code: "DE",
+		name: "Delaware"
+	},
+	FL: {
+		code: "FL",
+		name: "Florida"
+	},
+	GA: {
+		code: "GA",
+		name: "Georgia"
+	},
+	HI: {
+		code: "HI",
+		name: "Hawaii"
+	},
+	ID: {
+		code: "ID",
+		name: "Idaho"
+	},
+	IL: {
+		code: "IL",
+		name: "Illinois"
+	},
+	IN: {
+		code: "IN",
+		name: "Indiana"
+	},
+	IA: {
+		code: "IA",
+		name: "Iowa"
+	},
+	KS: {
+		code: "KS",
+		name: "Kansas"
+	},
+	KY: {
+		code: "KY",
+		name: "Kentucky"
+	},
+	LA: {
+		code: "LA",
+		name: "Louisiana"
+	},
+	ME: {
+		code: "ME",
+		name: "Maine"
+	},
+	MD: {
+		code: "MD",
+		name: "Maryland"
+	},
+	MA: {
+		code: "MA",
+		name: "Massachusetts"
+	},
+	MI: {
+		code: "MI",
+		name: "Michigan"
+	},
+	MN: {
+		code: "MN",
+		name: "Minnesota"
+	},
+	MS: {
+		code: "MS",
+		name: "Mississippi"
+	},
+	MO: {
+		code: "MO",
+		name: "Missouri"
+	},
+	MT: {
+		code: "MT",
+		name: "Montana"
+	},
+	NE: {
+		code: "NE",
+		name: "Nebraska"
+	},
+	NV: {
+		code: "NV",
+		name: "Nevada"
+	},
+	NH: {
+		code: "NH",
+		name: "New Hampshire"
+	},
+	NJ: {
+		code: "NJ",
+		name: "New Jersey"
+	},
+	NM: {
+		code: "NM",
+		name: "New Mexico"
+	},
+	NY: {
+		code: "NY",
+		name: "New York"
+	},
+	NC: {
+		code: "NC",
+		name: "North Carolina"
+	},
+	ND: {
+		code: "ND",
+		name: "North Dakota"
+	},
+	OH: {
+		code: "OH",
+		name: "Ohio"
+	},
+	OK: {
+		code: "OK",
+		name: "Oklahoma"
+	},
+	OR: {
+		code: "OR",
+		name: "Oregon"
+	},
+	PA: {
+		code: "PA",
+		name: "Pennsylvania"
+	},
+	RI: {
+		code: "RI",
+		name: "Rhode Island"
+	},
+	SC: {
+		code: "SC",
+		name: "South Carolina"
+	},
+	SD: {
+		code: "SD",
+		name: "South Dakota"
+	},
+	TN: {
+		code: "TN",
+		name: "Tennessee"
+	},
+	TX: {
+		code: "TX",
+		name: "Texas"
+	},
+	UT: {
+		code: "UT",
+		name: "Utah"
+	},
+	VT: {
+		code: "VT",
+		name: "Vermont"
+	},
+	VA: {
+		code: "VA",
+		name: "Virginia"
+	},
+	WA: {
+		code: "WA",
+		name: "Washington"
+	},
+	WV: {
+		code: "WV",
+		name: "West Virginia"
+	},
+	WI: {
+		code: "WI",
+		name: "Wisconsin"
+	},
+	WY: {
+		code: "WY",
+		name: "Wyoming"
+	}
+};
+const usStateOptions = Object.values(usStates).map((state) => ({
+	value: state.code,
+	label: state.name
+}));
+
+//#endregion
+//#region src/shared/postalCode.ts
+const DEFAULT_POSTAL_CODE_MAX_LENGTH = 8;
+const POSTAL_CODE_MAX_LENGTH_BY_COUNTRY = {
+	US: 10,
+	BR: 9,
+	GB: 8,
+	UK: 8,
+	AR: 8,
+	CA: 7,
+	IL: 7,
+	CN: 6,
+	NG: 6,
+	DE: 5,
+	ES: 5,
+	FR: 5,
+	IT: 5,
+	KE: 5,
+	MX: 5
+};
+const POSTAL_CODE_FORMAT_ERROR_KEYS = new Set([
+	"verification.errors.zipCodeInvalidFormat",
+	"verification.errors.postalCodeInvalidFormat",
+	"verification.errors.invalidPostalCodeFixedLength",
+	"verification.errors.CAPostalCodeInvalidFormat",
+	"verification.errors.UKPostalCodeInvalidFormat",
+	"verification.errors.ARPostalCodeInvalidFormat"
+]);
+const FIXED_LENGTH_KEY = "verification.errors.invalidPostalCodeFixedLength";
+const FIXED_DIGIT_POSTAL_CODE_LENGTH = {
+	DE: 5,
+	ES: 5,
+	FR: 5,
+	IT: 5,
+	KE: 5,
+	MX: 5,
+	CN: 6,
+	NG: 6,
+	IL: 7
+};
+function getPostalCodeMaxLength(country) {
+	return POSTAL_CODE_MAX_LENGTH_BY_COUNTRY[country] ?? DEFAULT_POSTAL_CODE_MAX_LENGTH;
+}
+function getPostalCodeErrorKey(country) {
+	if (country in FIXED_DIGIT_POSTAL_CODE_LENGTH) return FIXED_LENGTH_KEY;
+	if (country === "CA") return "verification.errors.CAPostalCodeInvalidFormat";
+	if (country === "AR") return "verification.errors.ARPostalCodeInvalidFormat";
+	if (country === "GB" || country === "UK") return "verification.errors.UKPostalCodeInvalidFormat";
+	if (country === "US") return "verification.errors.zipCodeInvalidFormat";
+	return "verification.errors.postalCodeInvalidFormat";
+}
+const US_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{9}|\d{5}-\d{4})$/;
+const BR_POSTAL_CODE_REGEX = /^(?:\d{5}|\d{8}|\d{5}-\d{3})$/;
+const CA_POSTAL_CODE_REGEX = /^[A-Za-z]\d[A-Za-z] \d[A-Za-z]\d$/;
+const UK_POSTAL_CODE_REGEX = /^(?:[A-Z]{2}\d|[A-Z]{2}\d{2}|[A-Z]\d|[A-Z]\d{2}|[A-Z]\d[A-Z]|[A-Z]{2}\d[A-Z]) \d[A-Z]{2}$/;
+const AR_POSTAL_CODE_REGEX = /^[A-Za-z]\d{4}[A-Za-z]{3}$/;
+const FIVE_DIGIT_REGEX = /^\d{5}$/;
+const SIX_DIGIT_REGEX = /^\d{6}$/;
+const IL_POSTAL_CODE_REGEX = /^\d{7}$/;
+/**
+* Validates a postal code by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function validatePostalCode(postalCode, country) {
+	if (!postalCode) return false;
+	switch (country) {
+		case "US": return US_POSTAL_CODE_REGEX.test(postalCode);
+		case "BR": return BR_POSTAL_CODE_REGEX.test(postalCode);
+		case "CA": return CA_POSTAL_CODE_REGEX.test(postalCode);
+		case "GB":
+		case "UK": return UK_POSTAL_CODE_REGEX.test(postalCode.toUpperCase());
+		case "AR": return AR_POSTAL_CODE_REGEX.test(postalCode.replace(/\s/g, "").toUpperCase());
+		case "IL": return IL_POSTAL_CODE_REGEX.test(postalCode);
+		case "CN":
+		case "NG": return SIX_DIGIT_REGEX.test(postalCode);
+		case "DE":
+		case "FR":
+		case "IT":
+		case "ES":
+		case "MX":
+		case "KE": return FIVE_DIGIT_REGEX.test(postalCode);
+		case "CM": return postalCode.length > 0;
+		default: {
+			const stripped = postalCode.replace(/\D/g, "");
+			return /^\d+$/.test(stripped) && [5, DEFAULT_POSTAL_CODE_MAX_LENGTH].includes(stripped.length);
+		}
+	}
+}
+/**
+* Progressively formats postal code input by country.
+* Covers all countries used by eKYC and eKYB.
+*/
+function formatPostalCode(value, country) {
+	if (country === "US" || country === "BR") {
+		const maxDigits = country === "US" ? 9 : 8;
+		const hasDash = value.includes("-");
+		const digits = value.replace(/\D/g, "").slice(0, maxDigits);
+		if (digits.length <= 5) {
+			if (hasDash && digits.length === 5) return `${digits}-`;
+			return digits;
+		}
+		if (hasDash) return `${digits.slice(0, 5)}-${digits.slice(5)}`;
+		return digits;
+	}
+	if (country === "ES") return value.replace(/\D/g, "").slice(0, 5);
+	if (country === "CA") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 6);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, 3)} ${normalized.slice(3)}`;
+	}
+	if (country === "GB" || country === "UK") {
+		const normalized = value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 7);
+		if (normalized.length <= 3) return normalized;
+		return `${normalized.slice(0, -3)} ${normalized.slice(-3)}`;
+	}
+	if (country === "AR") return value.replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 8);
+	if (country === "IL") return value.replace(/\D/g, "").slice(0, 7);
+	if (country === "CN" || country === "NG") return value.replace(/\D/g, "").slice(0, 6);
+	if (country === "DE" || country === "FR" || country === "IT" || country === "MX" || country === "KE") return value.replace(/\D/g, "").slice(0, 5);
+	return value.slice(0, DEFAULT_POSTAL_CODE_MAX_LENGTH);
+}
+
+//#endregion
+//#region src/shared/displayErrors.ts
+const DYNAMIC_REQUIRED_KEY = "verification.errors.fieldRequiredDynamic";
+
+//#endregion
+//#region src/shared/addressSuggestion.ts
+/**
+* Fills form values from an address autocomplete suggestion.
+* Shared between eKYC and eKYB address forms.
+*/
+function fillFromSuggestion(values, touched, suggestion, activeFields) {
+	const newValues = { ...values };
+	const newTouched = { ...touched };
+	const hasHouseNoField = !activeFields || activeFields.has("houseNo");
+	const streetValue = buildStreetValue(suggestion.street, suggestion.houseNumber, hasHouseNoField);
+	if (streetValue) {
+		newValues.street = streetValue;
+		newTouched.street = true;
+	}
+	if (suggestion.city) {
+		newValues.city = suggestion.city;
+		newTouched.city = true;
+	}
+	if (suggestion.stateCode) {
+		newValues.state = suggestion.stateCode;
+		newTouched.state = true;
+	}
+	if (suggestion.postalCode) {
+		newValues.postalCode = suggestion.postalCode;
+		newTouched.postalCode = true;
+	}
+	if (suggestion.houseNumber && hasHouseNoField) {
+		newValues.houseNo = suggestion.houseNumber;
+		newTouched.houseNo = true;
+	}
+	return {
+		values: newValues,
+		touched: newTouched
+	};
+}
+function buildStreetValue(street, houseNumber, hasHouseNoField) {
+	if (hasHouseNoField) return street ?? "";
+	if (houseNumber && street) return `${houseNumber} ${street}`;
+	return houseNumber ?? street ?? "";
+}
+
+//#endregion
+//#region src/shared/addressSearch.ts
+/** Searches for address suggestions via the address autocomplete API. */
+async function searchAddress(query, signal) {
+	const res = await api.post(endpoints.addressAutocomplete, { search: query }, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.addressAutocomplete} failed: ${res.status} ${res.statusText}`);
+	return { apiResponse: { items: (res.data.apiResponse?.items ?? []).map((item, i) => {
+		const addr = item.address ?? item;
+		return {
+			id: item.id ?? i,
+			label: addr.label ?? item.title ?? "",
+			street: addr.street,
+			city: addr.city,
+			stateCode: addr.stateCode ?? addr.state,
+			postalCode: addr.postalCode,
+			houseNumber: addr.houseNumber,
+			countryCode: addr.countryCode
+		};
+	}) } };
+}
+const DEBOUNCE_MS = 300;
+/**
+* XState callback actor that debounces address search requests.
+* Cancels in-flight HTTP requests when the actor is stopped.
+*/
+const debounceSearchActor = fromCallback(({ input, sendBack }) => {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	const controller = new AbortController();
+	const handle = timerProvider.setTimeout(async () => {
+		try {
+			sendBack({
+				type: "RESULTS",
+				suggestions: (await searchAddress(input.query, controller.signal)).apiResponse?.items ?? []
+			});
+		} catch {
+			if (!controller.signal.aborted) sendBack({
+				type: "RESULTS",
+				suggestions: []
+			});
+		}
+	}, DEBOUNCE_MS);
+	return () => {
+		timerProvider.clearTimeout(handle);
+		controller.abort();
+	};
+});
+
+//#endregion
+export { POSTAL_CODE_FORMAT_ERROR_KEYS as a, getPostalCodeMaxLength as c, FIXED_DIGIT_POSTAL_CODE_LENGTH as i, validatePostalCode as l, fillFromSuggestion as n, formatPostalCode as o, DYNAMIC_REQUIRED_KEY as r, getPostalCodeErrorKey as s, debounceSearchActor as t, usStateOptions as u };

package/dist/ae-signature-DDDZmWXj.esm.js

@@ -0,0 +1,12 @@
+import { t as createElectronicSignatureManager } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+
+//#region src/modules/ae-signature/index.ts
+function createAeSignatureManager(options) {
+	return createElectronicSignatureManager({ config: {
+		...options.config,
+		variant: "ae"
+	} });
+}
+
+//#endregion
+export { createAeSignatureManager as t };

package/dist/ae-signature.d.ts

@@ -0,0 +1,25 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import { a as AE_CONSENT_KEYS, c as ConsentKey, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-DZoqeAo9.js";
+
+//#region src/modules/ae-signature/index.d.ts
+
+type AeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
+declare function createAeSignatureManager(options: {
+  config: AeSignatureConfig;
+}): Manager<ElectronicSignatureState> & {
+  load(): void;
+  setConsent(name: ConsentKey, checked: boolean): void;
+  selectFile(fileName: string, fileData: ArrayBuffer, fileUrl: string): void;
+  replaceFile(): void;
+  confirmFile(): void;
+  viewDocument(url: string): void;
+  closeDocumentView(): void;
+  sign(): void;
+  finish(): void;
+  retry(): void;
+  close(): void;
+};
+type AeSignatureManager = ReturnType<typeof createAeSignatureManager>;
+//#endregion
+export { AE_CONSENT_KEYS, AeSignatureConfig, type ElectronicSignatureDocument as AeSignatureDocument, AeSignatureManager, type ElectronicSignatureState as AeSignatureState, type ConsentChecks, electronicSignatureMachine as aeSignatureMachine, areAllConsented, createAeSignatureManager, getDefaultConsentChecks };

package/dist/ae-signature.esm.js

@@ -0,0 +1,8 @@
+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, n as electronicSignatureMachine, r as AE_CONSENT_KEYS, s as getDefaultConsentChecks } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+import { t as createAeSignatureManager } from "./ae-signature-DDDZmWXj.esm.js";
+
+export { AE_CONSENT_KEYS, electronicSignatureMachine as aeSignatureMachine, areAllConsented, createAeSignatureManager, getDefaultConsentChecks };

package/dist/antifraud.d.ts

@@ -0,0 +1,57 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/antifraud/antifraudManager.d.ts
+type AntifraudIdleState = {
+  status: 'idle';
+};
+type AntifraudProcessingState = {
+  status: 'processing';
+};
+type AntifraudFinishedState = {
+  status: 'finished';
+};
+/**
+ * Union of all possible antifraud manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = antifraudManager.getState();
+ * if (state.status === 'finished') {
+ *   console.log('Antifraud check complete');
+ * }
+ * ```
+ */
+type AntifraudState = AntifraudIdleState | AntifraudProcessingState | AntifraudFinishedState;
+/**
+ * Creates an antifraud manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createAntifraudManager();
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * ```
+ */
+declare function createAntifraudManager(): Manager<AntifraudState> & {
+  /**
+   * Kicks off the antifraud process.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+type AntifraudManager = ReturnType<typeof createAntifraudManager>;
+//#endregion
+//#region src/modules/antifraud/antifraudStateMachine.d.ts
+declare const antifraudMachine: any;
+//#endregion
+//#region src/modules/antifraud/types.d.ts
+/**
+ * Configuration options for the antifraud module.
+ *
+ * The antifraud module requires no configuration — it is a fire-and-forget
+ * process that runs the backend antifraud check and completes regardless of
+ * the API outcome.
+ */
+type AntifraudConfig = Record<string, never>;
+//#endregion
+export { type AntifraudConfig, type AntifraudManager, type AntifraudState, antifraudMachine, createAntifraudManager };

package/dist/antifraud.esm.js

@@ -0,0 +1,45 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-O0TMf6yc.esm.js";
+
+//#region src/modules/antifraud/antifraudActor.ts
+function createAntifraudActor() {
+	return createActor(antifraudMachine).start();
+}
+
+//#endregion
+//#region src/modules/antifraud/antifraudManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+/**
+* Creates an antifraud manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createAntifraudManager();
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* ```
+*/
+function createAntifraudManager() {
+	return createManager({
+		actor: createAntifraudActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.antifraud)
+	});
+}
+
+//#endregion
+export { antifraudMachine, createAntifraudManager };

package/dist/antifraudStateMachine-O0TMf6yc.esm.js

@@ -0,0 +1,39 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/antifraud/antifraudServices.ts
+async function processAntifraud(signal) {
+	const res = await api.get(endpoints.processAntifraud, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.processAntifraud} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/antifraud/antifraudStateMachine.ts
+const antifraudMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processAntifraud: fromPromise(async ({ signal }) => {
+		return processAntifraud(signal);
+	}) }
+}).createMachine({
+	id: "antifraud",
+	initial: "idle",
+	context: {},
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processAntifraud",
+			src: "processAntifraud",
+			onDone: { target: "finished" },
+			onError: { target: "finished" }
+		} },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { antifraudMachine as t };

package/dist/api-CESGtpbH.esm.js

@@ -0,0 +1,53 @@
+//#region src/internal/http/api.ts
+let client = null;
+let currentToken = null;
+function setClient(httpClient) {
+	client = httpClient;
+}
+function setToken(token) {
+	currentToken = token;
+}
+function getToken() {
+	return currentToken;
+}
+function getApi() {
+	if (!client) throw new Error("SDK not configured. Call setup({ apiURL: \"...\" }) first.");
+	return client;
+}
+function isApiConfigured() {
+	return client !== null;
+}
+function resetApi() {
+	client = null;
+	currentToken = null;
+}
+function addTokenHeader(config) {
+	if (!currentToken) return config ?? {};
+	return {
+		...config,
+		headers: {
+			...config?.headers,
+			"X-Incode-Hardware-Id": currentToken
+		}
+	};
+}
+const api = {
+	get(url, config) {
+		return getApi().get(url, addTokenHeader(config));
+	},
+	post(url, data, config) {
+		return getApi().post(url, data, addTokenHeader(config));
+	},
+	put(url, data, config) {
+		return getApi().put(url, data, addTokenHeader(config));
+	},
+	patch(url, data, config) {
+		return getApi().patch(url, data, addTokenHeader(config));
+	},
+	delete(url, config) {
+		return getApi().delete(url, addTokenHeader(config));
+	}
+};
+
+//#endregion
+export { resetApi as a, isApiConfigured as i, getApi as n, setClient as o, getToken as r, setToken as s, api as t };

package/dist/authentication.d.ts

@@ -0,0 +1,12 @@
+import "./warmup-CEcppFiS.js";
+import "./Manager-C8PrhBOx.js";
+import "./Actor-CI32dTbG.js";
+import "./StateMachine-BCQrZJhf.js";
+import { D as authenticationMachine, S as AuthenticationConfig, b as CreateAuthenticationActorOptions, x as createAuthenticationActor, y as AuthenticationActor } from "./faceCaptureManagerFactory-yqtpxjnN.js";
+import "./camera-DBSxa6ML.js";
+import "./types-CFV9G_7j.js";
+import "./types-BP1m8VRw.js";
+import "./deepsightService-CEVxzehb.js";
+import "./types-CAD4va6a.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-C83GNIhl.js";
+export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };