@checktiv/sdk-web 1.9.0 → 1.12.0

package/dist/index-CGH7LlPH.d.ts

@@ -0,0 +1,736 @@
+import { l as CaptureBehaviorStep, m as CaptureBehaviorTraits, o as CaptureBrandTokens, p as CaptureTheme, e as CaptureLayout, f as CaptureBehaviorMessage, q as CaptureSessionClientConfig, s as SelfiePromptMap, t as SelfieChromeCopy, B as BeginScanCopyOverrides, C as CoachingKind, k as CaptureTimingSnapshot } from './machine-EePe2ERe.js';
+import { M as MountCopy } from './copy-Bsb1n1Wv.js';
+import { C as CrossDeviceCopy } from './copy-DCeQ4JKx.js';
+
+declare const SystemModes: readonly ["live", "test"];
+type SystemMode = (typeof SystemModes)[number];
+declare const DataRegions: readonly ["us", "eu"];
+type DataRegion = (typeof DataRegions)[number];
+
+type ChecktivKnownErrorCode = 'origin_not_allowed' | 'token_expired' | 'session_expired' | 'wrong_token_type' | 'protocol_mismatch' | 'camera_denied' | 'camera_policy_blocked' | 'camera_unsupported' | 'cv_gate_failed' | 'upload_failed' | 'submit_failed' | 'sdk_load_failed' | 'biometric_unsupported' | 'isolation_required' | 'session_parked';
+type ChecktivErrorCode = ChecktivKnownErrorCode | (string & {});
+declare const CHECKTIV_RECOVERY_STRATEGIES: readonly ["retry", "cross_device", "refresh_session", "contact_operator"];
+type ChecktivRecovery = (typeof CHECKTIV_RECOVERY_STRATEGIES)[number];
+interface ChecktivError {
+    code: ChecktivErrorCode;
+    recoverable: boolean;
+    recovery: ChecktivRecovery;
+    message: string;
+}
+declare const CHECKTIV_ERROR_CODES: readonly ChecktivKnownErrorCode[];
+declare function createChecktivError(code: ChecktivKnownErrorCode): ChecktivError;
+
+type ChecktivCustomFormEvent = {
+    type: 'checktiv.custom_form.ready';
+} | {
+    type: 'checktiv.custom_form.submitted';
+    sessionId: string;
+} | {
+    type: 'checktiv.custom_form.error';
+    error: ChecktivError;
+};
+
+declare const ESIGN_STATES: readonly ["preparing", "consent", "read", "scroll_incomplete", "adopt", "age_gate", "explain", "sign", "decline", "withdraw", "obscured", "frame_blocked", "age_blocked", "conflict", "token_expired", "protocol_mismatch", "error", "submit_error", "terminal_signed", "terminal_declined", "terminal_voided", "terminal_expired", "terminal_withdrawn"];
+type EsignState = (typeof ESIGN_STATES)[number];
+type TerminalEnvelopeStatus = 'signed' | 'declined' | 'voided' | 'expired';
+declare const TERMINAL_STATUS_TO_STATE: {
+    readonly signed: "terminal_signed";
+    readonly declined: "terminal_declined";
+    readonly voided: "terminal_voided";
+    readonly expired: "terminal_expired";
+};
+declare const ESIGN_CONSENT_ACTIONS: readonly ["withdraw_consent", "request_paper_copy"];
+type EsignConsentAction = (typeof ESIGN_CONSENT_ACTIONS)[number];
+type EsignConsentOutcome = 'consent_withdrawn_before_signing' | 'consent_withdrawn_after_signing' | 'paper_copy_requested' | 'paper_copy_already_outstanding';
+type EsignRightsAffordance = 'both' | 'none';
+declare const ESIGN_STATE_RIGHTS: {
+    readonly preparing: "none";
+    readonly consent: "both";
+    readonly read: "both";
+    readonly scroll_incomplete: "both";
+    readonly adopt: "both";
+    readonly age_gate: "both";
+    readonly explain: "both";
+    readonly sign: "both";
+    readonly decline: "both";
+    readonly withdraw: "both";
+    readonly obscured: "both";
+    readonly age_blocked: "none";
+    readonly frame_blocked: "none";
+    readonly conflict: "none";
+    readonly token_expired: "none";
+    readonly protocol_mismatch: "none";
+    readonly error: "none";
+    readonly submit_error: "none";
+    readonly terminal_signed: "none";
+    readonly terminal_declined: "none";
+    readonly terminal_voided: "none";
+    readonly terminal_expired: "none";
+    readonly terminal_withdrawn: "none";
+};
+declare function esignStateOffersRights(state: EsignState): boolean;
+declare const ESIGN_FRAME_ANNOUNCE_TIMEOUT_MS = 20000;
+
+type EsignSubmitOutcome = 'signed' | 'declined';
+type ChecktivEsignEvent = {
+    type: 'checktiv.esign.ready';
+} | {
+    type: 'checktiv.esign.state';
+    state: EsignState;
+} | {
+    type: 'checktiv.esign.submitted';
+    sessionId: string;
+    outcome: EsignSubmitOutcome;
+} | {
+    type: 'checktiv.esign.error';
+    error: ChecktivError;
+};
+
+type CreditBrandTokens = CaptureBrandTokens;
+type CreditTheme = CaptureTheme;
+type CreditScreen = 'consent' | 'address_history' | 'identity_and_title' | 'review';
+type CreditErrorCode = 'load_failed' | 'config_error' | 'session_expired' | 'submit_failed';
+type CreditSkipReason = 'unsupported_jurisdiction';
+interface CreditCopyMap {
+    continueLabel?: string;
+    backLabel?: string;
+    submitLabel?: string;
+}
+interface CreditInitMessage {
+    type: 'credit:init';
+    locale: string;
+    theme: CreditTheme;
+    copy?: CreditCopyMap;
+}
+type CreditBehaviorStep = CaptureBehaviorStep;
+type CreditBehaviorTraits = CaptureBehaviorTraits;
+interface CreditBehaviorSegment {
+    steps: CreditBehaviorStep[];
+    traits: CreditBehaviorTraits;
+}
+type CreditFromIframeMessage = {
+    type: 'credit:ready';
+} | {
+    type: 'credit:resize';
+    height: number;
+} | {
+    type: 'credit:screen_changed';
+    index: number;
+    total: number;
+    screen: CreditScreen;
+} | {
+    type: 'credit:submitted';
+} | {
+    type: 'credit:declined';
+} | {
+    type: 'credit:skipped';
+    reason: CreditSkipReason;
+} | {
+    type: 'credit:error';
+    code: CreditErrorCode;
+} | {
+    type: 'credit:credential_expired';
+} | {
+    type: 'credit:behavior';
+    steps: CreditBehaviorStep[];
+    traits: CreditBehaviorTraits;
+};
+declare const CREDIT_FRAME_MIN_HEIGHT_PX = 200;
+declare const CREDIT_FRAME_MAX_HEIGHT_PX = 20000;
+declare const CREDIT_SCREENS: readonly ["consent", "address_history", "identity_and_title", "review"];
+declare const CREDIT_SCREEN_COUNT: 4;
+declare function projectCreditCopy(copy: CreditCopyMap | undefined): CreditCopyMap | null;
+declare function parseCreditInbound(data: unknown): CreditFromIframeMessage | null;
+
+type CreditHistoryReconnectReason = 'bootstrap_timeout' | 'credential_expired';
+type ChecktivCreditHistoryEvent = {
+    type: 'checktiv.credit_history.ready';
+} | {
+    type: 'checktiv.credit_history.screen';
+    screen: CreditScreen;
+    index: number;
+    total: number;
+} | {
+    type: 'checktiv.credit_history.reconnecting';
+    reason: CreditHistoryReconnectReason;
+} | {
+    type: 'checktiv.credit_history.submitted';
+    sessionId: string;
+} | {
+    type: 'checktiv.credit_history.declined';
+} | {
+    type: 'checktiv.credit_history.skipped';
+    reason: CreditSkipReason;
+} | {
+    type: 'checktiv.credit_history.error';
+    error: ChecktivError;
+};
+declare const CREDIT_HISTORY_EVENT_TYPES: readonly ["checktiv.credit_history.ready", "checktiv.credit_history.screen", "checktiv.credit_history.reconnecting", "checktiv.credit_history.submitted", "checktiv.credit_history.declined", "checktiv.credit_history.skipped", "checktiv.credit_history.error"];
+declare function isChecktivCreditHistoryEvent(event: ChecktivEvent): event is ChecktivCreditHistoryEvent;
+
+declare const FORM_FIELD_TYPES: readonly ["short_text", "long_text", "number", "email", "phone", "date", "single_select", "multi_select", "boolean", "file_upload", "content_heading", "content_paragraph"];
+type FormFieldType = (typeof FORM_FIELD_TYPES)[number];
+
+type CustomFormApplicantLabel = Record<string, string>;
+interface CustomFormApplicantFieldValidation {
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    minSelections?: number;
+    maxSelections?: number;
+}
+interface CustomFormApplicantFieldOption {
+    value: string;
+    label: CustomFormApplicantLabel;
+}
+interface CustomFormApplicantField {
+    id: string;
+    type: FormFieldType;
+    label: CustomFormApplicantLabel;
+    helpText?: CustomFormApplicantLabel;
+    required: boolean;
+    validation?: CustomFormApplicantFieldValidation;
+    options?: CustomFormApplicantFieldOption[];
+}
+type CustomFormApplicantConfig = {
+    supportedLocales: string[];
+    fields: CustomFormApplicantField[];
+};
+
+declare const MODULE_SUBPATH: {
+    readonly idv: "idv";
+    readonly fraud: "fraud";
+    readonly custom_form: "custom-form";
+    readonly esign: "esign";
+    readonly credit_history: "credit-history";
+};
+type SdkModuleName = keyof typeof MODULE_SUBPATH;
+
+interface TokenManager {
+    get(): Promise<string>;
+    refresh(reason: 'expired' | '401'): Promise<string>;
+}
+
+interface SyntheticIdvScript {
+    injectError?: ChecktivKnownErrorCode;
+    stepDelayMs?: number;
+}
+
+type CrossDeviceHandoffHook = () => Promise<{
+    kind: 'ok';
+    url: string;
+} | {
+    kind: 'unavailable';
+}>;
+interface ForwardedSession {
+    sessionId: string;
+    stepId: string;
+    config: CaptureSessionClientConfig | null;
+}
+interface IdvMountOptions {
+    target: HTMLElement | string;
+    onEvent?: (e: ChecktivIdvEvent) => void;
+    copy?: MountCopy;
+    layout?: CaptureLayout;
+    maxWidth?: string;
+    onBeforeSubmit?: () => Promise<void>;
+    onBehaviorSegment?: (segment: Pick<CaptureBehaviorMessage, 'steps' | 'traits'>) => void;
+    fetchImpl?: typeof fetch;
+    synthetic?: SyntheticIdvScript;
+    onOpenCrossDevice?: CrossDeviceHandoffHook;
+    crossDeviceCopy?: CrossDeviceCopy;
+    session?: ForwardedSession;
+}
+interface IdvHandle {
+    destroy(): void;
+    unmount(): void;
+    openCrossDevice?(): void;
+}
+declare const REMINT_READY_TIMEOUT_MS = 15000;
+declare function createIdv(ctx: SubstrateContext, opts: IdvMountOptions): IdvHandle;
+type IdvChunkModule = {
+    createIdv: typeof createIdv;
+};
+
+interface CustomFormFieldCopy {
+    readonly label?: string;
+    readonly helpText?: string;
+    readonly options?: Readonly<Record<string, string>>;
+}
+interface CustomFormCopy {
+    readonly fields?: Readonly<Record<string, CustomFormFieldCopy>>;
+    readonly submit?: string;
+    readonly submitPending?: string;
+    readonly requiredError?: string;
+    readonly invalidPhoneError?: string;
+    readonly invalidEmailError?: string;
+    readonly invalidDateError?: string;
+    readonly invalidOptionError?: string;
+    readonly outOfRangeError?: string;
+    readonly invalidFormatError?: string;
+    readonly invalidError?: string;
+    readonly validationError?: string;
+    readonly uploadError?: string;
+    readonly submitError?: string;
+    readonly booleanYes?: string;
+    readonly booleanNo?: string;
+}
+
+interface CustomFormMountOptions {
+    target: HTMLElement | string;
+    config: CustomFormApplicantConfig;
+    copy?: CustomFormCopy;
+    onEvent?: (e: ChecktivCustomFormEvent) => void;
+    session?: {
+        sessionId: string;
+        stepId: string;
+    };
+    fetchImpl?: typeof fetch;
+    preview?: boolean;
+}
+interface CustomFormHandle {
+    destroy(): void;
+}
+declare function createCustomForm(ctx: SubstrateContext, opts: CustomFormMountOptions): CustomFormHandle;
+type CustomFormChunkModule = {
+    createCustomForm: typeof createCustomForm;
+};
+
+type EsignCopy = Partial<Record<EsignState, string>> & {
+    frameTitle?: string;
+    labels?: Partial<Record<EsignLabel, string>>;
+    rights?: Partial<Record<EsignRightsKey, string>>;
+    documents?: Partial<Record<EsignDocumentCopyKey, string>>;
+    shell?: Partial<Record<EsignShellKey, string>>;
+};
+type EsignCopyScalarKey = {
+    [K in keyof EsignCopy]-?: EsignCopy[K] extends string | undefined ? K : never;
+}[keyof EsignCopy];
+declare const ESIGN_COPY_FALLBACKS: {
+    preparing: string;
+    consent: string;
+    read: string;
+    scroll_incomplete: string;
+    adopt: string;
+    age_gate: string;
+    explain: string;
+    sign: string;
+    decline: string;
+    withdraw: string;
+    obscured: string;
+    frame_blocked: string;
+    conflict: string;
+    token_expired: string;
+    protocol_mismatch: string;
+    error: string;
+    submit_error: string;
+    terminal_signed: string;
+    terminal_declined: string;
+    terminal_voided: string;
+    terminal_expired: string;
+    terminal_withdrawn: string;
+    age_blocked: string;
+    frameTitle: string;
+};
+declare const ESIGN_LABELS: readonly ["finish", "adopt", "cancel", "change", "tryAgain", "reload", "reloadToCheck", "getHelp", "moreActions", "jumpToEnd", "readNotice", "signatureBlock", "signatureBlockDone", "finishLater", "printAndSign", "decline", "declineSubmit", "declineCancel", "signatureName", "signatureStyle", "declineReason", "ageConfirm", "documentHeading", "signatureHeading"];
+type EsignLabel = (typeof ESIGN_LABELS)[number];
+declare const ESIGN_LABEL_FALLBACKS: {
+    readonly finish: "Finish";
+    readonly adopt: "Use this signature";
+    readonly cancel: "Cancel";
+    readonly change: "Change";
+    readonly tryAgain: "Try again";
+    readonly reload: "Reload the page";
+    readonly reloadToCheck: "Reload to check";
+    readonly getHelp: "Get help";
+    readonly moreActions: "More actions";
+    readonly readNotice: "Notice and your rights";
+    readonly jumpToEnd: "Jump to the end";
+    readonly signatureBlock: "Add your signature here. Required.";
+    readonly signatureBlockDone: "Your signature. Select to change it.";
+    readonly finishLater: "Finish later";
+    readonly printAndSign: "Print and sign";
+    readonly decline: "Decline to sign";
+    readonly declineSubmit: "Send my decline";
+    readonly declineCancel: "Go back";
+    readonly signatureName: "Your full legal name";
+    readonly signatureStyle: "Signature style";
+    readonly declineReason: "Why are you declining?";
+    readonly ageConfirm: "I meet the minimum age";
+    readonly documentHeading: "Document";
+    readonly signatureHeading: "Your signature";
+};
+declare const ESIGN_RIGHTS_KEYS: readonly ["heading", "intro", "withdraw", "paperCopy", "working", "error", "confirmTitle", "confirmBody", "confirmSubmit", "confirmCancel", "withdrawnBeforeSigning", "withdrawnAfterSigning", "paperCopyRequested", "paperCopyAlreadyOutstanding"];
+type EsignRightsKey = (typeof ESIGN_RIGHTS_KEYS)[number];
+declare const ESIGN_RIGHTS_FALLBACKS: {
+    readonly heading: "Your rights";
+    readonly intro: "You do not have to use electronic records. You can stop using them for this document, or ask for a paper copy in the mail. Neither costs anything.";
+    readonly withdraw: "Stop using electronic records";
+    readonly paperCopy: "Ask for a mailed paper copy";
+    readonly working: "Working on your request.";
+    readonly error: "Your request did not go through. Select it again. If it keeps failing, contact the company that sent you this link.";
+    readonly confirmTitle: "Withdraw your consent?";
+    readonly confirmBody: "This ends the signing session and no electronic signature is recorded for you. The company that sent you this link is told that you withdrew. This costs nothing and no penalty applies, and you can still ask for a mailed paper copy afterward.";
+    readonly confirmSubmit: "Yes, withdraw consent";
+    readonly confirmCancel: "Go back";
+    readonly withdrawnBeforeSigning: "You withdrew your consent to use electronic records, and nothing was signed. The company that sent you this link has been told. If you want this document on paper, ask for a copy below. You can close this window.";
+    readonly withdrawnAfterSigning: "You withdrew your consent to use electronic records. The document you already signed still stands, because a signature cannot be taken back after the fact. The company that sent you this link has been told. If you want this document on paper, ask them to send you a copy.";
+    readonly paperCopyRequested: "We asked the company that sent you this link to send you a paper copy. There is no fee.";
+    readonly paperCopyAlreadyOutstanding: "A paper copy is already on its way to you, so there was nothing new to request.";
+};
+declare const ESIGN_OUTCOME_RIGHTS_KEY: {
+    readonly consent_withdrawn_before_signing: "withdrawnBeforeSigning";
+    readonly consent_withdrawn_after_signing: "withdrawnAfterSigning";
+    readonly paper_copy_requested: "paperCopyRequested";
+    readonly paper_copy_already_outstanding: "paperCopyAlreadyOutstanding";
+};
+declare const ESIGN_DOCUMENT_KEYS: readonly ["download", "printAndSignStarted", "downloadFailed", "downloadRemoved"];
+type EsignDocumentCopyKey = (typeof ESIGN_DOCUMENT_KEYS)[number];
+declare const ESIGN_DOCUMENT_FALLBACKS: {
+    readonly download: "Download a copy";
+    readonly printAndSignStarted: "Print your copy, sign it by hand, and send it to the company that sent you this link. You cannot return a printed page through this page.";
+    readonly downloadFailed: "We could not download that document. Select it again. If it keeps failing, contact the company that sent you this link.";
+    readonly downloadRemoved: "This copy is no longer stored. Ask the company that sent you this link to send you a new copy or a printed record.";
+};
+declare const ESIGN_COUNT_TOKEN = "{count}";
+declare const ESIGN_SHELL_KEYS: readonly ["stepsBlocked", "gateRead", "gateSignature", "gateAge", "consentTermsLink", "consentTermsNewWindow", "consentAgeAttest", "consentError", "adoptTitle", "adoptConsent", "adoptFinePrint", "declineTitle", "declineBody", "finishLaterTitle", "finishLaterBody", "disclosureTitle", "disclosureVersionLabel", "disclosurePublicCopy", "disclosureBack", "statusSigned", "statusDeclined", "statusVoided", "statusExpired", "statusWithdrawn"];
+type EsignShellKey = (typeof ESIGN_SHELL_KEYS)[number];
+declare const ESIGN_SHELL_FALLBACKS: {
+    readonly stepsBlocked: "Not finished yet. Taking you to what is left.";
+    readonly gateRead: "Please read to the end";
+    readonly gateSignature: "Please sign above";
+    readonly gateAge: "Please confirm your age";
+    readonly consentTermsLink: "See terms.";
+    readonly consentTermsNewWindow: "Opens in a new window.";
+    readonly consentAgeAttest: "I am {count} or older.";
+    readonly consentError: "We could not record your agreement, so your signature was not added. Select the signature line in the document to try again.";
+    readonly adoptTitle: "Add your signature";
+    readonly adoptConsent: "Selecting Use this signature also records your agreement to sign and to get records for this document electronically.";
+    readonly adoptFinePrint: "Use this signature adopts what you see above as your signature. Selecting Finish signs the document.";
+    readonly declineTitle: "Decline to sign?";
+    readonly declineBody: "This ends your signing session and tells the company that sent you this link. No penalty applies. You can ask them for a new link later.";
+    readonly finishLaterTitle: "Finish later?";
+    readonly finishLaterBody: "Come back to this same link any time before the deadline. What you have done is kept.";
+    readonly disclosureTitle: "Using electronic records";
+    readonly disclosureVersionLabel: "Notice version";
+    readonly disclosurePublicCopy: "Open this notice in a new window";
+    readonly disclosureBack: "Back to the document";
+    readonly statusSigned: "Signed";
+    readonly statusDeclined: "Declined";
+    readonly statusVoided: "Canceled";
+    readonly statusExpired: "Expired";
+    readonly statusWithdrawn: "Withdrawn";
+};
+type EsignTerminalState = Extract<EsignState, `terminal_${string}`>;
+declare const ESIGN_TERMINAL_STATUS_KEY: {
+    readonly terminal_signed: "statusSigned";
+    readonly terminal_declined: "statusDeclined";
+    readonly terminal_voided: "statusVoided";
+    readonly terminal_expired: "statusExpired";
+    readonly terminal_withdrawn: "statusWithdrawn";
+};
+declare function resolveEsignDocumentCopy(copy: EsignCopy | undefined, key: EsignDocumentCopyKey): string;
+declare function resolveEsignShellCopy(copy: EsignCopy | undefined, key: EsignShellKey): string;
+declare function resolveEsignTerminalStatus(copy: EsignCopy | undefined, state: EsignTerminalState): string;
+declare function resolveEsignRightsCopy(copy: EsignCopy | undefined, key: EsignRightsKey): string;
+declare function resolveEsignOutcomeCopy(copy: EsignCopy | undefined, outcome: EsignConsentOutcome): string;
+declare function resolveEsignLabel(copy: EsignCopy | undefined, label: EsignLabel): string;
+declare function resolveEsignCopy(copy: EsignCopy | undefined, state: EsignState): string;
+declare function resolveEsignFrameTitle(copy: EsignCopy | undefined): string;
+declare const ESIGN_COPY_STATE_KEYS: readonly EsignState[];
+
+interface EsignMountOptions {
+    target: HTMLElement | string;
+    copy?: EsignCopy;
+    onEvent?: (e: ChecktivEsignEvent) => void;
+    session?: {
+        sessionId: string;
+        stepId: string;
+    };
+    fetchImpl?: typeof fetch;
+    onRequestHelp?: (state: EsignState) => void;
+    schedule?: {
+        set(cb: () => void, ms: number): unknown;
+        clear(handle: unknown): void;
+    };
+}
+interface EsignHandle {
+    destroy(): void;
+}
+declare function createEsign(ctx: SubstrateContext, opts: EsignMountOptions): EsignHandle;
+type EsignChunkModule = {
+    createEsign: typeof createEsign;
+};
+
+interface CreditContextMint {
+    readonly creditContextToken: string;
+    readonly embedOrigin: string;
+    readonly expiresAt: string;
+}
+interface CreditHistoryScheduler {
+    set(callback: () => void, ms: number): unknown;
+    clear(handle: unknown): void;
+}
+interface CreditHistoryHostWindow extends Pick<Window, 'addEventListener' | 'removeEventListener'> {
+    readonly parent: {
+        postMessage(message: unknown, targetOrigin: string): void;
+    };
+}
+interface CreditHistoryOptions {
+    readonly win: CreditHistoryHostWindow;
+    readonly target: HTMLElement;
+    readonly sessionId: string;
+    readonly locale: string;
+    readonly theme: CreditTheme;
+    readonly copy?: CreditCopyMap;
+    readonly frameTitle?: string;
+    readonly readyTimeoutMs?: number;
+    readonly schedule?: CreditHistoryScheduler;
+    mintContext(): Promise<CreditContextMint>;
+    onEvent?(event: ChecktivCreditHistoryEvent): void;
+    onBehaviorSegment?(segment: CreditBehaviorSegment): void;
+}
+interface CreditHistoryController {
+    start(): void;
+    destroy(): void;
+}
+declare function clampFrameHeight(height: number): number;
+declare function createCreditHistory(options: CreditHistoryOptions): CreditHistoryController;
+
+interface CreditHistoryMountOptions {
+    target: HTMLElement | string;
+    session: {
+        sessionId: string;
+        stepId: string;
+    };
+    onEvent?: (event: ChecktivCreditHistoryEvent) => void;
+    copy?: CreditCopyMap;
+    frameTitle?: string;
+    onBehaviorSegment?: (segment: CreditBehaviorSegment) => void;
+    fetchImpl?: typeof fetch;
+    win?: CreditHistoryHostWindow;
+}
+interface CreditHistoryHandle {
+    destroy(): void;
+}
+declare function createCreditHistoryModule(ctx: SubstrateContext, opts: CreditHistoryMountOptions): CreditHistoryHandle;
+
+interface ProvisionedHandle {
+    destroy(): void;
+    openCrossDevice?(): void;
+}
+interface MountProvisionedOptions {
+    target: HTMLElement | string;
+    onEvent?: (e: ChecktivEvent) => void;
+    onConsent?: () => boolean | Promise<boolean>;
+    copy?: MountCopy;
+    layout?: CaptureLayout;
+    maxWidth?: string;
+    onBeforeSubmit?: () => Promise<void>;
+    onBehaviorSegment?: (segment: Pick<CaptureBehaviorMessage, 'steps' | 'traits'>) => void;
+    fetchImpl?: typeof fetch;
+    synthetic?: IdvMountOptions['synthetic'];
+    customFormConfig?: CustomFormApplicantConfig;
+    customFormCopy?: CustomFormCopy;
+    esignCopy?: EsignCopy;
+    creditCopy?: CreditCopyMap;
+    crossDeviceCopy?: CrossDeviceCopy;
+    onOpenCrossDevice?: CrossDeviceHandoffHook;
+    onRequestHelp?: EsignMountOptions['onRequestHelp'];
+}
+
+interface GetSessionTokenContext {
+    sessionId: string;
+    reason: 'initial' | 'expired' | '401';
+}
+type GetSessionToken = string | ((ctx: GetSessionTokenContext) => Promise<string>);
+interface ChecktivInitOptionsBase {
+    getSessionToken: GetSessionToken;
+    theme?: {
+        primaryColor?: string;
+    };
+    locale?: string;
+    apiBase?: string;
+    betas?: string[];
+    selfiePromptMap?: SelfiePromptMap;
+    selfieChromeCopy?: SelfieChromeCopy;
+    beginScanCopy?: BeginScanCopyOverrides;
+}
+type ChecktivInitScope = {
+    publishableKey: string;
+} | {
+    region: SdkRegion;
+    mode: SdkMode;
+};
+type ChecktivInitOptions = ChecktivInitOptionsBase & ChecktivInitScope;
+interface ChecktivClient {
+    mountProvisioned(opts: MountProvisionedOptions): ProvisionedHandle;
+    preload(modules: readonly SdkModuleName[]): void;
+    mount(module: 'idv', opts: IdvMountOptions): IdvHandle;
+    mount(module: 'fraud', opts: FraudMountOptions): FraudHandle;
+    mount(module: 'custom_form', opts: CustomFormMountOptions): CustomFormHandle;
+    mount(module: 'esign', opts: EsignMountOptions): EsignHandle;
+    mount(module: 'credit_history', opts: CreditHistoryMountOptions): CreditHistoryHandle;
+}
+interface SubstrateContext {
+    readonly region: SdkRegion;
+    readonly mode: SdkMode;
+    readonly publishableKey: string | undefined;
+    readonly apiBaseOrigin: string;
+    readonly theme?: ChecktivInitOptions['theme'];
+    readonly locale: string;
+    readonly betas: readonly string[];
+    readonly selfiePromptMap?: SelfiePromptMap;
+    readonly selfieChromeCopy?: SelfieChromeCopy;
+    readonly beginScanCopy?: BeginScanCopyOverrides;
+    readonly tokens: TokenManager;
+    getSessionId(): string;
+    setSessionId(id: string): void;
+}
+
+type ChecktivFraudEvent = {
+    type: 'checktiv.fraud.started';
+} | {
+    type: 'checktiv.fraud.error';
+    error: ChecktivError;
+};
+interface FraudMountOptions {
+    onConsent: () => boolean | Promise<boolean>;
+    onEvent?: (e: ChecktivFraudEvent) => void;
+    fetchImpl?: typeof fetch;
+}
+interface FraudHandle {
+    destroy(): void;
+}
+declare function createFraud(ctx: SubstrateContext, opts: FraudMountOptions): FraudHandle;
+type FraudChunkModule = {
+    createFraud: typeof createFraud;
+};
+
+type IdvCoachingHint = CoachingKind;
+interface ResolvedIdvConfig {
+    documentTypes: readonly string[];
+    biometricMode: 'selfie' | 'liveness' | 'none';
+    allowDocumentUpload?: boolean;
+}
+type ChecktivIdvEvent = {
+    type: 'checktiv.idv.ready';
+    config: ResolvedIdvConfig;
+} | {
+    type: 'checktiv.idv.phase';
+    phase: string;
+} | {
+    type: 'checktiv.idv.coaching';
+    hint: IdvCoachingHint;
+} | {
+    type: 'checktiv.idv.submitted';
+    sessionId: string;
+} | {
+    type: 'checktiv.idv.processing';
+    reason?: 'signal_pending' | 'no_renderable_step';
+} | {
+    type: 'checktiv.idv.capture_superseded';
+} | {
+    type: 'checktiv.idv.error';
+    error: ChecktivError;
+} | {
+    type: 'checktiv.idv.cross_device_opened';
+} | {
+    type: 'checktiv.idv.cross_device_unavailable';
+} | {
+    type: 'checktiv.idv.cross_device_capped';
+} | {
+    type: 'checktiv.idv.cross_device_closed';
+} | ({
+    type: 'checktiv.idv.timing';
+} & CaptureTimingSnapshot);
+type ChecktivEvent = ChecktivIdvEvent | ChecktivFraudEvent | {
+    type: `checktiv.${string}`;
+    [k: string]: unknown;
+};
+
+type SdkRegion = DataRegion;
+type SdkMode = SystemMode;
+interface InitOptions {
+    readonly publishableKey: string;
+    readonly applicantLinkToken?: string;
+    readonly target?: HTMLElement;
+    readonly onComplete?: (payload: unknown) => void;
+}
+interface MountCompleteResult {
+    readonly sessionId: string;
+}
+type MountScope = {
+    readonly publishableKey: string;
+} | {
+    readonly region: SdkRegion;
+    readonly mode: SdkMode;
+};
+type MountOptions = MountScope & {
+    readonly fetchToken: () => Promise<string>;
+    readonly onComplete?: (result: MountCompleteResult) => void;
+    readonly onEvent?: (e: ChecktivEvent) => void;
+    readonly onError?: (e: ChecktivError) => void;
+    readonly onConsent?: () => boolean | Promise<boolean>;
+    readonly apiBase?: string;
+    readonly fetchImpl?: typeof fetch;
+    readonly resumeKey?: string;
+    readonly shortCode?: string;
+    readonly layout?: CaptureLayout;
+    readonly maxWidth?: string;
+    readonly theme?: {
+        readonly primaryColor?: string;
+    };
+    readonly copy?: MountCopy;
+    readonly crossDeviceCopy?: CrossDeviceCopy;
+    readonly onOpenCrossDevice?: CrossDeviceHandoffHook;
+};
+interface SessionsCreateApplicantAddress {
+    readonly line1: string;
+    readonly line2?: string;
+    readonly city: string;
+    readonly region?: string;
+    readonly postalCode?: string;
+    readonly country: string;
+    readonly placeId?: string;
+    readonly formatted?: string;
+}
+interface SessionsCreateApplicant {
+    readonly externalId?: string;
+    readonly email?: string;
+    readonly phone?: string;
+    readonly familyName?: string;
+    readonly givenNames?: readonly string[];
+    readonly nameSuffix?: string;
+    readonly dateOfBirth?: string;
+    readonly address?: SessionsCreateApplicantAddress;
+    readonly referenceName?: string;
+    readonly bookingName?: string;
+}
+interface SessionsCreateInput {
+    readonly templateId: string;
+    readonly applicant: SessionsCreateApplicant;
+}
+interface SessionsCreateOptions {
+    readonly apiBase: string;
+    readonly secretKey: string;
+    readonly idempotencyKey?: string;
+    readonly fetchImpl?: typeof fetch;
+}
+interface SessionsCreateResult {
+    readonly clientToken: string;
+}
+interface ChecktivSessions {
+    create(input: SessionsCreateInput, options: SessionsCreateOptions): Promise<SessionsCreateResult>;
+}
+interface ParsedPublishableKey {
+    readonly region: SdkRegion;
+    readonly mode: SdkMode;
+}
+declare class InvalidPublishableKeyError extends Error {
+    constructor(message: string);
+}
+declare function parsePublishableKey(key: string): ParsedPublishableKey;
+
+export { type SdkRegion as $, type EsignRightsKey as A, type EsignShellKey as B, type ChecktivEsignEvent as C, type EsignState as D, ESIGN_CONSENT_ACTIONS as E, type EsignSubmitOutcome as F, type EsignTerminalState as G, type TerminalEnvelopeStatus as H, createEsign as I, esignStateOffersRights as J, resolveEsignCopy as K, resolveEsignDocumentCopy as L, resolveEsignFrameTitle as M, resolveEsignLabel as N, resolveEsignOutcomeCopy as O, resolveEsignRightsCopy as P, resolveEsignShellCopy as Q, resolveEsignTerminalStatus as R, type ChecktivIdvEvent as S, TERMINAL_STATUS_TO_STATE as T, type MountOptions as U, type ChecktivInitOptions as V, type ChecktivInitScope as W, type ChecktivClient as X, type SubstrateContext as Y, type CrossDeviceHandoffHook as Z, type TokenManager as _, ESIGN_COPY_FALLBACKS as a, type CreditHistoryController as a$, type ProvisionedHandle as a0, type InitOptions as a1, type ChecktivSessions as a2, CHECKTIV_ERROR_CODES as a3, type ChecktivCreditHistoryEvent as a4, type ChecktivError as a5, type ChecktivErrorCode as a6, type ChecktivEvent as a7, type ChecktivFraudEvent as a8, type ChecktivKnownErrorCode as a9, isChecktivCreditHistoryEvent as aA, parsePublishableKey as aB, type ForwardedSession as aC, type IdvChunkModule as aD, REMINT_READY_TIMEOUT_MS as aE, createIdv as aF, type FraudChunkModule as aG, createFraud as aH, type ChecktivCustomFormEvent as aI, type CustomFormChunkModule as aJ, type CustomFormCopy as aK, type CustomFormFieldCopy as aL, type CustomFormHandle as aM, type CustomFormMountOptions as aN, createCustomForm as aO, CREDIT_FRAME_MAX_HEIGHT_PX as aP, CREDIT_FRAME_MIN_HEIGHT_PX as aQ, CREDIT_HISTORY_EVENT_TYPES as aR, CREDIT_SCREENS as aS, CREDIT_SCREEN_COUNT as aT, type CreditBehaviorSegment as aU, type CreditBehaviorStep as aV, type CreditBehaviorTraits as aW, type CreditBrandTokens as aX, type CreditContextMint as aY, type CreditCopyMap as aZ, type CreditFromIframeMessage as a_, type ChecktivRecovery as aa, type CreditErrorCode as ab, type CreditHistoryReconnectReason as ac, type CreditScreen as ad, type CreditSkipReason as ae, type FraudHandle as af, type FraudMountOptions as ag, type GetSessionToken as ah, type GetSessionTokenContext as ai, type IdvCoachingHint as aj, type IdvHandle as ak, type IdvMountOptions as al, InvalidPublishableKeyError as am, type MountCompleteResult as an, type MountProvisionedOptions as ao, type MountScope as ap, type ParsedPublishableKey as aq, type ResolvedIdvConfig as ar, type SdkMode as as, type SessionsCreateApplicant as at, type SessionsCreateApplicantAddress as au, type SessionsCreateInput as av, type SessionsCreateOptions as aw, type SessionsCreateResult as ax, type SyntheticIdvScript as ay, createChecktivError as az, ESIGN_COPY_STATE_KEYS as b, type CreditHistoryHandle as b0, type CreditHistoryHostWindow as b1, type CreditHistoryMountOptions as b2, type CreditHistoryOptions as b3, type CreditHistoryScheduler as b4, type CreditInitMessage as b5, type CreditTheme as b6, clampFrameHeight as b7, createCreditHistory as b8, createCreditHistoryModule as b9, parseCreditInbound as ba, projectCreditCopy as bb, ESIGN_COUNT_TOKEN as c, ESIGN_DOCUMENT_FALLBACKS as d, ESIGN_DOCUMENT_KEYS as e, ESIGN_FRAME_ANNOUNCE_TIMEOUT_MS as f, ESIGN_LABELS as g, ESIGN_LABEL_FALLBACKS as h, ESIGN_OUTCOME_RIGHTS_KEY as i, ESIGN_RIGHTS_FALLBACKS as j, ESIGN_RIGHTS_KEYS as k, ESIGN_SHELL_FALLBACKS as l, ESIGN_SHELL_KEYS as m, ESIGN_STATES as n, ESIGN_STATE_RIGHTS as o, ESIGN_TERMINAL_STATUS_KEY as p, type EsignChunkModule as q, type EsignConsentAction as r, type EsignConsentOutcome as s, type EsignCopy as t, type EsignCopyScalarKey as u, type EsignDocumentCopyKey as v, type EsignHandle as w, type EsignLabel as x, type EsignMountOptions as y, type EsignRightsAffordance as z };