import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
import "./StateMachine-EDpYWy0i.js";
import { t as Manager } from "./Manager-CQQ99QOI.js";
import "./Actor-iTq7YY48.js";
import { a as UpdateOcrResponse, i as UpdateOcrDataParams, n as OcrData, t as IdOcrConfig } from "./types-CJ7Yl9K-2.js";
//#region src/modules/id-ocr/idOcrStateMachine.d.ts
type IdOcrOcrDocument = 'first' | 'second';
type IdOcrContext = {
  config: IdOcrConfig;
  error?: string;
  formData: UpdateOcrDataParams;
  editedFields: UpdateOcrDataParams;
  activeOcrDocument: IdOcrOcrDocument;
  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
};
type IdOcrInput = {
  config: IdOcrConfig;
};
declare const idOcrStateMachine: StateMachine<IdOcrContext, {
  type: "LOAD";
} | {
  type: "DATA_CHANGED";
  field: keyof UpdateOcrDataParams;
  value: string;
} | {
  type: "VALIDATE_FIELD";
  field: keyof UpdateOcrDataParams;
} | {
  type: "CONTINUE";
} | {
  type: "RETRY";
}, {
  [x: string]: ActorRefFromLogic<PromiseActorLogic<OcrData, {
    isSecondId: boolean;
  }, EventObject>> | ActorRefFromLogic<PromiseActorLogic<UpdateOcrResponse, {
    params: UpdateOcrDataParams;
    isSecondId: boolean;
  }, EventObject>> | undefined;
}, Values<{
  getOcrData: {
    src: "getOcrData";
    logic: PromiseActorLogic<OcrData, {
      isSecondId: boolean;
    }, EventObject>;
    id: string | undefined;
  };
  updateOcrData: {
    src: "updateOcrData";
    logic: PromiseActorLogic<UpdateOcrResponse, {
      params: UpdateOcrDataParams;
      isSecondId: boolean;
    }, EventObject>;
    id: string | undefined;
  };
}>, Values<{
  setError: {
    type: "setError";
    params: NonReducibleUnknown;
  };
  setInitialData: {
    type: "setInitialData";
    params: NonReducibleUnknown;
  };
  updateField: {
    type: "updateField";
    params: NonReducibleUnknown;
  };
  clearFieldValidationError: {
    type: "clearFieldValidationError";
    params: NonReducibleUnknown;
  };
  setOcrValidationErrors: {
    type: "setOcrValidationErrors";
    params: NonReducibleUnknown;
  };
  validateFormField: {
    type: "validateFormField";
    params: NonReducibleUnknown;
  };
  beginSecondIdOcrPhase: {
    type: "beginSecondIdOcrPhase";
    params: NonReducibleUnknown;
  };
  resetForRetry: {
    type: "resetForRetry";
    params: NonReducibleUnknown;
  };
  computeValidationResult: {
    type: "computeValidationResult";
    params: NonReducibleUnknown;
  };
}>, Values<{
  isOcrEditable: {
    type: "isOcrEditable";
    params: unknown;
  };
  shouldLoadSecondOcrAfterFirst: {
    type: "shouldLoadSecondOcrAfterFirst";
    params: unknown;
  };
  isOcrFormValid: {
    type: "isOcrFormValid";
    params: unknown;
  };
  shouldSubmit: {
    type: "shouldSubmit";
    params: unknown;
  };
  shouldProceedWithoutSubmitToSecondId: {
    type: "shouldProceedWithoutSubmitToSecondId";
    params: unknown;
  };
}>, never, "error" | "idle" | "success" | "finished" | "submitting" | "loading" | "inputting" | "readonly" | "validatingContinue", string, IdOcrInput, NonReducibleUnknown, EventObject, MetaObject, {
  readonly id: "idOcr";
  readonly initial: "idle";
  readonly context: ({ input }: {
    spawn: {
      <TSrc extends "getOcrData" | "updateOcrData">(logic: TSrc, ...[options]: ({
        src: "getOcrData";
        logic: PromiseActorLogic<OcrData, {
          isSecondId: boolean;
        }, EventObject>;
        id: string | undefined;
      } extends (infer T) ? T extends {
        src: "getOcrData";
        logic: PromiseActorLogic<OcrData, {
          isSecondId: boolean;
        }, EventObject>;
        id: string | undefined;
      } ? T extends {
        src: TSrc;
      } ? ConditionalRequired<[options?: ({
        id?: T["id"] | undefined;
        systemId?: string;
        input?: InputFrom<T["logic"]> | undefined;
        syncSnapshot?: boolean;
      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
        src: "updateOcrData";
        logic: PromiseActorLogic<UpdateOcrResponse, {
          params: UpdateOcrDataParams;
          isSecondId: boolean;
        }, EventObject>;
        id: string | undefined;
      } extends (infer T_1) ? T_1 extends {
        src: "updateOcrData";
        logic: PromiseActorLogic<UpdateOcrResponse, {
          params: UpdateOcrDataParams;
          isSecondId: boolean;
        }, EventObject>;
        id: string | undefined;
      } ? T_1 extends {
        src: TSrc;
      } ? ConditionalRequired<[options?: ({
        id?: T_1["id"] | undefined;
        systemId?: string;
        input?: InputFrom<T_1["logic"]> | undefined;
        syncSnapshot?: boolean;
      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
        getOcrData: {
          src: "getOcrData";
          logic: PromiseActorLogic<OcrData, {
            isSecondId: boolean;
          }, EventObject>;
          id: string | undefined;
        };
        updateOcrData: {
          src: "updateOcrData";
          logic: PromiseActorLogic<UpdateOcrResponse, {
            params: UpdateOcrDataParams;
            isSecondId: boolean;
          }, EventObject>;
          id: string | undefined;
        };
      }>, "src", TSrc>["logic"]>;
      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
        id?: never;
        systemId?: string;
        input?: InputFrom<TLogic> | undefined;
        syncSnapshot?: boolean;
      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
    };
    input: IdOcrInput;
    self: ActorRef<MachineSnapshot<IdOcrContext, {
      type: "LOAD";
    } | {
      type: "DATA_CHANGED";
      field: keyof UpdateOcrDataParams;
      value: string;
    } | {
      type: "VALIDATE_FIELD";
      field: keyof UpdateOcrDataParams;
    } | {
      type: "CONTINUE";
    } | {
      type: "RETRY";
    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
      type: "LOAD";
    } | {
      type: "DATA_CHANGED";
      field: keyof UpdateOcrDataParams;
      value: string;
    } | {
      type: "VALIDATE_FIELD";
      field: keyof UpdateOcrDataParams;
    } | {
      type: "CONTINUE";
    } | {
      type: "RETRY";
    }, AnyEventObject>;
  }) => {
    config: IdOcrConfig;
    formData: UpdateOcrDataParams;
    editedFields: {};
    activeOcrDocument: IdOcrOcrDocument;
  };
  readonly states: {
    readonly idle: {
      readonly on: {
        readonly LOAD: readonly [{
          readonly target: "loading";
        }];
      };
    };
    readonly loading: {
      readonly invoke: {
        readonly src: "getOcrData";
        readonly input: ({ context }: {
          context: IdOcrContext;
          event: {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          };
          self: ActorRef<MachineSnapshot<IdOcrContext, {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          }, AnyEventObject>;
        }) => {
          isSecondId: boolean;
        };
        readonly onDone: readonly [{
          readonly target: "inputting";
          readonly guard: "isOcrEditable";
          readonly actions: "setInitialData";
        }, {
          readonly target: "readonly";
          readonly actions: "setInitialData";
        }];
        readonly onError: {
          readonly target: "error";
          readonly actions: "setError";
        };
      };
    };
    readonly readonly: {
      readonly on: {
        readonly CONTINUE: readonly [{
          readonly target: "loading";
          readonly guard: "shouldLoadSecondOcrAfterFirst";
          readonly actions: "beginSecondIdOcrPhase";
        }, {
          readonly target: "success";
        }];
      };
    };
    readonly inputting: {
      readonly on: {
        readonly DATA_CHANGED: {
          readonly actions: readonly ["updateField", "clearFieldValidationError"];
        };
        readonly VALIDATE_FIELD: {
          readonly actions: "validateFormField";
        };
        readonly CONTINUE: {
          readonly target: "validatingContinue";
        };
      };
    };
    readonly validatingContinue: {
      readonly entry: "computeValidationResult";
      readonly always: readonly [{
        readonly guard: "shouldSubmit";
        readonly target: "submitting";
      }, {
        readonly guard: "shouldProceedWithoutSubmitToSecondId";
        readonly target: "loading";
        readonly actions: "beginSecondIdOcrPhase";
      }, {
        readonly guard: "isOcrFormValid";
        readonly target: "success";
      }, {
        readonly target: "inputting";
      }];
    };
    readonly submitting: {
      readonly invoke: {
        readonly src: "updateOcrData";
        readonly input: ({ context }: {
          context: IdOcrContext;
          event: {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          };
          self: ActorRef<MachineSnapshot<IdOcrContext, {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
            type: "LOAD";
          } | {
            type: "DATA_CHANGED";
            field: keyof UpdateOcrDataParams;
            value: string;
          } | {
            type: "VALIDATE_FIELD";
            field: keyof UpdateOcrDataParams;
          } | {
            type: "CONTINUE";
          } | {
            type: "RETRY";
          }, AnyEventObject>;
        }) => {
          params: UpdateOcrDataParams;
          isSecondId: boolean;
        };
        readonly onDone: readonly [{
          readonly target: "loading";
          readonly guard: "shouldLoadSecondOcrAfterFirst";
          readonly actions: "beginSecondIdOcrPhase";
        }, {
          readonly target: "success";
        }];
        readonly onError: {
          readonly target: "error";
          readonly actions: "setError";
        };
      };
    };
    readonly error: {
      readonly on: {
        readonly RETRY: {
          readonly target: "loading";
          readonly actions: "resetForRetry";
        };
      };
    };
    readonly success: {
      readonly after: {
        readonly 3000: "finished";
      };
    };
    readonly finished: {
      readonly type: "final";
    };
  };
}>;
type IdOcrMachine = typeof idOcrStateMachine;
//#endregion
//#region src/modules/id-ocr/idOcrActor.d.ts
type IdOcrActor = ActorRefFrom<IdOcrMachine>;
type CreateIdOcrActorOptions = {
  config: IdOcrConfig;
};
//#endregion
//#region src/modules/id-ocr/idOcrManager.d.ts
type IdOcrIdleState = {
  status: 'idle';
};
type IdOcrLoadingState = {
  status: 'loading';
  ocrDocument: IdOcrOcrDocument;
};
type IdOcrReadonlyState = {
  status: 'readonly';
  formData: UpdateOcrDataParams;
  editableOcr: boolean;
  ocrDocument: IdOcrOcrDocument;
};
type IdOcrInputtingState = {
  status: 'inputting';
  formData: UpdateOcrDataParams;
  editedFields: UpdateOcrDataParams;
  editableOcr: boolean;
  ocrDocument: IdOcrOcrDocument;
  validationErrors?: Partial<Record<keyof UpdateOcrDataParams, string>>;
};
type IdOcrSubmittingState = {
  status: 'submitting';
  ocrDocument: IdOcrOcrDocument;
};
type IdOcrFinishedState = {
  status: 'finished';
};
type IdOcrErrorState = {
  status: 'error';
  error: string;
};
type IdOcrSuccessState = {
  status: 'success';
};
type IdOcrState = IdOcrIdleState | IdOcrLoadingState | IdOcrReadonlyState | IdOcrInputtingState | IdOcrSubmittingState | IdOcrFinishedState | IdOcrErrorState | IdOcrSuccessState;
declare function createIdOcrManager(options: CreateIdOcrActorOptions): Manager<IdOcrState> & {
  load(): void;
  setField(field: keyof UpdateOcrDataParams, value: string): void;
  validateField(field: keyof UpdateOcrDataParams): void;
  continue(): void;
  retry(): void;
};
/**
 * Creates an ID-OCR manager from a pre-built actor.
 * Use this when overriding the machine via `.provide()` for custom backends
 * or for story-isolation testing.
 */
declare function createIdOcrManagerFromActor(actor: IdOcrActor): Manager<IdOcrState> & {
  load(): void;
  setField(field: keyof UpdateOcrDataParams, value: string): void;
  validateField(field: keyof UpdateOcrDataParams): void;
  continue(): void;
  retry(): void;
};
type IdOcrManager = ReturnType<typeof createIdOcrManager>;
//#endregion
export { IdOcrActor as a, createIdOcrManagerFromActor as i, IdOcrState as n, IdOcrOcrDocument as o, createIdOcrManager as r, idOcrStateMachine as s, IdOcrManager as t };