@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/camera-DUkgmYMo.esm.js

@@ -0,0 +1,79 @@
+//#region ../infra/src/media/camera.ts
+/**
+* Default resolution fallback order for camera access.
+* Tries each resolution in order until one succeeds.
+* Matches legacy behavior from Webcam.tsx
+*/
+const DEFAULT_RESOLUTION_FALLBACKS = [
+	{ height: 720 },
+	{
+		width: 3840,
+		height: 2160
+	},
+	{
+		width: 1920,
+		height: 1080
+	},
+	{
+		width: 640,
+		height: 480
+	},
+	{
+		width: 800,
+		height: 480
+	},
+	{}
+];
+/**
+* Request camera access with specific constraints.
+* Throws if the request fails - no automatic fallback.
+*/
+async function requestCameraAccess(constraints) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	return navigator.mediaDevices.getUserMedia(constraints);
+}
+/**
+* Request camera access with automatic resolution fallback.
+* Tries progressively different resolutions if the initial request fails.
+*
+* @param baseConstraints - Base constraints (facingMode, audio, etc.)
+* @param fallbacks - Optional custom fallback order (defaults to 720p -> 1080p -> 480p -> auto)
+* @returns MediaStream from the camera
+* @throws Error if all fallbacks fail or MediaDevices API not available
+*/
+async function requestCameraWithFallback(baseConstraints, fallbacks = DEFAULT_RESOLUTION_FALLBACKS) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	const baseVideo = baseConstraints.video;
+	for (let i = 0; i < fallbacks.length; i++) {
+		const resolution = fallbacks[i];
+		const videoConstraints = { ...baseVideo };
+		if (resolution.width) videoConstraints.width = { ideal: resolution.width };
+		if (resolution.height) videoConstraints.height = { ideal: resolution.height };
+		if (!resolution.width && !resolution.height) {
+			delete videoConstraints.width;
+			delete videoConstraints.height;
+		}
+		try {
+			return await navigator.mediaDevices.getUserMedia({
+				...baseConstraints,
+				video: videoConstraints
+			});
+		} catch (error) {
+			if (i === fallbacks.length - 1) throw error;
+		}
+	}
+	throw new Error("All camera resolution fallbacks failed");
+}
+function stopCameraStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+async function enumerateVideoDevices() {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) return [];
+	return (await navigator.mediaDevices.enumerateDevices()).filter((d) => d.kind === "videoinput");
+}
+async function applyTrackConstraints(track, constraints) {
+	await track.applyConstraints(constraints);
+}
+
+//#endregion
+export { stopCameraStream as a, requestCameraWithFallback as i, enumerateVideoDevices as n, requestCameraAccess as r, applyTrackConstraints as t };

package/dist/camera.d.ts

