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

package/dist/identity-reuse.d.ts

@@ -0,0 +1,530 @@
+import { t as Manager } from "./Manager-Bcnemkyi.js";
+import { t as ActorRefFrom } from "./Actor-BkPcZGke.js";
+import * as xstate735 from "xstate";
+
+//#region src/modules/identity-reuse/types.d.ts
+
+/**
+ * Configuration options for the IdentityReuse module.
+ *
+ * @example
+ * ```typescript
+ * const config: IdentityReuseConfig = {};
+ * ```
+ */
+type IdentityReuseConfig = {};
+/** @internal Response from GET /omni/identity-reuse/candidates */
+type FetchCandidatesResponse = {
+  currentOrganizationName: string;
+  candidateOrganizationNames: string[];
+};
+/** @internal Response from POST /omni/identity-reuse/submit — shape TBD */
+type SubmitResponse = {};
+//#endregion
+//#region src/modules/identity-reuse/identityReuseStateMachine.d.ts
+type IdentityReuseContext = {
+  config: IdentityReuseConfig;
+  currentOrganizationName: string | undefined;
+  candidateOrganizationNames: string[];
+  selectedOrganizationName: string | undefined;
+  error: string | undefined;
+};
+type IdentityReuseInput = {
+  config: IdentityReuseConfig;
+};
+declare const identityReuseMachine: xstate735.StateMachine<IdentityReuseContext, {
+  type: "LOAD";
+} | {
+  type: "START_SELECTION";
+} | {
+  type: "CANDIDATE_CHOSEN";
+  organizationName: string;
+} | {
+  type: "CHANGE_CANDIDATE";
+} | {
+  type: "SUBMIT_CANDIDATE";
+} | {
+  type: "SKIP";
+} | {
+  type: "RETRY";
+}, {
+  [x: string]: xstate735.ActorRefFromLogic<xstate735.PromiseActorLogic<FetchCandidatesResponse, void, xstate735.EventObject>> | xstate735.ActorRefFromLogic<xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>> | undefined;
+}, xstate735.Values<{
+  fetchCandidates: {
+    src: "fetchCandidates";
+    logic: xstate735.PromiseActorLogic<FetchCandidatesResponse, void, xstate735.EventObject>;
+    id: string | undefined;
+  };
+  submitContinue: {
+    src: "submitContinue";
+    logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+    id: string | undefined;
+  };
+  submitSkip: {
+    src: "submitSkip";
+    logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate735.Values<{
+  setError: {
+    type: "setError";
+    params: xstate735.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate735.NonReducibleUnknown;
+  };
+  setCandidates: {
+    type: "setCandidates";
+    params: xstate735.NonReducibleUnknown;
+  };
+  setSelectedCandidate: {
+    type: "setSelectedCandidate";
+    params: xstate735.NonReducibleUnknown;
+  };
+  autoSelectSingleCandidate: {
+    type: "autoSelectSingleCandidate";
+    params: xstate735.NonReducibleUnknown;
+  };
+  clearSelection: {
+    type: "clearSelection";
+    params: xstate735.NonReducibleUnknown;
+  };
+}>, xstate735.Values<{
+  hasMultipleCandidates: {
+    type: "hasMultipleCandidates";
+    params: unknown;
+  };
+  hasOneCandidate: {
+    type: "hasOneCandidate";
+    params: unknown;
+  };
+  hasChosenCandidate: {
+    type: "hasChosenCandidate";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "finished" | "loading" | "submitContinue" | "submitSkip" | "oneCandidateFound" | "noCandidatesFound" | {
+  multiCandidatesFound: "noCandidateSelected" | "choosingCandidate" | "candidateSelected";
+}, string, IdentityReuseInput, xstate735.NonReducibleUnknown, xstate735.EventObject, xstate735.MetaObject, {
+  readonly id: "identityReuse";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchCandidates" | "submitContinue" | "submitSkip">(logic: TSrc, ...[options]: ({
+        src: "fetchCandidates";
+        logic: xstate735.PromiseActorLogic<FetchCandidatesResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchCandidates";
+        logic: xstate735.PromiseActorLogic<FetchCandidatesResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate735.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate735.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate735.RequiredActorOptions<T>]: unknown }) | undefined], xstate735.IsNotNever<xstate735.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitContinue";
+        logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitContinue";
+        logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate735.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate735.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate735.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate735.IsNotNever<xstate735.RequiredActorOptions<T_1>>> : never : never : never) | ({
+        src: "submitSkip";
+        logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } extends infer T_2 ? T_2 extends {
+        src: "submitSkip";
+        logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+        id: string | undefined;
+      } ? T_2 extends {
+        src: TSrc;
+      } ? xstate735.ConditionalRequired<[options?: ({
+        id?: T_2["id"] | undefined;
+        systemId?: string;
+        input?: xstate735.InputFrom<T_2["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_2 in xstate735.RequiredActorOptions<T_2>]: unknown }) | undefined], xstate735.IsNotNever<xstate735.RequiredActorOptions<T_2>>> : never : never : never)): xstate735.ActorRefFromLogic<xstate735.GetConcreteByKey<xstate735.Values<{
+        fetchCandidates: {
+          src: "fetchCandidates";
+          logic: xstate735.PromiseActorLogic<FetchCandidatesResponse, void, xstate735.EventObject>;
+          id: string | undefined;
+        };
+        submitContinue: {
+          src: "submitContinue";
+          logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+          id: string | undefined;
+        };
+        submitSkip: {
+          src: "submitSkip";
+          logic: xstate735.PromiseActorLogic<SubmitResponse, void, xstate735.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate735.AnyActorLogic>(src: TLogic, ...[options]: xstate735.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate735.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate735.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate735.IsNotNever<xstate735.RequiredLogicInput<TLogic>>>): xstate735.ActorRefFromLogic<TLogic>;
+    };
+    input: IdentityReuseInput;
+    self: xstate735.ActorRef<xstate735.MachineSnapshot<IdentityReuseContext, {
+      type: "LOAD";
+    } | {
+      type: "START_SELECTION";
+    } | {
+      type: "CANDIDATE_CHOSEN";
+      organizationName: string;
+    } | {
+      type: "CHANGE_CANDIDATE";
+    } | {
+      type: "SUBMIT_CANDIDATE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, Record<string, xstate735.AnyActorRef | undefined>, xstate735.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "START_SELECTION";
+    } | {
+      type: "CANDIDATE_CHOSEN";
+      organizationName: string;
+    } | {
+      type: "CHANGE_CANDIDATE";
+    } | {
+      type: "SUBMIT_CANDIDATE";
+    } | {
+      type: "SKIP";
+    } | {
+      type: "RETRY";
+    }, xstate735.AnyEventObject>;
+  }) => {
+    config: IdentityReuseConfig;
+    currentOrganizationName: undefined;
+    candidateOrganizationNames: never[];
+    selectedOrganizationName: undefined;
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchCandidates";
+        readonly src: "fetchCandidates";
+        readonly onDone: readonly [{
+          readonly target: "multiCandidatesFound";
+          readonly guard: "hasMultipleCandidates";
+          readonly actions: "setCandidates";
+        }, {
+          readonly target: "oneCandidateFound";
+          readonly guard: "hasOneCandidate";
+          readonly actions: "setCandidates";
+        }, {
+          readonly target: "noCandidatesFound";
+          readonly actions: "setCandidates";
+        }];
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly multiCandidatesFound: {
+      readonly initial: "noCandidateSelected";
+      readonly states: {
+        readonly noCandidateSelected: {
+          readonly on: {
+            readonly START_SELECTION: {
+              readonly target: "choosingCandidate";
+            };
+          };
+        };
+        readonly choosingCandidate: {
+          readonly on: {
+            readonly CANDIDATE_CHOSEN: {
+              readonly target: "candidateSelected";
+              readonly actions: "setSelectedCandidate";
+            };
+          };
+        };
+        readonly candidateSelected: {
+          readonly on: {
+            readonly CHANGE_CANDIDATE: {
+              readonly target: "choosingCandidate";
+              readonly actions: "clearSelection";
+            };
+          };
+        };
+      };
+      readonly on: {
+        readonly SUBMIT_CANDIDATE: {
+          readonly target: "submitContinue";
+          readonly guard: "hasChosenCandidate";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly oneCandidateFound: {
+      readonly entry: "autoSelectSingleCandidate";
+      readonly on: {
+        readonly SUBMIT_CANDIDATE: {
+          readonly target: "submitContinue";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly noCandidatesFound: {
+      readonly on: {
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+    readonly submitContinue: {
+      readonly invoke: {
+        readonly id: "submitContinue";
+        readonly src: "submitContinue";
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly submitSkip: {
+      readonly invoke: {
+        readonly id: "submitSkip";
+        readonly src: "submitSkip";
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly SKIP: {
+          readonly target: "submitSkip";
+        };
+      };
+    };
+  };
+}>;
+type IdentityReuseMachine = typeof identityReuseMachine;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseActor.d.ts
+/**
+ * Options for creating an IdentityReuse actor.
+ */
+type CreateIdentityReuseActorOptions = {
+  /** Module configuration */
+  config: IdentityReuseConfig;
+};
+/**
+ * Type representing a running IdentityReuse actor.
+ */
+type IdentityReuseActor = ActorRefFrom<IdentityReuseMachine>;
+//#endregion
+//#region src/modules/identity-reuse/identityReuseManager.d.ts
+type SelectionPhase = 'noCandidateSelected' | 'choosingCandidate' | 'candidateSelected';
+/** IdentityReuse manager is in initial state, waiting for `load()` */
+type IdentityReuseIdleState = {
+  status: 'idle';
+};
+/** Fetching candidate organizations from the backend */
+type IdentityReuseLoadingState = {
+  status: 'loading';
+};
+/**
+ * Multiple candidates available — user must select one
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ * @property candidateOrganizationNames - Organizations with reusable identity data
+ * @property selectedOrganizationName - The currently chosen candidate, if any
+ * @property selectionPhase - Which child state the selection is in
+ */
+type IdentityReuseMultiCandidatesState = {
+  status: 'multiCandidatesFound';
+  currentOrganizationName: string;
+  candidateOrganizationNames: string[];
+  selectedOrganizationName: string | undefined;
+  selectionPhase: SelectionPhase;
+};
+/**
+ * Exactly one candidate found — auto-selected on entry
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ * @property selectedOrganizationName - The single candidate, auto-selected
+ */
+type IdentityReuseOneCandidateState = {
+  status: 'oneCandidateFound';
+  currentOrganizationName: string;
+  selectedOrganizationName: string;
+};
+/**
+ * No candidate organizations found
+ * @property currentOrganizationName - The organization the user is currently onboarding into
+ */
+type IdentityReuseNoCandidatesState = {
+  status: 'noCandidatesFound';
+  currentOrganizationName: string;
+};
+/** Submitting final decision (reuse: true) */
+type IdentityReuseSubmitContinueState = {
+  status: 'submitContinue';
+};
+/** Submitting final decision (reuse: false) */
+type IdentityReuseSubmitSkipState = {
+  status: 'submitSkip';
+};
+/** Module completed successfully */
+type IdentityReuseFinishedState = {
+  status: 'finished';
+};
+/**
+ * A recoverable error occurred — user can retry or skip
+ * @property error - Error message describing what went wrong
+ */
+type IdentityReuseErrorState = {
+  status: 'error';
+  error: string;
+};
+/**
+ * Union of all possible IdentityReuse manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = manager.getState();
+ * if (state.status === 'multiCandidatesFound') {
+ *   console.log(state.candidateOrganizationNames);
+ * }
+ * ```
+ */
+type IdentityReuseState = IdentityReuseIdleState | IdentityReuseLoadingState | IdentityReuseMultiCandidatesState | IdentityReuseOneCandidateState | IdentityReuseNoCandidatesState | IdentityReuseSubmitContinueState | IdentityReuseSubmitSkipState | IdentityReuseFinishedState | IdentityReuseErrorState;
+/**
+ * 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();
+ * ```
+ */
+declare function createIdentityReuseManager(options: CreateIdentityReuseActorOptions): Manager<IdentityReuseState> & {
+  /**
+   * Fetches candidate organizations from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Begins the candidate selection process.
+   * Transitions from 'noCandidateSelected' to 'choosingCandidate'.
+   */
+  startSelection(): void;
+  /**
+   * Chooses a candidate organization.
+   * Transitions from 'choosingCandidate' to 'candidateSelected'.
+   */
+  chooseCandidate(organizationName: string): void;
+  /**
+   * Goes back to choosing a different candidate.
+   * Transitions from 'candidateSelected' to 'choosingCandidate'.
+   */
+  changeCandidate(): void;
+  /**
+   * Submits the chosen candidate for processing.
+   * Guarded by having a chosen candidate.
+   */
+  submitCandidate(): void;
+  /**
+   * Skips identity reuse and proceeds with fresh onboarding.
+   * Sends /submit with reuse: false.
+   */
+  skip(): void;
+  /**
+   * Retries loading candidates after an error.
+   */
+  retry(): void;
+};
+/**
+ * Creates an IdentityReuse manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends or testing.
+ */
+declare function createIdentityReuseManagerFromActor(actor: IdentityReuseActor): Manager<IdentityReuseState> & {
+  /**
+   * Fetches candidate organizations from the backend.
+   * Transitions from 'idle' to 'loading'.
+   */
+  load(): void;
+  /**
+   * Begins the candidate selection process.
+   * Transitions from 'noCandidateSelected' to 'choosingCandidate'.
+   */
+  startSelection(): void;
+  /**
+   * Chooses a candidate organization.
+   * Transitions from 'choosingCandidate' to 'candidateSelected'.
+   */
+  chooseCandidate(organizationName: string): void;
+  /**
+   * Goes back to choosing a different candidate.
+   * Transitions from 'candidateSelected' to 'choosingCandidate'.
+   */
+  changeCandidate(): void;
+  /**
+   * Submits the chosen candidate for processing.
+   * Guarded by having a chosen candidate.
+   */
+  submitCandidate(): void;
+  /**
+   * Skips identity reuse and proceeds with fresh onboarding.
+   * Sends /submit with reuse: false.
+   */
+  skip(): void;
+  /**
+   * Retries loading candidates after an error.
+   */
+  retry(): void;
+};
+type IdentityReuseManager = ReturnType<typeof createIdentityReuseManager>;
+//#endregion
+export { type FetchCandidatesResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };