@checktiv/sdk-web 1.9.0 → 1.10.0

package/dist/agents/manifest.json

@@ -23,6 +23,18 @@
         "custom_form:steps:submit"
       ],
       "eventNamespace": "checktiv.custom_form"
+    },
+    "esign": {
+      "scopes": [
+        "sessions:me:read",
+        "esign:bundle:read",
+        "esign:context:mint",
+        "esign:events:write",
+        "esign:steps:submit",
+        "esign:consent:withdraw",
+        "esign:document:read"
+      ],
+      "eventNamespace": "checktiv.esign"
     }
   },
   "rules": [

package/dist/api-EY_fOZm-.d.ts

@@ -0,0 +1,578 @@
+import { C as CaptureLayout, a as CaptureBehaviorMessage, k as SelfiePromptMap, l as SelfieChromeCopy, B as BeginScanCopyOverrides, b as CoachingKind } from './machine-DXxarDcC.js';
+import { M as MountCopy } from './copy-D6Sd0BIe.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;
+
+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 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;
+}
+interface IdvHandle {
+    destroy(): void;
+    unmount(): void;
+    openCrossDevice?(): void;
+}
+declare const REMINT_READY_TIMEOUT_MS = 15000;
+declare function createIdv(ctx: SubstrateContext, opts: IdvMountOptions): IdvHandle;
+
+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[];
+};
+
+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;
+}
+
+type ChecktivCustomFormEvent = {
+    type: 'checktiv.custom_form.ready';
+} | {
+    type: 'checktiv.custom_form.submitted';
+    sessionId: string;
+} | {
+    type: 'checktiv.custom_form.error';
+    error: ChecktivError;
+};
+
+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;
+
+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 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[];
+
+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;
+};
+
+interface EsignContextMint {
+    contextToken: string;
+    embedOrigin: string;
+    disclosureLocale: string;
+}
+declare function parseEsignMint(body: unknown): EsignContextMint | null;
+declare function parseEsignPending(body: unknown): {
+    retryAfterMs: number;
+} | null;
+
+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;
+
+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;
+    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;
+    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;
+}
+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 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 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;
+}
+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 { createCustomForm as $, type SessionsCreateApplicant as A, type SessionsCreateApplicantAddress as B, type ChecktivInitOptions as C, type SessionsCreateInput as D, type EsignCopy as E, type FraudHandle as F, type GetSessionToken as G, type SessionsCreateOptions as H, type InitOptions as I, type SessionsCreateResult as J, type SyntheticIdvScript as K, createChecktivError as L, type MountOptions as M, parsePublishableKey as N, type ChecktivInitScope as O, type ProvisionedHandle as P, type SubstrateContext as Q, type ResolvedIdvConfig as R, type SdkRegion as S, type TokenManager as T, REMINT_READY_TIMEOUT_MS as U, createIdv as V, type ChecktivCustomFormEvent as W, type CustomFormCopy as X, type CustomFormFieldCopy as Y, type CustomFormHandle as Z, type CustomFormMountOptions as _, type ChecktivClient as a, ESIGN_CONSENT_ACTIONS as a0, ESIGN_COPY_FALLBACKS as a1, ESIGN_COPY_STATE_KEYS as a2, ESIGN_COUNT_TOKEN as a3, ESIGN_DOCUMENT_FALLBACKS as a4, ESIGN_DOCUMENT_KEYS as a5, ESIGN_FRAME_ANNOUNCE_TIMEOUT_MS as a6, ESIGN_LABELS as a7, ESIGN_LABEL_FALLBACKS as a8, ESIGN_OUTCOME_RIGHTS_KEY as a9, resolveEsignFrameTitle as aA, resolveEsignLabel as aB, resolveEsignOutcomeCopy as aC, resolveEsignRightsCopy as aD, resolveEsignShellCopy as aE, resolveEsignTerminalStatus as aF, createFraud as aG, ESIGN_RIGHTS_FALLBACKS as aa, ESIGN_RIGHTS_KEYS as ab, ESIGN_SHELL_FALLBACKS as ac, ESIGN_SHELL_KEYS as ad, ESIGN_STATES as ae, ESIGN_STATE_RIGHTS as af, ESIGN_TERMINAL_STATUS_KEY as ag, type EsignConsentAction as ah, type EsignConsentOutcome as ai, type EsignContextMint as aj, type EsignCopyScalarKey as ak, type EsignDocumentCopyKey as al, type EsignLabel as am, type EsignRightsAffordance as an, type EsignRightsKey as ao, type EsignShellKey as ap, type EsignSubmitOutcome as aq, type EsignTerminalState as ar, TERMINAL_STATUS_TO_STATE as as, type TerminalEnvelopeStatus as at, createEsign as au, esignStateOffersRights as av, parseEsignMint as aw, parseEsignPending as ax, resolveEsignCopy as ay, resolveEsignDocumentCopy as az, type ChecktivSessions as b, CHECKTIV_ERROR_CODES as c, type ChecktivError as d, type ChecktivErrorCode as e, type ChecktivEsignEvent as f, type ChecktivEvent as g, type ChecktivFraudEvent as h, type ChecktivIdvEvent as i, type ChecktivKnownErrorCode as j, type ChecktivRecovery as k, type CrossDeviceHandoffHook as l, type EsignHandle as m, type EsignMountOptions as n, type EsignState as o, type FraudMountOptions as p, type GetSessionTokenContext as q, type IdvCoachingHint as r, type IdvHandle as s, type IdvMountOptions as t, InvalidPublishableKeyError as u, type MountCompleteResult as v, type MountProvisionedOptions as w, type MountScope as x, type ParsedPublishableKey as y, type SdkMode as z };