@@ -1,8 +1,14 @@
-import { n as PermissionStatus, t as PermissionResult } from "./types-ya0LN_MX.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-Duy2rDxF.js";
 
 //#region src/internal/permissions/permissionServices.d.ts
 type RequestPermissionOptions = {
   requestMotion?: boolean;
+  /**
+   * Also request microphone access in the same `getUserMedia` call. Used by
+   * Video Selfie, which records audio alongside video. Defaults to `false` so
+   * camera-only flows (selfie, ID) keep requesting `{ video: true }` exactly.
+   */
+  requestAudio?: boolean;
 };
 declare function checkPermission(): Promise<PermissionResult>;
 /**

package/dist/camera.esm.js

@@ -1,6 +1,6 @@
-import "./WasmUtilProvider-BKWm8rSA.esm.js";
-import "./MotionSensorProvider-Bx7Mpzt0.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-Doec4X5L.esm.js";
-import "./camera-DJWm3V4g.esm.js";
+import "./WasmUtilProvider-ADG54T6M.esm.js";
+import "./MotionSensorProvider-DCbId4De.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-BJhGL13R.esm.js";
+import "./camera-DUkgmYMo.esm.js";
 
 export { checkPermission as checkCameraPermission, requestPermission as requestCameraPermission };

package/dist/{StreamCanvasCapture-yyl20qd9.d.ts → canvas-CJUmoXSD.d.ts}

@@ -1,5 +1,3 @@
-import { t as CameraStream } from "./camera-SRBpPq2X.js";
-
 //#region ../infra/src/media/canvas.d.ts
 /**
  * Class representing a canvas element for image capture and manipulation.
@@ -111,42 +109,4 @@ declare class IncodeCanvas {
   getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
 }
 //#endregion
-//#region ../infra/src/media/StreamCanvasCapture.d.ts
-type StreamCanvasCaptureOptions = {
-  fps?: number;
-  width?: number;
-  height?: number;
-};
-type StreamCanvasCaptureEventMap = {
-  frame: Event;
-};
-declare class StreamCanvasCapture {
-  private video;
-  private canvas;
-  private ctx;
-  private rafId;
-  private lastFrameTimeSeconds;
-  private lastTickTimeMs;
-  private hasFrame;
-  private disposed;
-  private eventTarget;
-  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
-  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-  /**
-   * Returns the latest cached frame as an {@link IncodeCanvas}.
-   */
-  getLatestCanvas(): IncodeCanvas | null;
-  /**
-   * Returns the latest cached frame as raw {@link ImageData}.
-   */
-  getLatestFrame(): ImageData | null;
-  /**
-   * Disposes internal resources and stops the capture loop.
-   */
-  dispose(): void;
-  private rafLoop;
-  private tick;
-}
-//#endregion
-export { IncodeCanvas as n, StreamCanvasCapture as t };
+export { IncodeCanvas as t };

package/dist/certificate-issuance.d.ts

