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

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 */
@@ -97,6 +107,57 @@ interface SessionStep {
     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,9 +195,36 @@ 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 app's `reuse.maxAgeMonths`) and
+     * `400` / `409 reuse_target_ambiguous`.
+     */
+    reuse?: SubjectReuseTarget;
 }
-/** A document type the backend reads (kyc-docs-v2 vocabulary). @public */
-type ProfileDocumentType = "carte_identite" | "passport";
+/**
+ * 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
+ */
+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 settings of an app's eKYC profile that a session may override — a
  * mirror of the backend profile (schema version 2) without `schemaVersion`,
@@ -146,10 +234,32 @@ type ProfileDocumentType = "carte_identite" | "passport";
  * @public
  */
 interface EkycProfileSettings {
-    /** Phone OTP step: off, or on with where the number comes from. */
+    /**
+     * Phone OTP step: off, or on with where the number comes from. The person
+     * chooses WhatsApp or SMS from the channels left after the org's settings
+     * and `channels`.
+     */
     phone: "off" | {
+        /** 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). A channel the org turned off answers
+         * `400 phone_channels_disabled_for_org`; an empty or duplicated list
+         * `400 phone_channels_invalid`.
+         */
+        channels?: Array<"whatsapp" | "sms">;
+        /**
+         * Which countries codes may be sent to: the profile's allowed
+         * `locations` (default), `any`, or a list of ISO 3166-1 alpha-2 codes.
+         * Invalid values answer `400 phone_destinations_invalid`.
+         */
+        destinations?: "locations" | "any" | {
+            countries: string[];
+        };
     };
+    /** Email OTP step (absent = off): a one-time code sent to the person's email address. */
+    email?: "off" | ProfileEmail;
     document: {
         mode: "off" | "optional" | "mandatory";
         /** Accepted document types: `'*'` (all) or a list, optionally per issuing country. */
@@ -185,6 +295,8 @@ interface EkycProfileSettings {
     /** Per-step attempt limits. */
     attempts?: {
         phone: number;
+        /** Email OTP attempts (1–5); absent = the platform default. */
+        email?: number;
         document: number;
         registry: number;
         liveness: number;
@@ -227,6 +339,32 @@ interface EkycProfileSettings {
             action: "signal" | "block";
         };
     };
+    /**
+     * The live photo. `purpose: "id_document"` also takes an ICAO 480×640 portrait you
+     * download for printing on an ID document. `icao` makes a verification selfie meet
+     * the ICAO photo rules: `"reject"` asks the person to retake a non-compliant photo
+     * (after the last attempt the session fails, or goes to review in review mode);
+     * `"alert"` lets the person continue and adds the risk signal `icao_non_compliant`.
+     * Both need liveness on; `"alert"` with `"id_document"` answers
+     * `400 portrait_icao_policy_id_document`. Absent = a verification selfie, no ICAO check.
+     */
+    portrait?: {
+        purpose?: "verification" | "id_document";
+        icao?: {
+            policy: "alert" | "reject";
+        };
+    };
+}
+/**
+ * The email OTP step of a profile. When the email check is not available on
+ * the platform yet, saving it answers `400 email_otp_not_available`.
+ * @public
+ */
+interface ProfileEmail {
+    /** 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";
 }
 /**
  * `T` with every property optional, recursively. Arrays are replaced as a
@@ -296,11 +434,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 {
     /**
@@ -382,6 +568,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.
@@ -424,9 +647,27 @@ interface Session {
     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
@@ -463,6 +704,10 @@ 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.
@@ -470,18 +715,129 @@ interface SessionLifecycleEventData {
     retryAfter?: string;
     /** Dotted profile paths the session's create-time override 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 your app's
+     * `reuse.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
@@ -510,6 +866,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)
@@ -531,6 +893,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 +915,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 +1006,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
@@ -654,6 +1022,47 @@ declare class SessionsApi {
     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.
@@ -671,6 +1080,7 @@ declare class SessionsApi {
  */
 declare class Sekyro {
     readonly sessions: SessionsApi;
+    readonly subjects: SubjectsApi;
     constructor(opts: SekyroOptions);
 }
 
@@ -687,7 +1097,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
@@ -731,6 +1141,61 @@ declare class SekyroApiError extends Error {
     constructor(init: SekyroApiErrorInit);
 }
 
+/**
+ * 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:
  * `t=<unix seconds>,v1=<hex>[,v1=<hex>]`.
@@ -787,4 +1252,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 EidResult, type EkycProfileOverride, type EkycProfileSettings, type EligibilityReason, type FetchLike, type IdentityMethod, LEGACY_SIGNATURE_HEADER, type Locale, type MatchReason, type PolicyFailureReason, type PortraitReportEntry, type ProbeBindingReason, type ProbeQuality, type ProfileDocumentType, type ProfileEmail, type RegistryFromAnrptsOptions, type RequestOptions, type RevokeSubjectInput, 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 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, registryFromAnrpts, signatureFromHeaders, verifyWebhook };