@sekyro/node 0.1.0-rc.3 → 0.1.0-rc.5

package/dist/index.d.cts

@@ -16,12 +16,14 @@ type SessionStatus = "created" | "in_progress" | "review_pending" | "completed"
 type SessionOutcome = "approved" | "review" | "rejected";
 /**
  * How the person proves their identity on an optional-document app: type the
- * national number, or photograph the document.
+ * national number, or photograph the document (`document_chip`: native NFC clients only).
+ * `national_eid`: the country's national eID (e.g. Houwiyeti for Mauritania),
+ * offered when the app's profile turns the national eID on.
  * @public
  */
-type IdentityMethod = "national_number" | "document_photo";
+type IdentityMethod = "national_number" | "document_photo" | "document_chip" | "national_eid";
 /** The verification checks a flow may contain. @public */
-type CheckType = "liveness" | "face_match" | "doc_ocr" | "population_registry" | "phone_otp";
+type CheckType = "liveness" | "face_match" | "doc_ocr" | "population_registry" | "phone_otp" | "nfc_chip" | "email_otp" | "portrait_icao" | "eid_auth";
 /** Per-check execution state within a session. @public */
 type CheckState = "pending" | "input_required" | "processing" | "passed" | "failed" | "review" | "skipped";
 /**
@@ -79,6 +81,14 @@ type PolicyFailureReason = SessionFailureReason | EligibilityReason | "document_
  * @public
  */
 type MatchReason = "name_mismatch" | "birth_date_mismatch" | "nationality_mismatch" | "document_number_mismatch";
+/**
+ * Face-match probe-binding reason a `face_match` {@link SessionStep.reason} may
+ * carry (SDK spec §4.10): `probe_not_from_liveness` — the face image isn't the
+ * person in the liveness clip. Retryable within the step's attempts (the
+ * person re-takes the liveness capture); billed.
+ * @public
+ */
+type ProbeBindingReason = "probe_not_from_liveness";
 /** Hosted-flow languages. @public */
 type Locale = "ar" | "fr" | "en";
 /** The environment a webhook was emitted from. @public */
@@ -91,12 +101,69 @@ type SekyroEnvironment = "sandbox" | "live";
 interface SessionStep {
     checkType: CheckType;
     state: CheckState;
+    /** Sekyro flows: the flow node this check belongs to (e.g. `n_live`). */
+    nodeId?: string;
+    /** Sekyro flows: the service of that node. */
+    service?: ServiceId;
+    /** Sekyro flows: the check failed and the flow's fallback took over. */
+    handled?: true;
     /** Machine-readable failure/review reason, when the check has one. */
     reason?: string;
     /** Calibrated model score in [0, 1] for scored checks (liveness, face match). */
     calibratedScore?: number;
     /** The check failed after using all of its attempts. */
     attemptsExhausted?: boolean;
+    /**
+     * `portrait_icao` only (ID mode): the per-criterion ICAO report of the last
+     * attempt — numbers and enums only, never the image.
+     */
+    report?: PortraitReportEntry[];
+    /**
+     * `face_match` only: the probe-quality measurement of the selfie that was
+     * matched (occlusion, head pose, eye openness, sharpness). Recorded for
+     * information only: it never changes the step's state or reason.
+     */
+    probeQuality?: ProbeQuality;
+}
+/**
+ * The probe-quality measurement on a `face_match` step. Numbers only; `null`
+ * means the value could not be measured. Informational: no threshold applies.
+ * @public
+ */
+interface ProbeQuality {
+    /** Share of the inner face that is covered (a hand, a mask, a phone), in [0, 1]. */
+    occlusion: number | null;
+    /** Head pose in degrees. */
+    pose: {
+        yaw: number | null;
+        pitch: number | null;
+        roll: number | null;
+    };
+    /** Openness of the less-open eye, in [0, 1]. */
+    eyesOpen: number | null;
+    /** Sharpness of the face region (higher is sharper; no fixed scale). */
+    sharpness: number | null;
+}
+/**
+ * One row of the `portrait_icao` report (ID mode): the server's measurement of
+ * one ICAO criterion and the threshold that applied.
+ * @public
+ */
+interface PortraitReportEntry {
+    criterion: "pose" | "eyes" | "mouth" | "occlusion" | "glare" | "lighting" | "background" | "resolution";
+    value: number | null;
+    threshold: number | string | null;
+    pass: boolean;
+}
+/**
+ * A short-lived link to a session's ICAO portrait (480×640 JPEG), from
+ * {@link SessionsApi.portrait}. Download it before `expiresAt`; never store the URL.
+ * @public
+ */
+interface SessionPortraitLink {
+    url: string;
+    /** ISO 8601 (about 5 minutes after the call). */
+    expiresAt: string;
 }
 /**
  * Out-of-band delivery of the session's hosted link, sent by Sekyro AI after the
@@ -134,24 +201,84 @@ interface SessionSubjectInput {
      * its webhooks, and searchable on the subjects API.
      */
     externalRef?: string;
+    /**
+     * Returning user (profile v2 step 5): verify this already-verified subject
+     * again with liveness + face match only, against the reference photo stored
+     * on the subject. Name exactly one target. Errors at create:
+     * `404 subject_not_found`, `409 subject_revoked`, `409 subject_no_reference`,
+     * `409 subject_stale` (older than the flow's `returning.maxAgeMonths`),
+     * `409 reuse_disabled` (the flow turns returning-user sessions off) and
+     * `400` / `409 reuse_target_ambiguous`.
+     */
+    reuse?: SubjectReuseTarget;
 }
-/** A document type the backend reads (kyc-docs-v2 vocabulary). @public */
-type ProfileDocumentType = "carte_identite" | "passport";
 /**
- * The settings of an app's eKYC profile that a session may override — a
- * mirror of the backend profile (schema version 2) without `schemaVersion`,
- * `link` (use {@link CreateSessionInput.ttlMinutes}) and `overrides` (the
- * app's own permission). Country codes are ISO 3166-1 alpha-2 (`MR`).
- * Used through {@link EkycProfileOverride}.
+ * Which subject a returning-user session re-verifies — exactly ONE of the
+ * subject id, your own `externalRef` (must match a single subject) or the NNI.
  * @public
  */
-interface EkycProfileSettings {
-    /** Phone OTP step: off, or on with where the number comes from. */
-    phone: "off" | {
-        numberSource: "prefilled" | "user_entered" | "prefilled_or_entered";
+type SubjectReuseTarget = {
+    subjectId: string;
+    externalRef?: never;
+    nni?: never;
+} | {
+    externalRef: string;
+    subjectId?: never;
+    nni?: never;
+} | {
+    nni: string;
+    subjectId?: never;
+    externalRef?: never;
+};
+/** A document type the backend reads (kyc-docs-v2 vocabulary; `carte_identite` = identity card of any issuer). @public */
+type ProfileDocumentType = "carte_identite" | "passport" | "residence_permit";
+/**
+ * The services a Sekyro flow is built from. A session's steps
+ * ({@link SessionStep.service}) and {@link FlowOverrides.services} use these
+ * ids; one service may run several checks (e.g. `liveness` with an ICAO
+ * portrait).
+ * @public
+ */
+type ServiceId = "device_network" | "phone_otp" | "email_otp" | "national_eid" | "document" | "nfc" | "population_registry" | "supplied_identity" | "summary_confirm" | "liveness" | "face_match" | "aml_screening" | "face_dedup";
+/**
+ * The general settings of a flow that a session may override (the flow's
+ * `link`, `language` and override policy are not overridable). Country codes
+ * are ISO 3166-1 alpha-2 (`MR`). Used through {@link FlowOverrides.settings}.
+ * @public
+ */
+interface FlowOverridableSettings {
+    /** Who may be verified. */
+    eligibility: {
+        /** Accepted nationalities: `'*'` or a list, optionally per IP location. */
+        nationalities: {
+            default: "*" | string[];
+            byLocation?: Record<string, "*" | string[]>;
+        };
+        /** Minimum age in years (1–120), or `null` for none. */
+        minAge: number | null;
     };
-    document: {
-        mode: "off" | "optional" | "mandatory";
+    /** Automatic decisions instead of human review (`retryConfidentRejects` lets confident rejects retry). */
+    decisions?: {
+        mode: "automatic" | "review";
+        retryConfidentRejects: boolean;
+    };
+    /** Data consistency across sources. */
+    fraud: {
+        /** Comparison of your `subject` data with the reference identity. */
+        nameMatch?: {
+            level: "strict" | "standard" | "lenient";
+            onMismatch: "fail" | "signal";
+        };
+    };
+    /** Returning-user sessions (`subject.reuse`). */
+    returning: {
+        /** `false`: returning-user sessions are refused (`409 reuse_disabled`). */
+        enabled: boolean;
+        /** Maximum age in months (1–120) of the subject's last verification; `null` = no limit. */
+        maxAgeMonths: number | null;
+    };
+    /** Identity-document rules. */
+    documents: {
         /** Accepted document types: `'*'` (all) or a list, optionally per issuing country. */
         accepted: {
             default: "*" | ProfileDocumentType[];
@@ -163,69 +290,122 @@ interface EkycProfileSettings {
         };
         authenticity: "standard" | "off";
     };
-    registry: {
-        enabled: boolean;
-        sources: Array<"MR.anrpts">;
-        /** Which identity is the reference for face match and your data. */
-        reference?: "document" | "registry";
-        /** What happens when the registry has no record for the NNI. */
-        onNoRecord?: "fail" | "use_document";
+}
+/**
+ * Document substitution: the portrait a `document` or `nfc` step produces is
+ * compared with the registry portrait (or the chip with the printed photo).
+ * `signal` records a risk signal on a clear mismatch, `review` also sends the
+ * session to review, `off` compares nothing. `failBelow` is the mismatch bound
+ * in (0, 1), absent = the platform bound.
+ * @public
+ */
+interface DocumentSubstitutionSettings {
+    mode: "off" | "signal" | "review";
+    failBelow?: number;
+}
+/**
+ * The per-service settings a session may override, by {@link ServiceId}.
+ * `attempts` limits are per step (absent = the platform default).
+ * @public
+ */
+interface FlowServiceSettings {
+    /** Device & Network Intelligence: IP location, anonymizers, cooldown, device and capture postures. */
+    device_network: {
+        /** Where the end user may be (IP location). */
+        locations: {
+            mode: "all";
+        } | {
+            mode: "only" | "all_except";
+            countries: string[];
+        };
+        /** VPN / proxy / Tor. */
+        anonymizers: "allow" | "block";
+        /** Device cooldown after repeated rejections (at most 5 tiers; `[]` = off). */
+        cooldown?: {
+            tiers: Array<{
+                rejectedSessions: number;
+                windowHours: number;
+                waitMinutes: number;
+            }>;
+        };
+        /** Device tamper and velocity actions. */
+        device?: {
+            tamper: "block" | "signal";
+            velocity: {
+                maxIdentitiesPerDevice: number;
+                windowDays: number;
+                action: "signal" | "block";
+            };
+        };
+        attestation?: "off" | "signal" | "enforce";
+        captureIntegrity?: "off" | "signal" | "enforce";
     };
-    liveness: {
-        enabled: boolean;
+    phone_otp: {
+        /** Where the number comes from: your `subject.phone` / `input.phone`, the person, or either. */
+        numberSource: "prefilled" | "user_entered" | "prefilled_or_entered";
+        /** Narrow the channels the person may choose from (absent = every channel the org has on). */
+        channels?: Array<"whatsapp" | "sms">;
+        /** Which countries codes may be sent to (absent = the flow's allowed `locations`). */
+        destinations?: "locations" | "any" | {
+            countries: string[];
+        };
+        attempts?: number;
     };
-    faceMatch: {
-        enabled: boolean;
+    email_otp: {
+        /** Where the address comes from: your `input.email`, the person, or either. */
+        emailSource: "prefilled" | "user_entered" | "prefilled_or_entered";
+        /** Disposable (temporary) addresses: allowed, flagged as a risk signal (default), or refused. */
+        disposable?: "allow" | "signal" | "block";
+        attempts?: number;
     };
-    /** Comparison of your `subject` data with the reference identity. */
-    nameMatch?: {
-        level: "strict" | "standard" | "lenient";
-        onMismatch: "fail" | "signal";
+    national_eid: {
+        /**
+         * `'org'` (every national eID the org can use, resolved at session create)
+         * or provider ids (`{country}.{provider}`, e.g. `MR.houwiyeti`).
+         */
+        providers: "org" | string[];
+        /** The eID portrait is the face-match reference. */
+        portraitReference: boolean;
     };
-    /** Per-step attempt limits. */
-    attempts?: {
-        phone: number;
-        document: number;
-        registry: number;
-        liveness: number;
-        faceMatch: number;
+    document: {
+        attempts?: number;
+        /** Compare the document photo with the registry photo (absent = the platform default). */
+        documentSubstitution?: DocumentSubstitutionSettings;
     };
-    /** Where the end user may be (IP location). */
-    locations: {
-        mode: "all";
-    } | {
-        mode: "only" | "all_except";
-        countries: string[];
+    /** The chip read (its MRZ source is derived from the flow and is not overridable). */
+    nfc: {
+        maxAttempts?: number;
+        /** Compare the chip photo with the registry photo (absent = the platform default). */
+        documentSubstitution?: DocumentSubstitutionSettings;
     };
-    anonymizers: "allow" | "block";
-    /** Accepted nationalities: `'*'` or a list, optionally per IP location. */
-    nationalities: {
-        default: "*" | string[];
-        byLocation?: Record<string, "*" | string[]>;
+    population_registry: {
+        /** `'org'` (every registry the org can use, resolved at session create) or registry ids. */
+        sources: "org" | Array<"MR.anrpts">;
+        nniSource: "auto" | "typed" | "bound_only";
+        onUncovered: "skip";
+        attempts?: number;
     };
-    /** Minimum age in years (1–120), or `null` for none. */
-    minAge: number | null;
-    /** Automatic decisions instead of human review (`retryConfidentRejects` lets confident rejects retry). */
-    decisions?: {
-        mode: "automatic" | "review";
-        retryConfidentRejects: boolean;
+    supplied_identity: Record<string, never>;
+    summary_confirm: {
+        /** Offer « Reprendre » (re-open the identity source). */
+        retake: boolean;
     };
-    /** Device cooldown after repeated rejections (at most 5 tiers; `[]` = off). */
-    cooldown?: {
-        tiers: Array<{
-            rejectedSessions: number;
-            windowHours: number;
-            waitMinutes: number;
-        }>;
+    liveness: {
+        /** `off`, selfie ICAO `alert` / `reject`, or `id_document` (ID-photo portrait, always rejects). */
+        icao: "off" | "alert" | "reject" | "id_document";
+        attempts?: number;
     };
-    /** Device tamper and velocity actions. */
-    device?: {
-        tamper: "block" | "signal";
-        velocity: {
-            maxIdentitiesPerDevice: number;
-            windowDays: number;
-            action: "signal" | "block";
-        };
+    face_match: {
+        reference: "auto" | "document" | "registry";
+        attempts?: number;
+    };
+    aml_screening: {
+        lists: Array<"sanctions" | "pep" | "adverse_media">;
+        onHit: "review" | "fail";
+    };
+    face_dedup: {
+        scope: "app" | "org";
+        onDuplicate: "review" | "fail";
     };
 }
 /**
@@ -237,37 +417,86 @@ type DeepPartial<T> = T extends readonly unknown[] ? T : T extends object ? {
     [K in keyof T]?: DeepPartial<T[K]>;
 } : T;
 /**
- * A per-session override of the app's eKYC profile
- * ({@link CreateSessionInput.profile}): any subset of
- * {@link EkycProfileSettings}, at any depth (every field optional). Objects
- * are merged into the app's profile; arrays and scalar values replace it.
+ * A per-session override of the flow ({@link CreateSessionInput.overrides}).
  *
- * The API validates the merged result like a profile save. Unknown keys are
- * rejected server-side (`400`, also for keys this SDK version does not type).
- * An override may only make the profile stricter unless the app allows
- * widening (`overrides.allowWidening`); otherwise a widening change answers
- * `403 override_widens_profile`. The changed paths are reported on
- * {@link Session.overriddenFields}.
+ * - `settings`: any subset of {@link FlowOverridableSettings}, at any depth.
+ * - `services`: keyed by service (applied to every node of that service): any
+ *   subset of its {@link FlowServiceSettings}, or `'off'` to remove it from
+ *   the flow. A service the flow does not use is ignored.
+ *
+ * Objects merge into the flow; arrays and scalar values replace. Unknown keys
+ * and invalid results answer `400 override_invalid`. An override may only
+ * make the flow stricter unless the flow allows widening; turning a service
+ * `'off'` always widens. A widening change answers `403 override_widens_flow`.
+ * The changed paths are reported on {@link Session.overriddenFields}.
+ *
+ * @example
+ * ```ts
+ * await sekyro.sessions.create({
+ *   flow: "foreigners",
+ *   overrides: {
+ *     settings: { eligibility: { minAge: 21 } },
+ *     services: { liveness: { attempts: 2 } },
+ *   },
+ * });
+ * ```
  * @public
  */
-type EkycProfileOverride = DeepPartial<EkycProfileSettings>;
+interface FlowOverrides {
+    settings?: DeepPartial<FlowOverridableSettings>;
+    services?: {
+        [S in ServiceId]?: DeepPartial<FlowServiceSettings[S]> | "off";
+    };
+}
+/**
+ * The flow version a session runs: its `flw_` id, its slug and the published
+ * version pinned at create.
+ * @public
+ */
+interface SessionFlowRef {
+    id: string;
+    slug: string;
+    version: number;
+}
 /**
- * Input of {@link SessionsApi.create}. There is no recipe field: the API key
- * belongs to an app, and that app's eKYC profile decides the steps.
+ * One flow of your app, from {@link Sekyro.listFlows}. Published flows only;
+ * pass `slug` or `id` as {@link CreateSessionInput.flow}.
+ * @public
+ */
+interface FlowSummary {
+    /** `flw_` id. */
+    id: string;
+    slug: string;
+    name: string;
+    /** The published version a new session runs. */
+    version: number;
+    /** The flow a session runs when you send no `flow`. */
+    isDefault: boolean;
+}
+/**
+ * Input of {@link SessionsApi.create}. The API key belongs to an app; the
+ * app's flow (its default flow, or the one named in `flow`) decides the steps.
  * @public
  */
 interface CreateSessionInput {
+    /**
+     * The app's flow to run: its slug (e.g. `foreigners`) or `flw_` id, as
+     * {@link Sekyro.listFlows} lists them. Absent = the app's default flow.
+     * Errors: `404 flow_not_found` (no such flow in the key's app),
+     * `409 flow_not_published`, `409 flow_archived`.
+     */
+    flow?: string;
     /** Pins the hosted-flow language. Omit to let the person's device decide. */
     locale?: Locale;
     /**
-     * Pre-choose the identity method when the app's document step is optional
-     * (the hosted method screen is then skipped). Ignored for other apps.
+     * Pre-choose the identity method when the flow offers a choice of identity
+     * method (the hosted choice screen is then skipped). Ignored otherwise.
      */
     identityMethod?: IdentityMethod;
     /**
-     * Session lifetime in minutes. Must fall within the app profile's link
-     * range, otherwise the API answers `400 ttl_out_of_policy`. Omit to use the
-     * profile's default.
+     * Session lifetime in minutes. Must fall within the flow's link range,
+     * otherwise the API answers `400 ttl_out_of_policy`. Omit to use the
+     * flow's default.
      */
     ttlMinutes?: number;
     /** Also send the hosted link to the person by SMS or WhatsApp. */
@@ -279,12 +508,13 @@ interface CreateSessionInput {
      */
     subject?: SessionSubjectInput;
     /**
-     * Override the app's eKYC profile for this session only (profile v2): a
-     * deep-partial {@link EkycProfileOverride}. Unknown keys are rejected
-     * server-side; a change that makes the profile less strict answers
-     * `403 override_widens_profile` unless the app allows widening.
+     * Override the flow for this session only ({@link FlowOverrides}): its
+     * general settings and per-service settings, or turn a service `'off'`.
+     * `400 override_invalid` for an unknown key or an invalid result;
+     * `403 override_widens_flow` for a change that makes the flow less strict
+     * when the flow does not allow widening.
      */
-    profile?: EkycProfileOverride;
+    overrides?: FlowOverrides;
     /**
      * Step inputs consumed server-side. The known anchors are typed (all
      * strings — an `nni` is a 10-digit string, never a number); further keys
@@ -296,11 +526,59 @@ interface CreateSessionInput {
         nni?: string;
         /** E.164 phone number, e.g. `+22236123456`. */
         phone?: string;
+        /** Email address for the email OTP step (`emailSource` `prefilled` / `prefilled_or_entered`). */
+        email?: string;
         fullName?: string;
         /** ISO 8601 date (`YYYY-MM-DD`). */
         birthDate?: string;
+        /**
+         * Partner-supplied identity data (`supplied` mode only): the person's
+         * biographic record and photo as YOUR system holds them — for example
+         * from your own ANRPTS answer, converted with {@link registryFromAnrpts}.
+         * Sekyro AI stores it as data you vouch for, makes no registry call, and
+         * never receives or stores any registry key. `nni` must be set too and
+         * equal `suppliedIdentity.nni`. Refused unless Sekyro AI enabled the mode
+         * for the environment (`403 supplied_identity_not_entitled`); required in
+         * that mode when the app verifies identity (`422 supplied_identity_required`).
+         */
+        suppliedIdentity?: SuppliedIdentityRecord;
     } & Record<string, unknown>;
 }
+/**
+ * Partner-supplied identity data (`sessions.create` `input.suppliedIdentity`):
+ * the person's biographic record and photo, as your organization holds them.
+ * Sekyro AI treats it as identity data supplied by your organization, not as
+ * a registry lookup. Refusals at create: `400 supplied_identity_nni_mismatch`,
+ * `422 supplied_identity_stale` (`fetchedAt` older than 24 h),
+ * `422 supplied_identity_photo_unusable` (not a JPEG/PNG of at most 1 MB within the
+ * size bounds). In a `supplied` environment whose app verifies identity, a create
+ * without `input.suppliedIdentity` is `422 supplied_identity_required`. The face on
+ * the photo is checked after consent, at the face match (`no_face_reference`).
+ * @public
+ */
+interface SuppliedIdentityRecord {
+    /** 10-digit NNI, as a string. */
+    nni: string;
+    firstNameFr: string;
+    lastNameFr: string;
+    fatherNameFr?: string;
+    firstNameAr: string;
+    lastNameAr: string;
+    fatherNameAr?: string;
+    /** ISO 8601 date (`YYYY-MM-DD`). */
+    birthDate: string;
+    birthPlaceFr?: string;
+    birthPlaceAr?: string;
+    sex?: "M" | "F";
+    /** Nationality text as your source holds it (e.g. `Mauritanienne`). */
+    nationalities?: string[];
+    /** Base64 JPEG or PNG (at most 1 MB decoded). */
+    photo: string;
+    /** ISO 8601 date (`YYYY-MM-DD`) of the registry photo. */
+    photoDate?: string;
+    /** ISO 8601 date-time at which your system obtained this record. */
+    fetchedAt: string;
+}
 /** Per-request options. @public */
 interface RequestOptions {
     /**
@@ -321,6 +599,9 @@ interface CreatedSession {
     clientToken: string;
     /** Hosted verification link for this session. */
     hostedUrl: string;
+    /** The flow version the session runs (the default flow when you sent no `flow`). */
+    flow?: SessionFlowRef;
+    /** The checks on the session's path (checks of a lane not taken are omitted). */
     steps: SessionStep[];
     /** ISO 8601 — when the session (and its link) stop accepting input. */
     expiresAt: string;
@@ -382,6 +663,43 @@ interface SessionDevice {
     deviceKeys: string[];
     signals: SessionDeviceSignal[];
 }
+/**
+ * The national eID that verified the session's identity (the `eid_auth` check
+ * passed): the provider id (`{country}.{provider}`, e.g. `MR.houwiyeti`), its
+ * ISO 3166-1 alpha-2 country and when. A passed eID ends the session.
+ * @public
+ */
+interface EidResult {
+    provider: string;
+    country: string;
+    verifiedAt: string;
+}
+/**
+ * The full phone number and email address the person verified in a session
+ * (an OTP check that passed) — sent ONLY to you (the session view and your
+ * webhooks), never to the person's browser, and removed when the session's
+ * personal data is purged. You are the controller of these values. A
+ * prefilled value that was not verified is never listed.
+ * @public
+ */
+interface VerifiedContacts {
+    /** From a passed `phone_otp` check. */
+    phone?: {
+        /** E.164, e.g. `+22236123456`. */
+        number: string;
+        /** The channel the code was delivered on. */
+        channel: "whatsapp" | "sms";
+        /** ISO 8601. */
+        verifiedAt: string;
+    };
+    /** From a passed `email_otp` check. */
+    email?: {
+        /** The verified address (domain lowercased). */
+        address: string;
+        /** ISO 8601. */
+        verifiedAt: string;
+    };
+}
 /**
  * The whitelisted session view returned by {@link SessionsApi.get}. Never
  * contains the client token.
@@ -389,8 +707,11 @@ interface SessionDevice {
  */
 interface Session {
     id: string;
+    /** Sekyro flows: the flow version the session runs (absent on sessions created before flows). */
+    flow?: SessionFlowRef;
     status: SessionStatus;
     outcome: SessionOutcome | null;
+    /** The checks on the session's path (checks of a lane the person did not take are omitted). */
     steps: SessionStep[];
     /** ISO 8601. */
     expiresAt: string;
@@ -420,13 +741,34 @@ interface Session {
      * `failureReason: 'device_cooldown'`.
      */
     retryAfter?: string;
-    /** Dotted profile paths this session's {@link CreateSessionInput.profile} changed (e.g. `decisions.mode`). */
+    /**
+     * Dotted paths this session's {@link CreateSessionInput.overrides} changed
+     * (e.g. `settings.decisions.mode`, `services.liveness`).
+     */
     overriddenFields?: string[];
     /**
      * Risk signals recorded on the session (e.g. `device_velocity`,
-     * `timezone_mismatch`) — signals only, never a verdict by themselves.
+     * `timezone_mismatch`, `icao_non_compliant` when an `alert` ICAO policy flagged
+     * the selfie) — signals only, never a verdict by themselves.
      */
     riskSignals?: string[];
+    /**
+     * `true` for a returning-user session (created with
+     * {@link SessionSubjectInput.reuse}): liveness + face match against the
+     * subject's stored reference photo only.
+     */
+    returning?: true;
+    /** On a returning-user session: the subject (person) it re-verifies. */
+    reuseOf?: string;
+    /** The contacts verified in this session (passed OTP checks only); absent when none. */
+    verifiedContacts?: VerifiedContacts;
+    /** The national eID that verified this session (the `eid_auth` check passed); absent otherwise. */
+    eid?: EidResult;
+    /**
+     * ID mode (`portrait.purpose = id_document`) only: the ICAO portrait can be
+     * fetched with {@link SessionsApi.portrait}.
+     */
+    portraitAvailable?: boolean;
 }
 /**
  * `data` of the terminal / review-pending session lifecycle events
@@ -434,14 +776,17 @@ interface Session {
  * `session.expired` | `session.rejected`) — ids and enums only, no civil data,
  * scores or links. `outcome` and `steps` travel on `completed` / `failed`;
  * `review_pending` carries `steps` without an outcome; `expired` carries the
- * status alone.
+ * status and the session's refs (`flow`, subject ids, `overriddenFields`).
  * @public
  */
 interface SessionLifecycleEventData {
     sessionId: string;
     status: SessionStatus;
     outcome?: SessionOutcome | null;
-    steps?: Array<Pick<SessionStep, "checkType" | "state">>;
+    /** The checks on the session's path (checks of a lane the person did not take are omitted). */
+    steps?: Array<Pick<SessionStep, "checkType" | "state" | "nodeId" | "service">>;
+    /** Sekyro flows: the flow version the session runs (absent on sessions created before flows). */
+    flow?: SessionFlowRef;
     /** Machine-readable reason, when the transition has one. */
     reason?: string;
     /** End-user network context (no IP); on `completed` / `failed` when recorded. */
@@ -463,25 +808,140 @@ interface SessionLifecycleEventData {
      * different subject than `subjectId` — the subjects are never merged.
      */
     subjectConflict?: boolean;
+    /** `true` on a returning-user session (liveness + face match against the stored photo). */
+    returning?: true;
+    /** On a returning-user session: the subject (person) it re-verifies. */
+    reuseOf?: string;
     /**
      * On `session.failed` with `failureReason: 'device_cooldown'`: ISO time
      * from which the device may start a new verification.
      */
     retryAfter?: string;
-    /** Dotted profile paths the session's create-time override changed. */
+    /** Dotted paths the session's create-time {@link CreateSessionInput.overrides} changed. */
     overriddenFields?: string[];
+    /** On `completed` / `failed`: the contacts verified in this session (passed OTP checks only). */
+    verifiedContacts?: VerifiedContacts;
+    /** On `completed` / `failed`: the national eID that verified this session, when one did. */
+    eid?: EidResult;
+    /**
+     * ID mode only, on `completed` / `failed`: the ICAO portrait can be fetched
+     * with {@link SessionsApi.portrait} (the event never carries the image).
+     */
+    portraitAvailable?: boolean;
 }
 /**
- * `data` of `subject.updated` — a session linked to the subject reached a
- * terminal state. Ids and enums only.
+ * `data` of `subject.updated` — either a session linked to the subject reached
+ * a terminal state (`sessionId`, session `status`, `outcome`), or the subject
+ * was revoked (`status: 'revoked'`, no session). Ids and enums only.
  * @public
  */
 interface SubjectUpdatedEventData {
     subjectId: string;
+    /** The session that reached a terminal state; absent on a revocation. */
+    sessionId?: string;
+    status: SessionStatus | "revoked";
+    /** The session outcome; absent on a revocation. */
+    outcome?: SessionOutcome | null;
+}
+/**
+ * `data` of `subject.enrolled` — the subject's first reference photo was
+ * stored (it can now be used for returning-user sessions). Ids and enums only.
+ * @public
+ */
+interface SubjectEnrolledEventData {
+    subjectId: string;
+    /** The approved session the reference photo came from. */
     sessionId: string;
+    assurance: SubjectAssurance;
+}
+/**
+ * `data` of `subject.deleted`. A delete through the subjects API carries
+ * `subjectId`; a right-to-erasure request carries the tokenized `subjectRef`
+ * (with `orgId` / `env`) instead — never the national number.
+ * @public
+ */
+interface SubjectDeletedEventData {
+    subjectId?: string;
+    subjectRef?: string;
+    orgId?: string;
+    env?: SekyroEnvironment;
+}
+/** Subject lifecycle: a revoked subject cannot be reused. @public */
+type SubjectStatus = "active" | "revoked";
+/**
+ * How strongly a subject's identity was established: the reference photo
+ * came from the national registry, the document's chip (`chip_biometric`, a
+ * passed chip read plus a face match) or the document, and a face match passed
+ * (`*_biometric`) or the session had no face match (`*_only`). `supplied_*`:
+ * partner-supplied identity data (`input.suppliedIdentity`), with
+ * (`supplied_biometric`) or without (`supplied_only`) a face match against its photo.
+ * @public
+ */
+type SubjectAssurance = "registry_biometric" | "chip_biometric" | "document_biometric" | "registry_only" | "document_only" | "supplied_biometric" | "supplied_only";
+/**
+ * Origin of a subject's stored reference photo, best first (`chip`: the document chip's portrait;
+ * `org_supplied`: the photo of your partner-supplied identity data).
+ * @public
+ */
+type SubjectReferenceSource = "registry" | "doc_registry" | "chip" | "org_supplied" | "document";
+/** One session linked to a subject. @public */
+interface SubjectSession {
+    sessionId: string;
+    appId: string | null;
+    /** ISO 8601 — when the session was linked. */
+    at: string;
     status: SessionStatus;
     outcome: SessionOutcome | null;
 }
+/**
+ * A subject (the same person across your apps), as `GET /subjects/:id`
+ * returns it. Never contains photo keys or URLs.
+ * @public
+ */
+interface Subject {
+    id: string;
+    status: SubjectStatus;
+    /** ISO 8601 — present only when revoked. */
+    revokedAt?: string;
+    sessions: SubjectSession[];
+    externalRefs: string[];
+    /** ISO 8601. */
+    firstSeenAt: string;
+    /** ISO 8601. */
+    lastSeenAt: string;
+    /** ISO 8601, or `null` before the first approved session. */
+    lastPassedAt: string | null;
+    /** ISO 8601 of the last approved full or returning session, or `null`. */
+    lastVerifiedAt: string | null;
+    /** The stored reference photo's origin and date — `null` until one is stored. */
+    reference: {
+        source: SubjectReferenceSource;
+        capturedAt: string;
+    } | null;
+    assurance: SubjectAssurance | null;
+    /**
+     * A returning-user session can be created now: active, a reference photo is
+     * stored, and the last FULL verification (returning-user sessions do not
+     * reset it) is within the returning-user limit of your app's default flow
+     * (`settings.returning`: turned on, and `maxAgeMonths` when set).
+     */
+    returningReady: boolean;
+    /** The verified name / birth date of the latest approved session. */
+    display?: {
+        name?: string;
+        birthDate?: string;
+    };
+}
+/** Result of {@link SubjectsApi.delete}. @public */
+interface DeletedSubject {
+    id: string;
+    deleted: true;
+}
+/** Options of {@link SubjectsApi.revoke}. @public */
+interface RevokeSubjectInput {
+    /** Kept on the audit trail only (≤ 500 characters). Do not put personal data here. */
+    reason?: string;
+}
 /**
  * `data` of `subject.suspicious_activity` — a device already linked to
  * ANOTHER subject was used for a session of this subject. `count` is the
@@ -501,6 +961,12 @@ interface SessionStepCompletedEventData {
     sessionId: string;
     checkType: CheckType;
     state: CheckState;
+    /** Sekyro flows: the flow node of the passed check. */
+    nodeId?: string;
+    /** Sekyro flows: the service of that node. */
+    service?: ServiceId;
+    /** Sekyro flows: the flow version the session runs (absent on sessions created before flows). */
+    flow?: SessionFlowRef;
     /** The subject (person) the session is linked to, when known. */
     subjectId?: string;
     /** Your own id for the person, from `subject.externalRef` at create. */
@@ -510,6 +976,12 @@ interface SessionStepCompletedEventData {
      * different subject than `subjectId` — the subjects are never merged.
      */
     subjectConflict?: boolean;
+    /** `true` on a returning-user session (liveness + face match against the stored photo). */
+    returning?: true;
+    /** On a returning-user session: the subject (person) it re-verifies. */
+    reuseOf?: string;
+    /** When the passed check is `phone_otp` / `email_otp`: that one verified contact. */
+    verifiedContacts?: VerifiedContacts;
 }
 /**
  * `data` of `session.review_decided` — a human (or the review-timeout sweep)
@@ -522,6 +994,8 @@ interface SessionReviewDecidedEventData {
     sessionId: string;
     outcome: "pass" | "fail";
     reason: string;
+    /** Sekyro flows: the flow version the session runs (absent on sessions created before flows). */
+    flow?: SessionFlowRef;
     /** The subject (person) the session is linked to, when known. */
     subjectId?: string;
     /** Your own id for the person, from `subject.externalRef` at create. */
@@ -531,6 +1005,12 @@ interface SessionReviewDecidedEventData {
      * different subject than `subjectId` — the subjects are never merged.
      */
     subjectConflict?: boolean;
+    /** `true` on a returning-user session (liveness + face match against the stored photo). */
+    returning?: true;
+    /** On a returning-user session: the subject (person) it re-verifies. */
+    reuseOf?: string;
+    /** ID mode only: the ICAO portrait can be fetched with {@link SessionsApi.portrait}. */
+    portraitAvailable?: boolean;
 }
 /**
  * Event type → the shape of its `data`. Session events are typed; the
@@ -547,10 +1027,10 @@ interface WebhookEventDataMap {
     "session.rejected": SessionLifecycleEventData;
     "session.expired": SessionLifecycleEventData;
     "session.failed": SessionLifecycleEventData;
-    "subject.enrolled": Record<string, unknown>;
+    "subject.enrolled": SubjectEnrolledEventData;
     "subject.updated": SubjectUpdatedEventData;
     "subject.suspicious_activity": SubjectSuspiciousActivityEventData;
-    "subject.deleted": Record<string, unknown>;
+    "subject.deleted": SubjectDeletedEventData;
     "aml.match_flagged": Record<string, unknown>;
     "payment.received": Record<string, unknown>;
     "invoice.generated": Record<string, unknown>;
@@ -638,7 +1118,7 @@ declare class SessionsApi {
      * surface on purpose (only its bound `call` crosses this boundary).
      * @internal
      */
-    constructor(call: <T>(method: "GET" | "POST", path: string, body?: unknown, idempotencyKey?: string) => Promise<T>);
+    constructor(call: <T>(method: "GET" | "POST" | "DELETE", path: string, body?: unknown, idempotencyKey?: string) => Promise<T>);
     /**
      * `POST /sessions`. Returns the one-time `clientToken` — hand it to the
      * browser, never persist it. Pass an `idempotencyKey` so a retried call
@@ -650,10 +1130,54 @@ declare class SessionsApi {
      * optional-document session on the person's behalf (the hosted method
      * screen is then skipped). `409 method_locked` once the choice can no
      * longer change; `409 session_not_active` on a finished or expired session.
+     * On a flow session: `409 choice_not_found` (the flow has no identity-method
+     * choice), `409 choice_locked`, `409 choice_option_unavailable` (see
+     * {@link isFlowError}).
      */
     selectMethod(id: string, method: IdentityMethod): Promise<Session>;
     /** `GET /sessions/:id` — the whitelisted view (no client token). */
     get(id: string): Promise<Session>;
+    /**
+     * `GET /sessions/:id/portrait?format=url` — ID mode: a 5-minute presigned
+     * link to the 480×640 ICAO portrait (JPEG). Needs the `portrait:read` scope
+     * (keys minted from the dashboard carry it). `404 portrait_not_available`
+     * until the session's `portrait_icao` check has passed (`portraitAvailable`).
+     */
+    portrait(id: string): Promise<SessionPortraitLink>;
+}
+/**
+ * `sekyro.subjects` — read and manage subjects (the same person across your
+ * apps). Reads need the `subjects:read` scope, `revoke` / `delete` the
+ * `subjects:write` scope (keys minted from the dashboard carry both; an older
+ * key answers `403 insufficient_scope`). A foreign or unknown id answers
+ * `404 subject_not_found`.
+ *
+ * Type-only export, like {@link SessionsApi}: obtained through
+ * {@link Sekyro.subjects}.
+ * @public
+ */
+declare class SubjectsApi {
+    private readonly call;
+    /** @internal */
+    constructor(call: <T>(method: "GET" | "POST" | "DELETE", path: string, body?: unknown, idempotencyKey?: string) => Promise<T>);
+    /** `GET /subjects/:id` — the subject, its sessions and its returning-user readiness. */
+    get(id: string): Promise<Subject>;
+    /** `GET /subjects?externalRef=…` — the subjects carrying your own id (newest first, at most 50). */
+    list(query: {
+        externalRef: string;
+    }): Promise<Subject[]>;
+    /**
+     * `POST /subjects/:id/revoke` — the subject can no longer be used for
+     * returning-user sessions. Idempotent: revoking again returns the same view.
+     * Emits `subject.updated` with `status: 'revoked'`.
+     */
+    revoke(id: string, input?: RevokeSubjectInput, opts?: RequestOptions): Promise<Subject>;
+    /**
+     * `DELETE /subjects/:id` — deletes the subject's stored photos, face
+     * templates and identifiers, and unlinks its sessions. Emits
+     * `subject.deleted`. Cannot be undone; a second call answers `404`.
+     */
+    delete(id: string): Promise<DeletedSubject>;
 }
 /**
  * Sekyro AI partner API client. Server-side only: it carries your API key.
@@ -670,8 +1194,17 @@ declare class SessionsApi {
  * @public
  */
 declare class Sekyro {
+    #private;
     readonly sessions: SessionsApi;
+    readonly subjects: SubjectsApi;
     constructor(opts: SekyroOptions);
+    /**
+     * `GET /flows` — the published flows of the API key's app (default flow
+     * first, then by name). Pass a flow's `slug` or `id` as
+     * {@link CreateSessionInput.flow}. Needs the `sessions:create` scope; a key
+     * not bound to an app answers `401 key_not_bound`.
+     */
+    listFlows(): Promise<FlowSummary[]>;
 }
 
 /** Why {@link verifyWebhook} rejected a delivery. @public */
@@ -687,7 +1220,7 @@ declare class SekyroWebhookError extends Error {
     constructor(code: SekyroWebhookErrorCode, message?: string);
 }
 /** Why the {@link Sekyro} constructor rejected its options. @public */
-type SekyroConfigErrorCode = "missing_api_key" | "invalid_base_url";
+type SekyroConfigErrorCode = "missing_api_key" | "invalid_base_url" | "invalid_registry_record";
 /**
  * Thrown synchronously by `new Sekyro(...)` for an unusable configuration —
  * before any request is made. Extends `TypeError` so existing
@@ -699,15 +1232,104 @@ declare class SekyroConfigError extends TypeError {
     readonly code: SekyroConfigErrorCode;
     constructor(code: SekyroConfigErrorCode, message?: string);
 }
+/**
+ * The flow codes of the partner API (Sekyro flows). Each carries
+ * {@link SekyroApiError.details} (see {@link SekyroFlowErrorDetailsMap} and
+ * {@link isFlowError}). On `sessions.create`:
+ *  - `flow_not_found` (404): no flow with this slug or `flw_` id in the key's app;
+ *  - `flow_not_published` (409): the flow has no published version yet;
+ *  - `flow_archived` (409): the flow is archived;
+ *  - `override_invalid` (400): an unknown key or value in `overrides`, or a
+ *    result that is not a valid flow;
+ *  - `override_widens_flow` (403): the override makes the flow less strict
+ *    (e.g. a service turned `'off'`) and the flow does not allow widening;
+ *  - `reuse_disabled` (409): `subject.reuse` on a flow whose returning-user
+ *    sessions are turned off.
+ *
+ * On `sessions.selectMethod` (a flow session's identity-method choice):
+ * `choice_not_found` (409: the session's flow has no identity-method choice),
+ * `choice_locked` (409: it can no longer change) and
+ * `choice_option_unavailable` (409: that method is not offered).
+ * @public
+ */
+type SekyroFlowErrorCode = "flow_not_found" | "flow_not_published" | "flow_archived" | "override_invalid" | "override_widens_flow" | "reuse_disabled" | "choice_not_found" | "choice_locked" | "choice_option_unavailable";
+/**
+ * One machine-readable issue of a flow error. Never carries a value you sent.
+ * @public
+ */
+interface FlowErrorIssue {
+    /**
+     * A flow validation code (e.g. `face_match_needs_liveness`), `schema_invalid`,
+     * `schema_unknown_field`, `field_widens_flow`, or the error's own code.
+     */
+    code: string;
+    /** A short plain English sentence. */
+    message: string;
+    /** The field of your request body, e.g. `overrides.services.liveness.attempts`, `flow`, `subject.reuse`. */
+    path?: string;
+    /** A node of your app's flow. */
+    nodeId?: string;
+    /** The service of that node (or of the `overrides.services` key). */
+    service?: ServiceId;
+    /** `override_widens_flow`: the widened field, e.g. `settings.eligibility.minAge`, `services.nfc`. */
+    field?: string;
+}
+/** `details` common to every flow error: at least one issue. @public */
+interface FlowErrorDetails {
+    issues: FlowErrorIssue[];
+}
+/** `details` of `override_widens_flow`: the widened fields, plus one `field_widens_flow` issue each. @public */
+interface FlowWidensErrorDetails extends FlowErrorDetails {
+    fields: string[];
+}
+/** `details` of `flow_not_published`, `flow_archived` and `reuse_disabled`: the flow concerned. @public */
+interface FlowRefErrorDetails extends FlowErrorDetails {
+    flow: {
+        id: string;
+        slug: string;
+    };
+}
+/**
+ * {@link SekyroFlowErrorCode} → the shape of its {@link SekyroApiError.details}.
+ * @public
+ */
+interface SekyroFlowErrorDetailsMap {
+    flow_not_found: FlowErrorDetails;
+    flow_not_published: FlowRefErrorDetails;
+    flow_archived: FlowRefErrorDetails;
+    override_invalid: FlowErrorDetails;
+    override_widens_flow: FlowWidensErrorDetails;
+    reuse_disabled: FlowRefErrorDetails;
+    choice_not_found: FlowErrorDetails;
+    choice_locked: FlowErrorDetails;
+    choice_option_unavailable: FlowErrorDetails;
+}
+/**
+ * A {@link SekyroApiError} narrowed by {@link isFlowError}: `code` is a flow
+ * code and `details` has that code's shape.
+ * @public
+ */
+type SekyroFlowError<C extends SekyroFlowErrorCode = SekyroFlowErrorCode> = C extends SekyroFlowErrorCode ? SekyroApiError & {
+    readonly code: C;
+    readonly details: SekyroFlowErrorDetailsMap[C];
+} : never;
+/**
+ * {@link SekyroApiError.code}: an SDK code, a documented flow code, or any
+ * other API code (the union stays open so a new API code never breaks a build).
+ * @public
+ */
+type SekyroApiErrorCode = SekyroClientErrorCode | SekyroFlowErrorCode | (string & {});
 /** Constructor input of {@link SekyroApiError}. @public */
 interface SekyroApiErrorInit {
     /** HTTP status; `0` when no response was received (network / timeout). */
     status: number;
     /** API error code, or `network` | `timeout` | `http_error` | `malformed_response`. */
-    code: string;
+    code: SekyroApiErrorCode;
     message: string;
     /** The API's `request_id`, when the response carried one. */
     requestId?: string;
+    /** The API's `error.details`, when the response carried them (the flow codes: {@link SekyroFlowErrorDetailsMap}). */
+    details?: unknown;
     /** Underlying error (network failures, abort reasons, JSON parse errors). */
     cause?: unknown;
 }
@@ -725,11 +1347,90 @@ type SekyroClientErrorCode = "network" | "timeout" | "http_error" | "malformed_r
 declare class SekyroApiError extends Error {
     readonly name = "SekyroApiError";
     readonly status: number;
-    readonly code: string;
+    readonly code: SekyroApiErrorCode;
     readonly requestId: string | undefined;
+    /**
+     * The API's `error.details`, when the response carried them; `undefined`
+     * otherwise. Untyped here: narrow with {@link isFlowError} to read a flow
+     * code's documented shape ({@link SekyroFlowErrorDetailsMap}).
+     */
+    readonly details: unknown;
     readonly retryable: boolean;
     constructor(init: SekyroApiErrorInit);
 }
+/**
+ * Narrow an error to a flow error, optionally to given codes: `true` only for
+ * a {@link SekyroApiError} with a flow code whose `details` have that code's
+ * documented shape, so `err.details` is typed after the check. An error whose
+ * `details` are missing or unexpected is not narrowed (read `err.code`).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await sekyro.sessions.create({ flow, overrides });
+ * } catch (err) {
+ *   if (isFlowError(err, "override_widens_flow")) err.details.fields; // string[]
+ *   else if (isFlowError(err)) err.details.issues.map((i) => i.path);
+ * }
+ * ```
+ * @public
+ */
+declare function isFlowError<C extends SekyroFlowErrorCode = SekyroFlowErrorCode>(err: unknown, ...codes: C[]): err is SekyroFlowError<C>;
+
+/**
+ * The raw ANRPTS `getPersonne` answer your server received with your own
+ * access: `{ personne, photo }`, where `photo` is a base64 JPEG (optionally
+ * data-URL prefixed). Only the fields the mapping reads are typed.
+ * @public
+ */
+interface AnrptsPersonneResponse {
+    personne?: {
+        nni?: string | undefined;
+        prenomFr?: string | undefined;
+        patronymeFr?: string | undefined;
+        perePrenomFr?: string | undefined;
+        prenomAr?: string | undefined;
+        patronymeAr?: string | undefined;
+        perePrenomAr?: string | undefined;
+        /** ISO date or date-time (`1990-01-01T00:00:00.000Z`), or `DD/MM/YYYY`. */
+        dateNaissance?: string | undefined;
+        lieuNaissanceFr?: string | undefined;
+        lieuNaissanceAr?: string | undefined;
+        sexeCode?: string | undefined;
+        nationalities?: string[] | undefined;
+        [key: string]: unknown;
+    };
+    photo?: string | undefined;
+    datePhoto?: string | undefined;
+    [key: string]: unknown;
+}
+/** Options of {@link registryFromAnrpts}. @public */
+interface RegistryFromAnrptsOptions {
+    /**
+     * When YOUR system received this ANRPTS answer (not "now" when you map a cached
+     * answer). Required: records older than 24 h are refused at session create.
+     */
+    fetchedAt: Date | string;
+}
+/**
+ * Convert an ANRPTS `getPersonne` answer that YOUR server already received,
+ * with your own access, into the `input.suppliedIdentity` record of
+ * `sessions.create` (partner-supplied identity data). A pure, local mapping:
+ * it makes no network call, and Sekyro AI never sees, receives or stores any
+ * ANRPTS key — only the record and photo you pass.
+ *
+ * ```ts
+ * const anrpts = await myAnrptsClient.getPersonne(nni); // your call, your key
+ * const suppliedIdentity = registryFromAnrpts(anrpts, { fetchedAt: receivedAt });
+ * await sekyro.sessions.create({ input: { nni, suppliedIdentity } });
+ * ```
+ *
+ * Throws {@link SekyroConfigError} (`invalid_registry_record`) when a required
+ * field (NNI, French and Arabic first and last names, birth date, photo) is
+ * missing. The message names the field, never its value.
+ * @public
+ */
+declare function registryFromAnrpts(response: AnrptsPersonneResponse, options: RegistryFromAnrptsOptions): SuppliedIdentityRecord;
 
 /**
  * The HTTP header carrying the webhook signature:
@@ -787,4 +1488,4 @@ interface VerifyWebhookOptions {
  */
 declare function verifyWebhook(rawBody: string, header: string | null | undefined, secret: string, opts?: VerifyWebhookOptions): WebhookEnvelope;
 
-export { type CheckState, type CheckType, type CreateSessionInput, type CreatedSession, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type DecisionReason, type DeepPartial, type DeliverOptions, type EkycProfileOverride, type EkycProfileSettings, type EligibilityReason, type FetchLike, type IdentityMethod, LEGACY_SIGNATURE_HEADER, type Locale, type MatchReason, type PolicyFailureReason, type ProfileDocumentType, type RequestOptions, SEKYRO_SIGNATURE_HEADER, Sekyro, SekyroApiError, type SekyroApiErrorInit, type SekyroClientErrorCode, SekyroConfigError, type SekyroConfigErrorCode, type SekyroEnvironment, type SekyroOptions, SekyroWebhookError, type SekyroWebhookErrorCode, type Session, type SessionDevice, type SessionDeviceSignal, type SessionEventData, type SessionFailureReason, type SessionLifecycleEventData, type SessionNetwork, type SessionNetworkEvent, type SessionOutcome, type SessionReviewDecidedEventData, type SessionStatus, type SessionStep, type SessionStepCompletedEventData, type SessionSubjectInput, SessionsApi, type SubjectSuspiciousActivityEventData, type SubjectUpdatedEventData, type VerifyWebhookOptions, type WebhookEnvelope, type WebhookEnvelopeOf, type WebhookEventDataMap, type WebhookEventType, signatureFromHeaders, verifyWebhook };
+export { type AnrptsPersonneResponse, type CheckState, type CheckType, type CreateSessionInput, type CreatedSession, DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, type DecisionReason, type DeepPartial, type DeletedSubject, type DeliverOptions, type DocumentSubstitutionSettings, type EidResult, type EligibilityReason, type FetchLike, type FlowErrorDetails, type FlowErrorIssue, type FlowOverridableSettings, type FlowOverrides, type FlowRefErrorDetails, type FlowServiceSettings, type FlowSummary, type FlowWidensErrorDetails, type IdentityMethod, LEGACY_SIGNATURE_HEADER, type Locale, type MatchReason, type PolicyFailureReason, type PortraitReportEntry, type ProbeBindingReason, type ProbeQuality, type ProfileDocumentType, type RegistryFromAnrptsOptions, type RequestOptions, type RevokeSubjectInput, SEKYRO_SIGNATURE_HEADER, Sekyro, SekyroApiError, type SekyroApiErrorCode, type SekyroApiErrorInit, type SekyroClientErrorCode, SekyroConfigError, type SekyroConfigErrorCode, type SekyroEnvironment, type SekyroFlowError, type SekyroFlowErrorCode, type SekyroFlowErrorDetailsMap, type SekyroOptions, SekyroWebhookError, type SekyroWebhookErrorCode, type ServiceId, type Session, type SessionDevice, type SessionDeviceSignal, type SessionEventData, type SessionFailureReason, type SessionFlowRef, type SessionLifecycleEventData, type SessionNetwork, type SessionNetworkEvent, type SessionOutcome, type SessionPortraitLink, type SessionReviewDecidedEventData, type SessionStatus, type SessionStep, type SessionStepCompletedEventData, type SessionSubjectInput, SessionsApi, type Subject, type SubjectAssurance, type SubjectDeletedEventData, type SubjectEnrolledEventData, type SubjectReferenceSource, type SubjectReuseTarget, type SubjectSession, type SubjectStatus, type SubjectSuspiciousActivityEventData, type SubjectUpdatedEventData, SubjectsApi, type SuppliedIdentityRecord, type VerifiedContacts, type VerifyWebhookOptions, type WebhookEnvelope, type WebhookEnvelopeOf, type WebhookEventDataMap, type WebhookEventType, isFlowError, registryFromAnrpts, signatureFromHeaders, verifyWebhook };