@smileid/usesmileid-nodejs 12.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Smile Identity Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,335 @@
+# @smileid/usesmileid-nodejs
+
+![npm version](https://img.shields.io/badge/npm-unpublished-lightgrey)
+![CI status](https://img.shields.io/badge/CI-pending-lightgrey)
+![license](https://img.shields.io/badge/license-MIT-blue)
+
+Official Smile ID server-side SDK for JavaScript/TypeScript — V3 APIs.
+
+This project is under active development and is not yet published to npm. The package name and API surface may change before the first release.
+
+## Requirements
+
+Node.js 18 or later. The SDK uses the built-in global `fetch` and has no runtime dependencies. Development and CI use the version pinned in `.nvmrc`.
+
+## Install
+
+```sh
+npm install @smileid/usesmileid-nodejs
+```
+
+## Create a client
+
+Construct a client with your partner id and API key. The SDK handles authentication for you: it fetches an internal token, caches it until just before expiry, and refreshes it once on a 401. You never handle tokens yourself.
+
+```ts
+import { SmileID } from '@smileid/usesmileid-nodejs';
+
+const smile = new SmileID({
+  partnerId: '1234',
+  apiKey: process.env.SMILE_API_KEY!,
+  environment: 'sandbox', // the default
+  defaultCallbackUrl: 'https://app.example.com/smile/callback',
+});
+```
+
+Partner ids are displayed zero-padded (for example 002) but must be passed without leading zeros (2).
+
+### Environments and base URL
+
+The client targets the sandbox by default. Set `environment: 'production'` to go live. Only `sandbox` and `production` are accepted; anything else is rejected at construction.
+
+| Environment  | Base URL                            |
+| ------------ | ----------------------------------- |
+| `sandbox`    | `https://testapi.smileidentity.com` |
+| `production` | `https://api.smileidentity.com`     |
+
+Any other host needs an explicit `baseUrl`, which wins over `environment`:
+
+```ts
+const smile = new SmileID({
+  partnerId: '2',
+  apiKey: process.env.SMILE_API_KEY!,
+  baseUrl: process.env.SMILE_BASE_URL ?? 'https://your-environment.example.com',
+});
+```
+
+### HTTPS requirements
+
+The SDK talks to Smile ID over HTTPS only:
+
+- `baseUrl` must be an absolute `https://` URL with no query string or fragment. There is no option to allow plain HTTP.
+- `defaultCallbackUrl` and every per-request `callbackUrl` must be `https://` URLs. A non-HTTPS callback raises `ValidationError` before any request is sent.
+
+Both are checked at client construction; per-request callback URLs are checked again before each send.
+
+### Other options
+
+| Option               | Default    | Purpose                                                       |
+| -------------------- | ---------- | ------------------------------------------------------------- |
+| `defaultCallbackUrl` | unset      | Used when a call omits `callbackUrl`                          |
+| `timeout`            | 30000 ms   | Per-request total timeout                                     |
+| `maxRetries`         | 2          | Retries for idempotent operations only                        |
+| `fetch`              | global     | Injectable fetch implementation for testing or proxies        |
+
+## Shared inputs
+
+Every verification call takes a `consent` block and `userDetails`. Build consent with the `Consent.granted` helper. `userDetails` needs at least one of `email` or `phoneNumber` — the SDK checks this before sending.
+
+```ts
+import { Consent } from '@smileid/usesmileid-nodejs';
+
+const consent = Consent.granted({
+  grantedAt: new Date(),
+  noticeLanguage: 'EN',
+  noticePrivacyPolicyUrl: 'https://example.com/privacy',
+});
+
+const userDetails = {
+  givenNames: 'Amina Fatou',
+  lastName: 'Clearwater',
+  email: 'amina.clearwater@example.com',
+};
+```
+
+Non-production environments match test identities on given names, last name and email. An unrecognised identity resolves to `block`.
+
+Image inputs (`selfieImage`, `livenessImages`, `document`, `comparisonImage`) accept a file path, a `Buffer`, a `Blob`, or a readable stream. Wrap one in `{ data, filename, contentType }` to override the filename or content type.
+
+Every method takes an optional final `options` argument with `timeout`, `callbackUrl`, and `signal` (an `AbortSignal`).
+
+## Methods
+
+### Enhanced KYC
+
+```ts
+const accepted = await smile.enhancedKyc.verify({
+  country: 'NG',
+  idType: 'NIN',
+  idNumber: '12345678901',
+  userDetails,
+  consent,
+  userId: 'user_01h8x9y2z3a4b5c6d7e8f9g0h1',
+});
+accepted.jobId;      // "job_..."
+accepted.isAccepted; // true
+```
+
+### Document verification
+
+```ts
+const accepted = await smile.documents.verify({
+  country: 'NG',
+  selfieImage: './selfie.jpg',
+  livenessImages: ['./live1.jpg', './live2.jpg', './live3.jpg', './live4.jpg', './live5.jpg', './live6.jpg'],
+  document: './passport.jpg',
+  userDetails,
+  consent,
+});
+```
+
+### Enhanced document verification
+
+Same as document verification, but `idType` is required.
+
+```ts
+const accepted = await smile.documents.verifyEnhanced({
+  country: 'NG',
+  idType: 'PASSPORT',
+  selfieImage: './selfie.jpg',
+  livenessImages: ['./live1.jpg', './live2.jpg', './live3.jpg', './live4.jpg', './live5.jpg', './live6.jpg'],
+  document: './passport.jpg',
+  userDetails,
+  consent,
+});
+```
+
+### Biometric KYC
+
+```ts
+const accepted = await smile.biometricKyc.verify({
+  country: 'NG',
+  idType: 'NIN',
+  idNumber: '12345678901',
+  selfieImage: './selfie.jpg',
+  livenessImages: ['./live1.jpg', './live2.jpg', './live3.jpg', './live4.jpg', './live5.jpg', './live6.jpg'],
+  userDetails,
+  consent,
+});
+```
+
+### Biometric enrollment
+
+```ts
+const accepted = await smile.biometric.enroll({
+  selfieImage: './selfie.jpg',
+  livenessImages: ['./live1.jpg', './live2.jpg', './live3.jpg', './live4.jpg', './live5.jpg', './live6.jpg'],
+  userDetails,
+  consent,
+  userId: 'user_01h8x9y2z3a4b5c6d7e8f9g0h1',
+});
+```
+
+### Biometric authentication
+
+`userId` is required and must match an enrolled user. Images are required unless `useEnrolledImage` is true.
+
+```ts
+const accepted = await smile.biometric.authenticate({
+  userId: 'user_01h8x9y2z3a4b5c6d7e8f9g0h1',
+  selfieImage: './selfie.jpg',
+  livenessImages: ['./live1.jpg', './live2.jpg', './live3.jpg', './live4.jpg', './live5.jpg', './live6.jpg'],
+  userDetails,
+  consent,
+});
+```
+
+### Selfie comparison
+
+```ts
+const accepted = await smile.biometric.compare({
+  selfieImage: './selfie.jpg',
+  comparisonImage: './id-photo.jpg',
+  comparisonImageType: 'ID_PHOTO', // DOCUMENT | ID_PHOTO | PORTRAIT
+  userDetails,
+  consent,
+});
+```
+
+### Check a verification
+
+`retrieve` never throws on an unknown job: a 404 comes back as a `JobStatus` with `status: "not_found"` so polling can treat it as pending.
+
+`status` is `processing` while the job runs, `not_found` for an unknown job, and otherwise the decision itself: `clear`, `block`, `attention` or `error`. `message` is a human-readable note, "Job completed" on a finished job — the decision is never in the message.
+
+```ts
+const status = await smile.verifications.retrieve('job_01h8x9y2z3a4b5c6d7e8f9g0h1');
+status.status;       // e.g. "clear"
+status.isComplete;   // true on any decision, i.e. not processing and not not_found
+status.isProcessing; // true while running
+status.message;      // e.g. "Job completed"
+```
+
+### Wait for completion
+
+Polls while the job is `processing` (and, by default, while it is `not_found`), then returns the status carrying the decision. Throws `TimeoutError` when the deadline passes. Options: `interval` (default 2000 ms), `timeout` (default 60000 ms), and `treatNotFoundAsPending` (default true).
+
+```ts
+const status = await smile.verifications.waitUntilComplete('job_01h8x9y2z3a4b5c6d7e8f9g0h1', {
+  interval: 2000,
+  timeout: 60000,
+});
+```
+
+### Replay a callback
+
+Only completed verifications can be replayed; a replay of a job that is still processing throws `ConflictError`.
+
+```ts
+const accepted = await smile.verifications.replay('job_01h8x9y2z3a4b5c6d7e8f9g0h1', {
+  callbackUrl: 'https://app.example.com/smile/callback',
+});
+```
+
+### Report fraud
+
+`reason` is required when flagging fraud; `notes` is required when clearing it or when the reason is `OTHER`.
+
+```ts
+const accepted = await smile.users.reportFraud('user_01h8x9y2z3a4b5c6d7e8f9g0h1', {
+  isFraud: true,
+  reason: 'ACCOUNT_TAKEOVER',
+  reportedBy: 'trust@example.com',
+});
+```
+
+The `flagFraud` and `clearFraud` wrappers set `isFraud` for you:
+
+```ts
+await smile.users.flagFraud('user_01h8x9y2z3a4b5c6d7e8f9g0h1', {
+  reason: 'DOCUMENT_FORGERY',
+  reportedBy: 'trust@example.com',
+});
+
+await smile.users.clearFraud('user_01h8x9y2z3a4b5c6d7e8f9g0h1', {
+  notes: 'Investigated and cleared.',
+  reportedBy: 'trust@example.com',
+});
+```
+
+### Bank codes
+
+No authentication needed.
+
+```ts
+const { bankCodes } = await smile.services.bankCodes({ country: 'NG' });
+```
+
+### Supported ID types
+
+No authentication needed.
+
+```ts
+const { idTypes } = await smile.services.supportedIdTypes({ country: 'NG' });
+```
+
+### Supported documents
+
+No authentication needed.
+
+```ts
+const { validDocuments } = await smile.services.supportedDocuments({ countryCode: 'NG' });
+```
+
+### ID provider status
+
+```ts
+const status = await smile.services.idStatus({ country: 'NG', idType: 'NIN' });
+status.lastKnownStatus; // "online"
+```
+
+## Error handling
+
+Every failure throws a subclass of `SmileIDError`. Each error carries `statusCode`, `status`, `message`, `code` (services errors only), `requestId`, and `rawBody`.
+
+| Error                  | When                                                       |
+| ---------------------- | ---------------------------------------------------------- |
+| `InvalidRequestError`  | 400 or 415                                                 |
+| `ValidationError`      | Client-side validation, before any request is sent         |
+| `AuthenticationError`  | 401 after one token refresh has already been tried         |
+| `PaymentRequiredError` | 402, insufficient wallet balance                           |
+| `PermissionError`      | 403                                                        |
+| `NotFoundError`        | 404 (not thrown by `verifications.retrieve`)               |
+| `ConflictError`        | 409, e.g. replaying a job that is still processing         |
+| `PayloadTooLargeError` | 413                                                        |
+| `RateLimitError`       | 429                                                        |
+| `APIError`             | 5xx                                                        |
+| `ConnectionError`      | Network failure with no HTTP response                      |
+| `UnexpectedResponseError` | A 2xx response whose body is not a JSON object          |
+| `TimeoutError`         | `waitUntilComplete` deadline passed                        |
+
+```ts
+import { PaymentRequiredError, SmileIDError } from '@smileid/usesmileid-nodejs';
+
+try {
+  await smile.enhancedKyc.verify({ /* ... */ });
+} catch (err) {
+  if (err instanceof PaymentRequiredError) {
+    // top up the wallet
+  } else if (err instanceof SmileIDError) {
+    console.error(err.statusCode, err.message);
+  }
+}
+```
+
+### Retries
+
+The SDK retries idempotent operations only (status and services reads, plus the internal token fetch) on connection errors, 408, 429, and 5xx, honouring the `Retry-After` header. It never retries verification submissions, replay, or fraud reports, and never retries a 409 — those are yours to decide.
+
+## Telemetry
+
+Every request carries three headers identifying the SDK: `SmileID-Source-SDK: node`, `SmileID-Source-SDK-Version`, and a `User-Agent` with the runtime version. These are observability metadata only; they are never used for authentication and carry no personal data.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/client/auth.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Internal JWT token lifecycle (spec §2.3, §2A).
+ *
+ * Partners never see or pass a token. The manager fetches one from
+ * POST /v3/token, caches it until `exp − 60s`, and refreshes on demand. Token
+ * fetches are stampede-safe: concurrent callers share a single in-flight
+ * promise, so the token endpoint is hit once (JavaScript's single-threaded
+ * model makes the in-flight promise the mutex).
+ *
+ * The fetch itself goes through the transport's execute path, so it gets the
+ * same retry policy (the token POST is idempotent, spec §2.6) and the same
+ * typed-error mapping (network failures raise ConnectionError) as every other
+ * idempotent operation.
+ */
+import type { RequestPlan, TransportResult } from './transport.js';
+/** Executes a request plan; provided by the transport. */
+export type ExecuteFn = (plan: RequestPlan) => Promise<TransportResult>;
+/** Manages the internal JWT: fetch, cache, refresh, stampede-safe. */
+export declare class TokenManager {
+    private readonly partnerId;
+    private readonly apiKey;
+    private readonly execute;
+    private readonly now;
+    private cached;
+    private inflight;
+    constructor(partnerId: string, apiKey: string, execute: ExecuteFn, now?: () => number);
+    /** Return a valid cached token, fetching one if necessary. */
+    ensureToken(): Promise<string>;
+    /** Discard the cached token so the next call fetches a fresh one. */
+    invalidate(): void;
+    private fetchToken;
+}

package/dist/client/auth.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Internal JWT token lifecycle (spec §2.3, §2A).
+ *
+ * Partners never see or pass a token. The manager fetches one from
+ * POST /v3/token, caches it until `exp − 60s`, and refreshes on demand. Token
+ * fetches are stampede-safe: concurrent callers share a single in-flight
+ * promise, so the token endpoint is hit once (JavaScript's single-threaded
+ * model makes the in-flight promise the mutex).
+ *
+ * The fetch itself goes through the transport's execute path, so it gets the
+ * same retry policy (the token POST is idempotent, spec §2.6) and the same
+ * typed-error mapping (network failures raise ConnectionError) as every other
+ * idempotent operation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = void 0;
+const index_js_1 = require("../errors/index.js");
+const jwt_js_1 = require("../helpers/jwt.js");
+/** Skew subtracted from token expiry so a token is refreshed before it lapses. */
+const EXPIRY_SKEW_SECONDS = 60;
+/** Manages the internal JWT: fetch, cache, refresh, stampede-safe. */
+class TokenManager {
+    partnerId;
+    apiKey;
+    execute;
+    now;
+    cached = null;
+    inflight = null;
+    constructor(partnerId, apiKey, execute, now = () => Date.now()) {
+        this.partnerId = partnerId;
+        this.apiKey = apiKey;
+        this.execute = execute;
+        this.now = now;
+    }
+    /** Return a valid cached token, fetching one if necessary. */
+    async ensureToken() {
+        if (this.cached && this.now() < this.cached.expiresAt) {
+            return this.cached.jwt;
+        }
+        if (this.inflight) {
+            return this.inflight;
+        }
+        this.inflight = this.fetchToken().finally(() => {
+            this.inflight = null;
+        });
+        return this.inflight;
+    }
+    /** Discard the cached token so the next call fetches a fresh one. */
+    invalidate() {
+        this.cached = null;
+    }
+    async fetchToken() {
+        // The token endpoint documents lowercase header names; send them verbatim.
+        // No body is sent. The plan is unauthenticated (no SmileID-Token) and
+        // idempotent, so the transport retries transient failures (spec §2.6).
+        const result = await this.execute({
+            method: 'POST',
+            path: '/v3/token',
+            authenticated: false,
+            needsPartnerIdHeader: false,
+            idempotent: true,
+            headers: {
+                'smileid-partner-id': this.partnerId,
+                'smileid-api-key': this.apiKey,
+            },
+        });
+        const jwt = result.json?.token;
+        if (!jwt) {
+            throw (0, index_js_1.parseError)({
+                statusCode: result.statusCode,
+                rawBody: result.rawBody,
+                requestId: result.requestId,
+            });
+        }
+        const exp = (0, jwt_js_1.decodeJwtExp)(jwt);
+        // A decodable exp caches until exp − skew; an undecodable one refreshes next call.
+        const expiresAt = exp !== null ? (exp - EXPIRY_SKEW_SECONDS) * 1000 : this.now();
+        this.cached = { jwt, expiresAt };
+        return jwt;
+    }
+}
+exports.TokenManager = TokenManager;

package/dist/client/client.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The SmileID client and its resource namespaces (spec §4).
+ *
+ * Canonical shape: `client.<resource>.<verb>(args, options)`. All 14 public
+ * operations plus the waitUntilComplete poll helper and the flagFraud /
+ * clearFraud convenience wrappers.
+ */
+import { type SmileIDConfig } from './config.js';
+import type { AcceptedResponse, AuthenticationParams, BankCodesParams, BankCodesResponse, BiometricKycParams, ClearFraudParams, CompareParams, DocumentVerificationParams, EnhancedDocumentVerificationParams, EnhancedKycParams, FlagFraudParams, IdStatusParams, IdStatusResponse, JobStatus, RegistrationParams, ReplayParams, ReportFraudParams, RequestOptions, SupportedDocumentsParams, SupportedDocumentsResponse, SupportedIdTypesParams, SupportedIdTypesResponse, WaitOptions } from '../generated/models/index.js';
+/** The Smile ID V3 server-side client. */
+export declare class SmileID {
+    private readonly transport;
+    /** enhanced_kyc (spec §6.1). */
+    readonly enhancedKyc: {
+        verify(params: EnhancedKycParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Document verification (spec §6.2, §6.3). */
+    readonly documents: {
+        verify(params: DocumentVerificationParams, options?: RequestOptions): Promise<AcceptedResponse>;
+        verifyEnhanced(params: EnhancedDocumentVerificationParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Biometric KYC (spec §6.4). */
+    readonly biometricKyc: {
+        verify(params: BiometricKycParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Biometric enroll / authenticate / compare (spec §6.5–§6.7). */
+    readonly biometric: {
+        enroll(params: RegistrationParams, options?: RequestOptions): Promise<AcceptedResponse>;
+        authenticate(params: AuthenticationParams, options?: RequestOptions): Promise<AcceptedResponse>;
+        compare(params: CompareParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Job status, polling, and callback replay (spec §6.8–§6.10). */
+    readonly verifications: {
+        retrieve(jobId: string, options?: RequestOptions): Promise<JobStatus>;
+        waitUntilComplete(jobId: string, options?: WaitOptions): Promise<JobStatus>;
+        replay(jobId: string, params?: ReplayParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Fraud reporting (spec §6.11). */
+    readonly users: {
+        reportFraud(userId: string, params: ReportFraudParams, options?: RequestOptions): Promise<AcceptedResponse>;
+        flagFraud(userId: string, params: FlagFraudParams, options?: RequestOptions): Promise<AcceptedResponse>;
+        clearFraud(userId: string, params: ClearFraudParams, options?: RequestOptions): Promise<AcceptedResponse>;
+    };
+    /** Services lookups (spec §6.12–§6.15). */
+    readonly services: {
+        bankCodes(params?: BankCodesParams, options?: RequestOptions): Promise<BankCodesResponse>;
+        supportedIdTypes(params?: SupportedIdTypesParams, options?: RequestOptions): Promise<SupportedIdTypesResponse>;
+        supportedDocuments(params?: SupportedDocumentsParams, options?: RequestOptions): Promise<SupportedDocumentsResponse>;
+        idStatus(params: IdStatusParams, options?: RequestOptions): Promise<IdStatusResponse>;
+    };
+    constructor(config: SmileIDConfig);
+}

package/dist/client/client.js

@@ -0,0 +1,155 @@
+"use strict";
+/**
+ * The SmileID client and its resource namespaces (spec §4).
+ *
+ * Canonical shape: `client.<resource>.<verb>(args, options)`. All 14 public
+ * operations plus the waitUntilComplete poll helper and the flagFraud /
+ * clearFraud convenience wrappers.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmileID = void 0;
+const config_js_1 = require("./config.js");
+const transport_js_1 = require("./transport.js");
+const ops = __importStar(require("../generated/operations/index.js"));
+const index_js_1 = require("../errors/index.js");
+const poll_js_1 = require("../helpers/poll.js");
+const validation_js_1 = require("../helpers/validation.js");
+/** The Smile ID V3 server-side client. */
+class SmileID {
+    transport;
+    /** enhanced_kyc (spec §6.1). */
+    enhancedKyc;
+    /** Document verification (spec §6.2, §6.3). */
+    documents;
+    /** Biometric KYC (spec §6.4). */
+    biometricKyc;
+    /** Biometric enroll / authenticate / compare (spec §6.5–§6.7). */
+    biometric;
+    /** Job status, polling, and callback replay (spec §6.8–§6.10). */
+    verifications;
+    /** Fraud reporting (spec §6.11). */
+    users;
+    /** Services lookups (spec §6.12–§6.15). */
+    services;
+    constructor(config) {
+        this.transport = new transport_js_1.Transport((0, config_js_1.resolveConfig)(config));
+        const t = this.transport;
+        this.enhancedKyc = {
+            verify: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                return ops.enhancedKyc(t, params, options);
+            },
+        };
+        this.documents = {
+            verify: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                return ops.documentVerification(t, params, options);
+            },
+            verifyEnhanced: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                // idType is required for enhanced document verification (spec §6.3);
+                // enforced at runtime for plain-JavaScript callers too.
+                if (!params.idType) {
+                    throw new index_js_1.ValidationError({
+                        message: 'idType is required for enhanced document verification.',
+                    });
+                }
+                return ops.enhancedDocumentVerification(t, params, options);
+            },
+        };
+        this.biometricKyc = {
+            verify: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                return ops.biometricKyc(t, params, options);
+            },
+        };
+        this.biometric = {
+            enroll: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                return ops.registration(t, params, options);
+            },
+            authenticate: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                (0, validation_js_1.validateAuthentication)(params);
+                return ops.authentication(t, params, options);
+            },
+            compare: (params, options) => {
+                (0, validation_js_1.validateUserDetails)(params.userDetails);
+                return ops.compare(t, params, options);
+            },
+        };
+        this.verifications = {
+            retrieve: (jobId, options) => ops.verificationStatus(t, jobId, options),
+            waitUntilComplete: (jobId, options) => (0, poll_js_1.waitUntilComplete)(() => ops.verificationStatus(t, jobId, {
+                signal: options?.signal,
+                timeout: options?.requestTimeout,
+            }), options),
+            replay: (jobId, params, options) => ops.replayCallback(t, jobId, params, options),
+        };
+        this.users = {
+            reportFraud: (userId, params, options) => {
+                (0, validation_js_1.validateReportFraud)(params);
+                return ops.reportFraud(t, userId, params, options);
+            },
+            flagFraud: (userId, params, options) => {
+                const report = {
+                    isFraud: true,
+                    reason: params.reason,
+                    notes: params.notes,
+                    reportedBy: params.reportedBy,
+                };
+                (0, validation_js_1.validateReportFraud)(report);
+                return ops.reportFraud(t, userId, report, options);
+            },
+            clearFraud: (userId, params, options) => {
+                const report = {
+                    isFraud: false,
+                    notes: params.notes,
+                    reportedBy: params.reportedBy,
+                };
+                (0, validation_js_1.validateReportFraud)(report);
+                return ops.reportFraud(t, userId, report, options);
+            },
+        };
+        this.services = {
+            bankCodes: (params, options) => ops.bankCodes(t, params, options),
+            supportedIdTypes: (params, options) => ops.supportedIdTypes(t, params, options),
+            supportedDocuments: (params, options) => ops.supportedDocuments(t, params, options),
+            idStatus: (params, options) => ops.idStatus(t, params, options),
+        };
+    }
+}
+exports.SmileID = SmileID;