@@ -0,0 +1,312 @@
+import "./StateMachine-C_AY4cs7.js";
+import { t as Manager } from "./Manager-CJ3G2zqi.js";
+import "./Actor-CGEelYtQ.js";
+import * as xstate1374 from "xstate";
+
+//#region src/modules/certificate-issuance/certificateIssuanceConstants.d.ts
+declare const MIN_PASSWORD_LENGTH = 8;
+declare const PASSWORD_VALIDATION_KEYS: readonly ["length", "uppercase", "lowercase", "number"];
+declare const REQUIREMENT_I18N_KEYS: Record<PasswordValidationKey, string>;
+//#endregion
+//#region src/modules/certificate-issuance/types.d.ts
+type CertificateIssuanceType = 'ONE_TIME' | 'SHORT_TERM' | 'LONG_TERM';
+/**
+ * Configuration for the certificate issuance module.
+ */
+type CertificateIssuanceConfig = {
+  /** Issuance region (from flow `moduleConfiguration`) */
+  region: string;
+  /** Certificate validity period */
+  type: CertificateIssuanceType;
+};
+type IssueCertificateResponse = {
+  blob: Blob;
+};
+type PasswordValidations = {
+  length: boolean;
+  uppercase: boolean;
+  lowercase: boolean;
+  number: boolean;
+};
+type PasswordValidationKey = (typeof PASSWORD_VALIDATION_KEYS)[number];
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceStateMachine.d.ts
+type CertificateIssuanceContext = {
+  config: CertificateIssuanceConfig;
+  password: string;
+  passwordValidations: PasswordValidations;
+  certificateBlob: Blob | undefined;
+};
+type CertificateIssuanceInput = {
+  config: CertificateIssuanceConfig;
+};
+declare const certificateIssuanceMachine: xstate1374.StateMachine<CertificateIssuanceContext, {
+  type: "LOAD";
+} | {
+  type: "PASSWORD_CHANGED";
+  password: string;
+} | {
+  type: "SUBMIT_PASSWORD";
+} | {
+  type: "DOWNLOADED";
+} | {
+  type: "DOWNLOAD_FAILED";
+} | {
+  type: "FINISH";
+}, {
+  [x: string]: xstate1374.ActorRefFromLogic<xstate1374.PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, xstate1374.EventObject>> | undefined;
+}, {
+  src: "issueCertificate";
+  logic: xstate1374.PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, xstate1374.EventObject>;
+  id: string | undefined;
+}, xstate1374.Values<{
+  setPassword: {
+    type: "setPassword";
+    params: xstate1374.NonReducibleUnknown;
+  };
+  setBlob: {
+    type: "setBlob";
+    params: xstate1374.NonReducibleUnknown;
+  };
+}>, {
+  type: "isPasswordValid";
+  params: unknown;
+}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, xstate1374.NonReducibleUnknown, xstate1374.EventObject, xstate1374.MetaObject, {
+  readonly id: "certificateIssuance";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "issueCertificate">(logic: TSrc, ...[options]: {
+        src: "issueCertificate";
+        logic: xstate1374.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate1374.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "issueCertificate";
+        logic: xstate1374.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate1374.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate1374.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate1374.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1374.RequiredActorOptions<T>]: unknown }) | undefined], xstate1374.IsNotNever<xstate1374.RequiredActorOptions<T>>> : never : never : never): xstate1374.ActorRefFromLogic<xstate1374.GetConcreteByKey<{
+        src: "issueCertificate";
+        logic: xstate1374.PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, xstate1374.EventObject>;
+        id: string | undefined;
+      }, "src", TSrc>["logic"]>;
+      <TLogic extends xstate1374.AnyActorLogic>(src: TLogic, ...[options]: xstate1374.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate1374.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1374.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1374.IsNotNever<xstate1374.RequiredLogicInput<TLogic>>>): xstate1374.ActorRefFromLogic<TLogic>;
+    };
+    input: CertificateIssuanceInput;
+    self: xstate1374.ActorRef<xstate1374.MachineSnapshot<CertificateIssuanceContext, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, Record<string, xstate1374.AnyActorRef | undefined>, xstate1374.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, xstate1374.AnyEventObject>;
+  }) => {
+    config: CertificateIssuanceConfig;
+    password: string;
+    passwordValidations: PasswordValidations;
+    certificateBlob: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "password";
+        };
+      };
+    };
+    readonly password: {
+      readonly on: {
+        readonly PASSWORD_CHANGED: {
+          readonly actions: "setPassword";
+        };
+        readonly SUBMIT_PASSWORD: {
+          readonly target: "processing";
+          readonly guard: "isPasswordValid";
+        };
+      };
+    };
+    readonly processing: {
+      readonly invoke: {
+        readonly id: "issueCertificate";
+        readonly src: "issueCertificate";
+        readonly input: ({
+          context
+        }: {
+          context: CertificateIssuanceContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          };
+          self: xstate1374.ActorRef<xstate1374.MachineSnapshot<CertificateIssuanceContext, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, Record<string, xstate1374.AnyActorRef>, xstate1374.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, xstate1374.AnyEventObject>;
+        }) => {
+          password: string;
+        };
+        readonly onDone: {
+          readonly target: "success";
+          readonly actions: "setBlob";
+        };
+        readonly onError: {
+          readonly target: "error";
+        };
+      };
+    };
+    readonly success: {
+      readonly on: {
+        readonly DOWNLOADED: {
+          readonly target: "downloaded";
+        };
+        readonly DOWNLOAD_FAILED: {
+          readonly target: "error";
+        };
+        readonly FINISH: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly downloaded: {
+      readonly on: {
+        readonly FINISH: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly error: {
+      readonly after: {
+        readonly 3000: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceActor.d.ts
+type CreateCertificateIssuanceActorOptions = {
+  config: CertificateIssuanceConfig;
+};
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceManager.d.ts
+type CertificateIssuanceIdleState = {
+  status: 'idle';
+};
+type CertificateIssuancePasswordState = {
+  status: 'password';
+  password: string;
+  passwordValidations: PasswordValidations;
+  canSubmit: boolean;
+};
+type CertificateIssuanceProcessingState = {
+  status: 'processing';
+};
+type CertificateIssuanceErrorState = {
+  status: 'error';
+};
+type CertificateIssuanceSuccessState = {
+  status: 'success';
+  blob: Blob;
+};
+type CertificateIssuanceDownloadedState = {
+  status: 'downloaded';
+};
+type CertificateIssuanceFinishedState = {
+  status: 'finished';
+};
+type CertificateIssuanceState = CertificateIssuanceIdleState | CertificateIssuancePasswordState | CertificateIssuanceProcessingState | CertificateIssuanceSuccessState | CertificateIssuanceDownloadedState | CertificateIssuanceErrorState | CertificateIssuanceFinishedState;
+declare function createCertificateIssuanceManager(options: CreateCertificateIssuanceActorOptions): Manager<CertificateIssuanceState> & {
+  load(): void;
+  setPassword(password: string): void;
+  submitPassword(): void;
+  markDownloaded(): void;
+  reportDownloadError(): void;
+  finish(): void;
+};
+type CertificateIssuanceManager = ReturnType<typeof createCertificateIssuanceManager>;
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceUtils.d.ts
+declare function emptyPasswordValidations(): PasswordValidations;
+declare function validatePassword(value: string): PasswordValidations;
+declare function isPasswordValid(validations: PasswordValidations): boolean;
+//#endregion
+export { type CertificateIssuanceConfig, type CertificateIssuanceManager, type CertificateIssuanceState, type CertificateIssuanceType, type IssueCertificateResponse, MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, type PasswordValidationKey, type PasswordValidations, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };

package/dist/certificate-issuance.esm.js

@@ -0,0 +1,74 @@
+import "./api-DsbUi7TO.esm.js";
+import { n as createManagerInstrumentation } from "./events-CqGY1yMq.esm.js";
+import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
+import "./endpoints-BzMJFAPV.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
+import "./urlUtils-BZqFU9rR.esm.js";
+import "./externalFetch-CyhBfD-n.esm.js";
+import { a as MIN_PASSWORD_LENGTH, i as validatePassword, n as emptyPasswordValidations, o as PASSWORD_VALIDATION_KEYS, r as isPasswordValid, s as REQUIREMENT_I18N_KEYS, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-C07m7qtP.esm.js";
+
+//#region src/modules/certificate-issuance/certificateIssuanceActor.ts
+/**
+* Creates and starts a certificate issuance actor.
+*/
+function createCertificateIssuanceActor(options) {
+	return createActor(certificateIssuanceMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("password")) return {
+		status: "password",
+		password: context.password,
+		passwordValidations: context.passwordValidations,
+		canSubmit: isPasswordValid(context.passwordValidations)
+	};
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("error")) return { status: "error" };
+	if (typedSnapshot.matches("success")) return {
+		status: "success",
+		blob: context.certificateBlob
+	};
+	if (typedSnapshot.matches("downloaded")) return { status: "downloaded" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setPassword(password) {
+			actor.send({
+				type: "PASSWORD_CHANGED",
+				password
+			});
+		},
+		submitPassword() {
+			actor.send({ type: "SUBMIT_PASSWORD" });
+		},
+		markDownloaded() {
+			actor.send({ type: "DOWNLOADED" });
+		},
+		reportDownloadError() {
+			actor.send({ type: "DOWNLOAD_FAILED" });
+		},
+		finish() {
+			actor.send({ type: "FINISH" });
+		}
+	};
+}
+function createCertificateIssuanceManager(options) {
+	return createManager({
+		actor: createCertificateIssuanceActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.certificateIssuance)
+	});
+}
+
+//#endregion
+export { MIN_PASSWORD_LENGTH, PASSWORD_VALIDATION_KEYS, REQUIREMENT_I18N_KEYS, certificateIssuanceMachine, createCertificateIssuanceManager, emptyPasswordValidations, isPasswordValid, validatePassword };

package/dist/certificateIssuanceStateMachine-C07m7qtP.esm.js

@@ -0,0 +1,127 @@
+import { n as getApi, r as getToken } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as externalFetch } from "./externalFetch-CyhBfD-n.esm.js";
+
+//#region src/modules/certificate-issuance/certificateIssuanceServices.ts
+function buildIssueCertificateUrl(baseURL) {
+	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${endpoints.certificateIssuanceIssue}`;
+}
+/**
+* Issues a digital certificate and returns it as a Blob.
+*/
+async function issueCertificate(params, signal) {
+	const { baseURL, headers: defaultHeaders } = getApi().defaults;
+	const token = getToken();
+	return { blob: await (await externalFetch({
+		method: "POST",
+		url: buildIssueCertificateUrl(baseURL),
+		headers: {
+			...defaultHeaders,
+			Accept: "application/octet-stream",
+			...token ? { "X-Incode-Hardware-Id": token } : {}
+		},
+		body: JSON.stringify({ password: params.password }),
+		signal
+	})).blob() };
+}
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceConstants.ts
+const MIN_PASSWORD_LENGTH = 8;
+const PASSWORD_VALIDATION_KEYS = [
+	"length",
+	"uppercase",
+	"lowercase",
+	"number"
+];
+const REQUIREMENT_I18N_KEYS = {
+	length: "certificateIssuance.password.length",
+	uppercase: "certificateIssuance.password.uppercase",
+	lowercase: "certificateIssuance.password.lowercase",
+	number: "certificateIssuance.password.number"
+};
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceUtils.ts
+function emptyPasswordValidations() {
+	return {
+		length: false,
+		uppercase: false,
+		lowercase: false,
+		number: false
+	};
+}
+function validatePassword(value) {
+	return {
+		length: value.length >= MIN_PASSWORD_LENGTH,
+		uppercase: /[A-Z]/.test(value),
+		lowercase: /[a-z]/.test(value),
+		number: /[0-9]/.test(value)
+	};
+}
+function isPasswordValid(validations) {
+	return PASSWORD_VALIDATION_KEYS.every((key) => validations[key]);
+}
+
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceStateMachine.ts
+const certificateIssuanceMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { issueCertificate: fromPromise(async ({ input, signal }) => issueCertificate({ password: input.password }, signal)) },
+	actions: {
+		setPassword: assign(({ event }) => {
+			const e = event;
+			return {
+				password: e.password,
+				passwordValidations: validatePassword(e.password)
+			};
+		}),
+		setBlob: assign(({ event }) => ({ certificateBlob: "output" in event ? event.output.blob : void 0 }))
+	},
+	guards: { isPasswordValid: ({ context }) => isPasswordValid(context.passwordValidations) }
+}).createMachine({
+	id: "certificateIssuance",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		password: "",
+		passwordValidations: emptyPasswordValidations(),
+		certificateBlob: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "password" } } },
+		password: { on: {
+			PASSWORD_CHANGED: { actions: "setPassword" },
+			SUBMIT_PASSWORD: {
+				target: "processing",
+				guard: "isPasswordValid"
+			}
+		} },
+		processing: { invoke: {
+			id: "issueCertificate",
+			src: "issueCertificate",
+			input: ({ context }) => ({ password: context.password }),
+			onDone: {
+				target: "success",
+				actions: "setBlob"
+			},
+			onError: { target: "error" }
+		} },
+		success: { on: {
+			DOWNLOADED: { target: "downloaded" },
+			DOWNLOAD_FAILED: { target: "error" },
+			FINISH: { target: "finished" }
+		} },
+		downloaded: { on: { FINISH: { target: "finished" } } },
+		error: { after: { 3e3: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+export { MIN_PASSWORD_LENGTH as a, validatePassword as i, emptyPasswordValidations as n, PASSWORD_VALIDATION_KEYS as o, isPasswordValid as r, REQUIREMENT_I18N_KEYS as s, certificateIssuanceMachine as t };