package/dist/capture-ui.d.ts

@@ -1,7 +1,7 @@
-import { a as CaptureControllerDeps, b as CaptureEvent } from './controller-Ta5RgFZ4.js';
-import { C as CaptureLayout, f as CaptureState } from './machine-BhPiYmOR.js';
-import { M as MountCopy } from './copy-CEILzVXc.js';
-export { T as TerminalKind, f as fallbackCopy } from './copy-CEILzVXc.js';
+import { a as CaptureControllerDeps, b as CaptureEvent } from './controller-CO5r6vXD.js';
+import { C as CaptureLayout, f as CaptureState } from './machine-DXxarDcC.js';
+import { M as MountCopy } from './copy-D6Sd0BIe.js';
+export { T as TerminalKind, f as fallbackCopy } from './copy-D6Sd0BIe.js';
 
 interface MountCaptureOptions extends Omit<CaptureControllerDeps, 'getIframe'> {
     copy: MountCopy;

package/dist/capture-ui.js

@@ -1,9 +1,9 @@
-export { fallbackCopy, mount } from './chunk-FL2GCRSI.js';
+export { fallbackCopy, mount } from './chunk-YRM5SYRT.js';
+import './chunk-T6NMRTFB.js';
+import './chunk-NHNGQ5BB.js';
+import './chunk-ZU4L3NDZ.js';
 import './chunk-HV2QKVJX.js';
 import './chunk-XOGHMNBX.js';
-import './chunk-T4R5TTE5.js';
-import './chunk-NHNGQ5BB.js';
-import './chunk-XSSM5ZB7.js';
 import './chunk-IQKHRPJR.js';
 import './chunk-QFA3K5ZV.js';
 import './chunk-AIK7CDV6.js';

package/dist/capture.d.ts

@@ -1,6 +1,6 @@
-export { C as CaptureController, a as CaptureControllerDeps, b as CaptureEvent, c as CaptureEventType, S as SubmitResult, d as createCaptureController } from './controller-Ta5RgFZ4.js';
-import { b as CoachingKind } from './machine-BhPiYmOR.js';
-export { c as CaptureAction, d as CaptureErrorKind, e as CapturePhase, f as CaptureState, i as isBiometricPhase, n as nextCapturePhaseAfterDocument, r as reducer } from './machine-BhPiYmOR.js';
+export { C as CaptureController, a as CaptureControllerDeps, b as CaptureEvent, c as CaptureEventType, S as SubmitResult, d as createCaptureController } from './controller-CO5r6vXD.js';
+import { b as CoachingKind } from './machine-DXxarDcC.js';
+export { c as CaptureAction, d as CaptureErrorKind, e as CapturePhase, f as CaptureState, i as isBiometricPhase, n as nextCapturePhaseAfterDocument, r as reducer } from './machine-DXxarDcC.js';
 
 declare function coachingKindForState(state: string): CoachingKind;
 

package/dist/capture.js

@@ -1,6 +1,6 @@
-export { coachingKindForState, createCaptureController, isBiometricPhase, nextCapturePhaseAfterDocument, reducer } from './chunk-T4R5TTE5.js';
+export { coachingKindForState, createCaptureController, isBiometricPhase, nextCapturePhaseAfterDocument, reducer } from './chunk-T6NMRTFB.js';
 import './chunk-NHNGQ5BB.js';
-import './chunk-XSSM5ZB7.js';
+import './chunk-ZU4L3NDZ.js';
 import './chunk-IQKHRPJR.js';
 import './chunk-QFA3K5ZV.js';
 import './chunk-AIK7CDV6.js';

package/dist/challenge.js

@@ -1,5 +1,5 @@
-import { assertNever } from './chunk-UBQTPS5J.js';
 import { external_exports } from './chunk-NHNGQ5BB.js';
+import { assertNever } from './chunk-UBQTPS5J.js';
 import './chunk-AIK7CDV6.js';
 
 var canonicalOriginSchema=external_exports.string().min(1).refine(v=>{if(v.includes("*"))return false;try{return new URL(v).origin===v}catch{return false}},"must be a canonical origin (scheme and host[:port], no path / query / fragment / credentials / wildcard)");var challengeErrorCodeEnum=external_exports.enum(["challenge_failed","load_failed","expired","config_error"]);var challengeInitMessageSchema=external_exports.object({type:external_exports.literal("challenge:init"),theme:external_exports.enum(["light","dark"]).optional(),locale:external_exports.string().optional()}).strict();var challengeResetMessageSchema=external_exports.object({type:external_exports.literal("challenge:reset")}).strict();external_exports.discriminatedUnion("type",[challengeInitMessageSchema,challengeResetMessageSchema]);var challengeReadyMessageSchema=external_exports.object({type:external_exports.literal("challenge:ready")}).strict();var challengeTokenMessageSchema=external_exports.object({type:external_exports.literal("challenge:token"),token:external_exports.string().min(1)}).strict();var challengeErrorMessageSchema=external_exports.object({type:external_exports.literal("challenge:error"),code:challengeErrorCodeEnum}).strict();var challengeFromIframeMessageSchema=external_exports.discriminatedUnion("type",[challengeReadyMessageSchema,challengeTokenMessageSchema,challengeErrorMessageSchema]);external_exports.object({challengeContextToken:external_exports.string().min(1),embedOrigin:canonicalOriginSchema}).strict();function createChallengeController(deps){let started=false;let destroyed=false;let resetInFlight=false;let messageListener=null;function postInit(){const iframe=deps.getIframe();if(iframe===null||iframe.contentWindow===null)return;const init={type:"challenge:init",...deps.theme!==void 0?{theme:deps.theme}:{},...deps.locale!==void 0?{locale:deps.locale}:{}};iframe.contentWindow.postMessage(init,deps.embedOrigin);}function postReset(){const iframe=deps.getIframe();if(iframe===null||iframe.contentWindow===null)return;const reset={type:"challenge:reset"};iframe.contentWindow.postMessage(reset,deps.embedOrigin);}function handleMessage(msg){switch(msg.type){case "challenge:ready":{resetInFlight=false;return}case "challenge:token":{resetInFlight=false;deps.onToken(msg.token);return}case "challenge:error":{resetInFlight=false;deps.onError(msg.code);return}default:{return assertNever(msg)}}}function onWindowMessage(event){if(destroyed)return;if(event.origin!==deps.embedOrigin)return;if(event.source!==null&&event.source!==deps.getIframe()?.contentWindow)return;const parsed=challengeFromIframeMessageSchema.safeParse(event.data);if(!parsed.success)return;handleMessage(parsed.data);}return {start(){if(destroyed||started)return;started=true;messageListener=onWindowMessage;window.addEventListener("message",messageListener);postInit();},reset(){if(destroyed||!started)return;if(resetInFlight)return;resetInFlight=true;postReset();},destroy(){if(destroyed)return;destroyed=true;if(messageListener!==null){window.removeEventListener("message",messageListener);messageListener=null;}}}}