@authenta/core 1.0.0

package/README.md

@@ -0,0 +1,324 @@
+# @authenta/core
+
+Pure TypeScript API client for the [Authenta](https://authenta.ai) eKYC platform. Works in **Node.js** and **React Native** — no native modules or UI dependencies.
+
+Use this package directly if you want headless control over uploads, polling, and result retrieval. For a ready-made camera capture UI, use [`@authenta/react-native`](https://www.npmjs.com/package/@authenta/react-native).
+
+---
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [AuthentaClient](#authentaclient)
+  - [Configuration](#configuration)
+  - [faceIntelligence()](#faceintelligence)
+  - [RunOptions](#runoptions)
+  - [Low-level API](#low-level-api)
+- [Models](#models)
+- [Error Handling](#error-handling)
+- [TypeScript Types](#typescript-types)
+- [Contributing](#contributing)
+
+---
+
+## Installation
+
+```bash
+npm install @authenta/core
+```
+
+No peer dependencies. Works out of the box in Node.js >= 16 and React Native >= 0.72.
+
+---
+
+## Quick Start
+
+```ts
+import { AuthentaClient } from '@authenta/core';
+
+const client = new AuthentaClient({
+  clientId:     'YOUR_CLIENT_ID',
+  clientSecret: 'YOUR_CLIENT_SECRET',
+});
+
+const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+  livenessCheck: true,
+});
+
+console.log(result.result?.isLiveness);   // true | false
+console.log(result.status);               // "PROCESSED"
+```
+
+---
+
+## AuthentaClient
+
+### Configuration
+
+```ts
+const client = new AuthentaClient({
+  clientId:     'YOUR_CLIENT_ID',       // required
+  clientSecret: 'YOUR_CLIENT_SECRET',   // required
+  baseUrl:      'https://platform.authenta.ai', // optional — default shown
+});
+```
+
+| Option | Type | Required | Description |
+|---|---|---|---|
+| `clientId` | `string` | Yes | Your Authenta client ID |
+| `clientSecret` | `string` | Yes | Your Authenta client secret |
+| `baseUrl` | `string` | No | API base URL (default: `https://platform.authenta.ai`) |
+
+---
+
+### faceIntelligence()
+
+The primary high-level method. Uploads the file, polls until processing is complete, fetches the detection result, and returns a `ProcessedMedia` object.
+
+```ts
+const result = await client.faceIntelligence(uri, modelType, options);
+```
+
+**Parameters**
+
+| Parameter | Type | Description |
+|---|---|---|
+| `uri` | `string` | `file://` URI of the photo or video to analyse |
+| `modelType` | `ModelType` | Model to run (e.g. `'FI-1'`) |
+| `options` | `RunOptions` | Detection options — see [RunOptions](#runoptions) |
+
+**Examples**
+
+```ts
+// Liveness check — photo
+const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+  livenessCheck: true,
+});
+
+// Faceswap check — video
+const result = await client.faceIntelligence('file:///path/to/clip.mp4', 'FI-1', {
+  faceswapCheck: true,
+});
+
+// Liveness + faceswap — video
+const result = await client.faceIntelligence('file:///path/to/clip.mp4', 'FI-1', {
+  livenessCheck: true,
+  faceswapCheck: true,
+});
+
+// Face similarity — photo + reference
+const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+  faceSimilarityCheck: true,
+  referenceImage: 'file:///path/to/id-photo.jpg',
+});
+
+// Liveness + face similarity — photo
+const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+  livenessCheck: true,
+  faceSimilarityCheck: true,
+  referenceImage: 'file:///path/to/id-photo.jpg',
+});
+```
+
+**Returns** `Promise<ProcessedMedia>`
+
+```ts
+{
+  mid:         string;       // unique media ID
+  name:        string;
+  status:      'PROCESSED';  // always PROCESSED on success
+  modelType:   string;       // e.g. "FI-1"
+  contentType: string;       // MIME type of the uploaded file
+  size:        number;       // file size in bytes
+  createdAt:   string;       // ISO 8601
+  srcURL?:     string;
+  resultURL?:  string;
+  result?: {
+    resultType:       string;
+    isLiveness?:      boolean | string;   // liveness check result
+    isDeepFake?:      boolean | string;   // faceswap / deepfake result
+    isSimilar?:       boolean | string;   // face similarity result
+    similarityScore?: number  | string;   // 0–100
+    [key: string]:    any;
+  };
+}
+```
+
+---
+
+### RunOptions
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `livenessCheck` | `boolean` | `false` | Run liveness check (FI-1) |
+| `faceswapCheck` | `boolean` | `false` | Run faceswap / deepfake check (FI-1, video required) |
+| `faceSimilarityCheck` | `boolean` | `false` | Run face similarity check (FI-1, photo + reference required) |
+| `referenceImage` | `string` | — | `file://` URI of reference face image (required when `faceSimilarityCheck: true`) |
+| `isSingleFace` | `boolean` | `true` | Hint that only one face is present |
+| `autoPolling` | `boolean` | `true` | Wait for result before returning. Set `false` to return immediately after upload |
+| `interval` | `number` | `5000` | Polling interval in milliseconds |
+| `timeout` | `number` | `600000` | Max polling duration in milliseconds (10 min) |
+
+**Check compatibility**
+
+| Check | Input required | Can combine with |
+|---|---|---|
+| `livenessCheck` | Photo **or** video | `faceSimilarityCheck` |
+| `faceswapCheck` | Video (max 10 s) | `livenessCheck` |
+| `faceSimilarityCheck` | Photo + `referenceImage` | `livenessCheck` |
+| `faceswapCheck` + `faceSimilarityCheck` | — | **Not allowed** |
+
+---
+
+### Low-level API
+
+Call each step individually for full control:
+
+```ts
+// 1. Upload — creates a media record and uploads the file to S3
+const media = await client.upload('file:///path/to/selfie.jpg', 'FI-1', {
+  livenessCheck: true,
+});
+console.log(media.mid); // "abc-123"
+
+// 2. Poll until processing completes
+const processed = await client.waitForMedia(media.mid, {
+  interval: 3000,    // poll every 3 s
+  timeout:  120000,  // give up after 2 min
+});
+
+// 3. Fetch the detection result from resultURL
+const result = await client.getResult(processed);
+console.log(result.isLiveness, result.isDeepFake);
+
+// CRUD helpers
+const record = await client.getMedia(mid);
+const list   = await client.listMedia({ page: 1, pageSize: 20 });
+await client.deleteMedia(mid);
+```
+
+---
+
+## Models
+
+| Model ID | Description | Input |
+|---|---|---|
+| `FI-1` | Face Intelligence — liveness, faceswap, face similarity | Photo or video |
+
+---
+
+## Error Handling
+
+All errors extend `AuthentaError`. Import and catch specifically:
+
+```ts
+import {
+  AuthentaError,
+  AuthenticationError,
+  AuthorizationError,
+  QuotaExceededError,
+  InsufficientCreditsError,
+  ValidationError,
+  ServerError,
+} from '@authenta/core';
+
+try {
+  const result = await client.faceIntelligence(uri, 'FI-1', { livenessCheck: true });
+} catch (err) {
+  if (err instanceof AuthenticationError) {
+    // Invalid clientId / clientSecret — check your credentials
+  } else if (err instanceof AuthorizationError) {
+    // Account lacks permission for this operation
+  } else if (err instanceof QuotaExceededError) {
+    // Monthly quota exceeded
+  } else if (err instanceof InsufficientCreditsError) {
+    // No remaining credits
+  } else if (err instanceof ValidationError) {
+    // Bad input — see err.message for details
+    console.error(err.message, err.code, err.statusCode);
+  } else if (err instanceof ServerError) {
+    // Platform error — safe to retry
+  } else if (err instanceof AuthentaError) {
+    // Base class catch-all
+    console.error(err.message, err.code, err.statusCode, err.details);
+  }
+}
+```
+
+**Error properties**
+
+| Property | Type | Description |
+|---|---|---|
+| `message` | `string` | Human-readable description |
+| `code` | `string?` | API error code (e.g. `IAM001`) |
+| `statusCode` | `number?` | HTTP status code |
+| `details` | `object?` | Raw API response body |
+
+---
+
+## TypeScript Types
+
+All public types are exported from the package entry point:
+
+```ts
+import type {
+  AuthentaClientConfig,
+  ModelType,
+  MediaStatus,
+  FileInfo,
+  FIOptions,
+  RunOptions,
+  PollingOptions,
+  CreateMediaResponse,
+  MediaRecord,
+  ListMediaResponse,
+  DetectionResult,
+  ProcessedMedia,
+} from '@authenta/core';
+```
+
+---
+
+## Contributing
+
+### Setup
+
+```bash
+git clone https://github.com/phospheneai/authenta-reactnative-sdk.git
+cd authenta-reactnative-sdk
+npm install
+```
+
+### Build
+
+```bash
+npm run build --workspace=packages/core
+```
+
+### Test
+
+```bash
+npm test --workspace=packages/core
+```
+
+### Guidelines
+
+- **No native modules** — this package must work in plain Node.js. Do not import React, React Native, or any native module.
+- **No Node.js built-ins at the top level** — Metro (React Native bundler) cannot resolve `fs`, `path`, etc. Use the `_require = require` alias trick only inside runtime guards (`typeof XMLHttpRequest === 'undefined'`).
+- **Typed errors** — all thrown values must extend `AuthentaError`. New error types go in `errors.ts` and must be exported from `index.ts`.
+- **Types in one place** — all interfaces belong in `src/types/index.ts`.
+- **No breaking changes** — `AuthentaClient` and all exported types are the stable public surface.
+
+### Publish
+
+```bash
+# Bump version in packages/core/package.json, then:
+npm publish --workspace=packages/core --access public
+```
+
+---
+
+## License
+
+MIT © Authenta

package/dist/client.d.ts

@@ -0,0 +1,62 @@
+import { ModelType, FIOptions, PollingOptions, RunOptions, CreateMediaResponse, MediaRecord, ListMediaParams, ListMediaResponse, DetectionResult, ProcessedMedia } from './types';
+export interface AuthentaClientConfig {
+    baseUrl?: string;
+    clientId: string;
+    clientSecret: string;
+}
+export declare class AuthentaClient {
+    private readonly baseUrl;
+    private readonly clientId;
+    private readonly clientSecret;
+    constructor({ baseUrl, clientId, clientSecret, }: AuthentaClientConfig);
+    private get authHeaders();
+    private request;
+    private throwApiError;
+    /** Fetch a local URI once — derives name, type, size, and blob for upload.
+     *  In React Native uses XMLHttpRequest (fetch('file://...') fails on Android).
+     *  In Node.js (tests) uses fs since XMLHttpRequest is not available. */
+    private resolveUri;
+    private uploadToS3;
+    createMedia(params: {
+        name: string;
+        contentType: string;
+        size: number;
+        modelType: ModelType;
+        metadata?: Record<string, any>;
+    }): Promise<CreateMediaResponse>;
+    getMedia(mid: string): Promise<MediaRecord>;
+    listMedia(params?: ListMediaParams): Promise<ListMediaResponse>;
+    deleteMedia(mid: string): Promise<void>;
+    /**
+     * Two-step upload: derives file info from the URI, creates a media record,
+     * then PUTs the file blob to S3. Works for all model types.
+     * Pass `fiOptions` only when modelType is "FI-1".
+     */
+    upload(uri: string, modelType: ModelType, fiOptions?: FIOptions): Promise<CreateMediaResponse>;
+    waitForMedia(mid: string, { interval, timeout }?: PollingOptions): Promise<MediaRecord>;
+    getResult(media: MediaRecord): Promise<DetectionResult>;
+    /**
+     * Upload a file URI and process it with the given model.
+     * The SDK automatically derives the file name, type, and size from the URI.
+     *
+     * - For all models: uploads, polls until complete, and fetches the result.
+     * - For FI-1: pass any face-check flags; unset flags default to false.
+     * - Set `autoPolling: false` to return immediately after upload.
+     *
+     * @example DF-1 / AC-1
+     *   const result = await client.faceIntelligence('file:///path/to/video.mp4', 'DF-1');
+     *
+     * @example FI-1 liveness
+     *   const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', { livenessCheck: true });
+     *
+     * @example FI-1 faceswap (video only)
+     *   const result = await client.faceIntelligence('file:///path/to/video.mp4', 'FI-1', { faceswapCheck: true });
+     *
+     * @example FI-1 similarity
+     *   const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+     *     faceSimilarityCheck: true,
+     *     referenceImage: 'file:///path/to/id-photo.jpg',
+     *   });
+     */
+    faceIntelligence(uri: string, modelType: ModelType, { autoPolling, interval, timeout, isSingleFace, faceswapCheck, livenessCheck, faceSimilarityCheck, referenceImage, }?: RunOptions): Promise<ProcessedMedia>;
+}

package/dist/client.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthentaClient = void 0;
+const errors_1 = require("./errors");
+const helpers_1 = require("./utils/helpers");
+const TERMINAL_STATUSES = new Set(['PROCESSED', 'FAILED', 'ERROR']);
+class AuthentaClient {
+    constructor({ baseUrl = 'https://platform.authenta.ai', clientId, clientSecret, }) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+    }
+    // ─── Private helpers ───────────────────────────────────────────────────────
+    get authHeaders() {
+        return {
+            'x-client-id': this.clientId,
+            'x-client-secret': this.clientSecret,
+            'Content-Type': 'application/json',
+        };
+    }
+    async request(method, path, body, queryParams) {
+        let url = `${this.baseUrl}${path}`;
+        if (queryParams) {
+            const qs = Object.entries(queryParams)
+                .filter(([, v]) => v !== undefined && v !== null)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+                .join('&');
+            if (qs)
+                url += `?${qs}`;
+        }
+        const response = await fetch(url, {
+            method,
+            headers: this.authHeaders,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            await this.throwApiError(response);
+        }
+        const text = await response.text();
+        if (!text.trim())
+            return {};
+        try {
+            return JSON.parse(text);
+        }
+        catch (_a) {
+            throw new errors_1.ValidationError('Expected JSON but received non-JSON response', undefined, response.status, { body: text.slice(0, 200) });
+        }
+    }
+    async throwApiError(response) {
+        var _a, _b, _c;
+        const status = response.status;
+        let data;
+        try {
+            data = await response.json();
+        }
+        catch (_d) {
+            const text = await response.text().catch(() => '');
+            if (status >= 500)
+                throw new errors_1.ServerError(text || 'Server error', undefined, status);
+            throw new errors_1.ValidationError(text || 'Client error', undefined, status);
+        }
+        const code = (_a = data === null || data === void 0 ? void 0 : data.code) !== null && _a !== void 0 ? _a : 'unknown';
+        const message = (_c = (_b = data === null || data === void 0 ? void 0 : data.message) !== null && _b !== void 0 ? _b : response.statusText) !== null && _c !== void 0 ? _c : 'Unknown error';
+        if (code === 'IAM001')
+            throw new errors_1.AuthenticationError(message, status, data);
+        if (code === 'IAM002')
+            throw new errors_1.AuthorizationError(message, status, data);
+        if (code === 'AA001')
+            throw new errors_1.QuotaExceededError(message, status, data);
+        if (code === 'U007')
+            throw new errors_1.InsufficientCreditsError(message, status, data);
+        if (status >= 500)
+            throw new errors_1.ServerError(message, code, status, data);
+        if (status >= 400)
+            throw new errors_1.ValidationError(message, code, status, data);
+        throw new errors_1.AuthentaError(message, code, status, data);
+    }
+    /** Fetch a local URI once — derives name, type, size, and blob for upload.
+     *  In React Native uses XMLHttpRequest (fetch('file://...') fails on Android).
+     *  In Node.js (tests) uses fs since XMLHttpRequest is not available. */
+    resolveUri(uri) {
+        var _a, _b;
+        const name = (_b = (_a = uri.split('/').pop()) === null || _a === void 0 ? void 0 : _a.split('?')[0]) !== null && _b !== void 0 ? _b : 'file';
+        const type = (0, helpers_1.getMimeType)(name);
+        // Node.js environment — XMLHttpRequest does not exist
+        if (typeof XMLHttpRequest === 'undefined') {
+            // Use aliased require so Metro's static analyser does not try to bundle 'fs'
+            const _require = require;
+            const fs = _require('fs');
+            const filePath = uri.replace(/^file:\/\//, '');
+            const buffer = fs.readFileSync(filePath);
+            const blob = new Blob([buffer], { type });
+            return Promise.resolve({ name, type, size: buffer.byteLength, blob });
+        }
+        // React Native — use XHR
+        return new Promise((resolve, reject) => {
+            const xhr = new XMLHttpRequest();
+            xhr.responseType = 'blob';
+            xhr.onload = () => resolve({ name, type, size: xhr.response.size, blob: xhr.response });
+            xhr.onerror = () => reject(new errors_1.AuthentaError(`Could not read file at URI: ${uri}`));
+            xhr.open('GET', uri);
+            xhr.send();
+        });
+    }
+    async uploadToS3(uploadUrl, blob, contentType) {
+        const putResponse = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: { 'Content-Type': contentType },
+            body: blob,
+        });
+        if (!putResponse.ok) {
+            throw new errors_1.AuthentaError(`S3 upload failed: HTTP ${putResponse.status}`, undefined, putResponse.status);
+        }
+    }
+    // ─── Core media CRUD ───────────────────────────────────────────────────────
+    async createMedia(params) {
+        return this.request('POST', '/api/media', params);
+    }
+    async getMedia(mid) {
+        return this.request('GET', `/api/media/${mid}`);
+    }
+    async listMedia(params) {
+        return this.request('GET', '/api/media', undefined, params);
+    }
+    async deleteMedia(mid) {
+        await this.request('DELETE', `/api/media/${mid}`);
+    }
+    // ─── Upload (common for all models) ───────────────────────────────────────
+    /**
+     * Two-step upload: derives file info from the URI, creates a media record,
+     * then PUTs the file blob to S3. Works for all model types.
+     * Pass `fiOptions` only when modelType is "FI-1".
+     */
+    async upload(uri, modelType, fiOptions) {
+        const { name, type, size, blob } = await this.resolveUri(uri);
+        const payload = {
+            name,
+            contentType: type,
+            size,
+            modelType,
+        };
+        if (modelType.toUpperCase() === 'FI-1' && fiOptions) {
+            const { isSingleFace = true, faceswapCheck = false, livenessCheck = false, faceSimilarityCheck = false, } = fiOptions;
+            payload.metadata = { isSingleFace, faceswapCheck, livenessCheck, faceSimilarityCheck };
+        }
+        const media = await this.createMedia(payload);
+        await this.uploadToS3(media.uploadUrl, blob, type);
+        if (modelType.toUpperCase() === 'FI-1' && (fiOptions === null || fiOptions === void 0 ? void 0 : fiOptions.faceSimilarityCheck)) {
+            if (!fiOptions.referenceImage) {
+                throw new errors_1.ValidationError('referenceImage is required when faceSimilarityCheck is true');
+            }
+            if (!media.referenceUploadUrl) {
+                throw new errors_1.AuthentaError('No referenceUploadUrl returned from server');
+            }
+            const { blob: refBlob, type: refType } = await this.resolveUri(fiOptions.referenceImage);
+            await this.uploadToS3(media.referenceUploadUrl, refBlob, refType);
+        }
+        return media;
+    }
+    // ─── Polling ───────────────────────────────────────────────────────────────
+    async waitForMedia(mid, { interval = 5000, timeout = 600000 } = {}) {
+        const deadline = Date.now() + timeout;
+        while (true) {
+            const media = await this.getMedia(mid);
+            if (TERMINAL_STATUSES.has(media.status.toUpperCase()))
+                return media;
+            if (Date.now() >= deadline) {
+                throw new errors_1.AuthentaError(`Timed out waiting for media ${mid} — last status: ${media.status}`);
+            }
+            await new Promise(resolve => setTimeout(resolve, interval));
+        }
+    }
+    // ─── Result ────────────────────────────────────────────────────────────────
+    async getResult(media) {
+        if (!media.resultURL) {
+            throw new errors_1.ValidationError('media has no resultURL — ensure processing is complete (status=PROCESSED)');
+        }
+        const response = await fetch(media.resultURL);
+        if (!response.ok) {
+            throw new errors_1.AuthentaError(`Failed to fetch resultURL: HTTP ${response.status}`, undefined, response.status);
+        }
+        return response.json();
+    }
+    // ─── High-level: one function for all models ──────────────────────────────
+    /**
+     * Upload a file URI and process it with the given model.
+     * The SDK automatically derives the file name, type, and size from the URI.
+     *
+     * - For all models: uploads, polls until complete, and fetches the result.
+     * - For FI-1: pass any face-check flags; unset flags default to false.
+     * - Set `autoPolling: false` to return immediately after upload.
+     *
+     * @example DF-1 / AC-1
+     *   const result = await client.faceIntelligence('file:///path/to/video.mp4', 'DF-1');
+     *
+     * @example FI-1 liveness
+     *   const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', { livenessCheck: true });
+     *
+     * @example FI-1 faceswap (video only)
+     *   const result = await client.faceIntelligence('file:///path/to/video.mp4', 'FI-1', { faceswapCheck: true });
+     *
+     * @example FI-1 similarity
+     *   const result = await client.faceIntelligence('file:///path/to/selfie.jpg', 'FI-1', {
+     *     faceSimilarityCheck: true,
+     *     referenceImage: 'file:///path/to/id-photo.jpg',
+     *   });
+     */
+    async faceIntelligence(uri, modelType, { autoPolling = true, interval, timeout, isSingleFace = true, faceswapCheck = false, livenessCheck = false, faceSimilarityCheck = false, referenceImage, } = {}) {
+        var _a;
+        const isFI = modelType.toUpperCase() === 'FI-1';
+        if (isFI) {
+            const type = (0, helpers_1.getMimeType)((_a = uri.split('/').pop()) !== null && _a !== void 0 ? _a : '');
+            if ((0, helpers_1.isImage)(type) && faceswapCheck) {
+                throw new errors_1.ValidationError('faceswapCheck cannot be true for image files');
+            }
+            if ((0, helpers_1.isVideo)(type) && faceSimilarityCheck) {
+                throw new errors_1.ValidationError('faceSimilarityCheck cannot be true for video files');
+            }
+            if (faceSimilarityCheck && !referenceImage) {
+                throw new errors_1.ValidationError('referenceImage is required when faceSimilarityCheck is true');
+            }
+        }
+        const fiOptions = isFI
+            ? { isSingleFace, faceswapCheck, livenessCheck, faceSimilarityCheck, referenceImage }
+            : undefined;
+        const meta = await this.upload(uri, modelType, fiOptions);
+        if (!autoPolling)
+            return meta;
+        const media = await this.waitForMedia(meta.mid, { interval, timeout });
+        const result = media.resultURL ? await this.getResult(media) : undefined;
+        return Object.assign(Object.assign({}, media), { result });
+    }
+}
+exports.AuthentaClient = AuthentaClient;

package/dist/errors.d.ts

@@ -0,0 +1,24 @@
+export declare class AuthentaError extends Error {
+    readonly code?: string | undefined;
+    readonly statusCode?: number | undefined;
+    readonly details?: Record<string, any> | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined, details?: Record<string, any> | undefined);
+}
+export declare class AuthenticationError extends AuthentaError {
+    constructor(message: string, statusCode?: number, details?: Record<string, any>);
+}
+export declare class AuthorizationError extends AuthentaError {
+    constructor(message: string, statusCode?: number, details?: Record<string, any>);
+}
+export declare class QuotaExceededError extends AuthentaError {
+    constructor(message: string, statusCode?: number, details?: Record<string, any>);
+}
+export declare class InsufficientCreditsError extends AuthentaError {
+    constructor(message: string, statusCode?: number, details?: Record<string, any>);
+}
+export declare class ValidationError extends AuthentaError {
+    constructor(message: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}
+export declare class ServerError extends AuthentaError {
+    constructor(message: string, code?: string, statusCode?: number, details?: Record<string, any>);
+}

package/dist/errors.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = exports.ValidationError = exports.InsufficientCreditsError = exports.QuotaExceededError = exports.AuthorizationError = exports.AuthenticationError = exports.AuthentaError = void 0;
+class AuthentaError extends Error {
+    constructor(message, code, statusCode, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = 'AuthentaError';
+    }
+}
+exports.AuthentaError = AuthentaError;
+class AuthenticationError extends AuthentaError {
+    constructor(message, statusCode, details) {
+        super(message, 'IAM001', statusCode, details);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class AuthorizationError extends AuthentaError {
+    constructor(message, statusCode, details) {
+        super(message, 'IAM002', statusCode, details);
+        this.name = 'AuthorizationError';
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+class QuotaExceededError extends AuthentaError {
+    constructor(message, statusCode, details) {
+        super(message, 'AA001', statusCode, details);
+        this.name = 'QuotaExceededError';
+    }
+}
+exports.QuotaExceededError = QuotaExceededError;
+class InsufficientCreditsError extends AuthentaError {
+    constructor(message, statusCode, details) {
+        super(message, 'U007', statusCode, details);
+        this.name = 'InsufficientCreditsError';
+    }
+}
+exports.InsufficientCreditsError = InsufficientCreditsError;
+class ValidationError extends AuthentaError {
+    constructor(message, code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class ServerError extends AuthentaError {
+    constructor(message, code, statusCode, details) {
+        super(message, code, statusCode, details);
+        this.name = 'ServerError';
+    }
+}
+exports.ServerError = ServerError;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { AuthentaClient } from './client';
+export type { AuthentaClientConfig } from './client';
+export * from './types';
+export * from './errors';
+export { getMimeType, isImage, isVideo, safeJsonParse } from './utils/helpers';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJsonParse = exports.isVideo = exports.isImage = exports.getMimeType = exports.AuthentaClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AuthentaClient", { enumerable: true, get: function () { return client_1.AuthentaClient; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);
+var helpers_1 = require("./utils/helpers");
+Object.defineProperty(exports, "getMimeType", { enumerable: true, get: function () { return helpers_1.getMimeType; } });
+Object.defineProperty(exports, "isImage", { enumerable: true, get: function () { return helpers_1.isImage; } });
+Object.defineProperty(exports, "isVideo", { enumerable: true, get: function () { return helpers_1.isVideo; } });
+Object.defineProperty(exports, "safeJsonParse", { enumerable: true, get: function () { return helpers_1.safeJsonParse; } });

package/dist/types/index.d.ts

@@ -0,0 +1,85 @@
+export type ModelType = 'DF-1' | 'AC-1' | 'FI-1' | (string & {});
+export type MediaStatus = 'PENDING' | 'PROCESSING' | 'PROCESSED' | 'FAILED' | 'ERROR';
+export interface FileInfo {
+    uri: string;
+    name: string;
+    type: string;
+    size: number;
+}
+export interface FIOptions {
+    isSingleFace?: boolean;
+    faceswapCheck?: boolean;
+    livenessCheck?: boolean;
+    faceSimilarityCheck?: boolean;
+    referenceImage?: string;
+}
+export interface PollingOptions {
+    interval?: number;
+    timeout?: number;
+}
+export interface RunOptions extends FIOptions, PollingOptions {
+    autoPolling?: boolean;
+}
+export interface CreateMediaResponse {
+    mid: string;
+    name: string;
+    status: MediaStatus;
+    modelType: string;
+    contentType: string;
+    size: number;
+    createdAt: string;
+    uploadUrl: string;
+    referenceUploadUrl?: string;
+}
+export interface MediaRecord {
+    mid: string;
+    name: string;
+    status: MediaStatus;
+    modelType: string;
+    contentType: string;
+    size: number;
+    createdAt: string;
+    srcURL?: string;
+    resultURL?: string;
+}
+export interface ListMediaParams {
+    page?: number;
+    pageSize?: number;
+    [key: string]: any;
+}
+export interface ListMediaResponse {
+    items: MediaRecord[];
+    total?: number;
+    page?: number;
+    pageSize?: number;
+}
+export interface DetectionResult {
+    resultType?: string;
+    isDeepFake?: string | boolean;
+    RealConfidencePercent?: string | number;
+    isLiveness?: string | boolean;
+    isSimilar?: string | boolean;
+    similarityScore?: string | number;
+    identityPredictions?: IdentityPrediction[];
+    boundingBoxes?: BoundingBoxesMap;
+    [key: string]: any;
+}
+export interface IdentityPrediction {
+    identityId: number;
+    isDeepFake: boolean;
+}
+export type BoundingBoxCoords = [number, number, number, number];
+export interface FrameBoundingBox {
+    [frameId: string]: BoundingBoxCoords;
+}
+export interface IdentityBoundingBox {
+    boundingBox: FrameBoundingBox;
+    class: 'real' | 'fake';
+    confidence: number;
+}
+export interface BoundingBoxesMap {
+    [identityId: string]: IdentityBoundingBox;
+}
+export interface ProcessedMedia extends MediaRecord {
+    result?: DetectionResult;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const getMimeType: (path: string) => string;
+export declare const isImage: (mimeType: string) => boolean;
+export declare const isVideo: (mimeType: string) => boolean;
+export declare const safeJsonParse: (jsonString: string) => any;

package/dist/utils/helpers.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJsonParse = exports.isVideo = exports.isImage = exports.getMimeType = void 0;
+const getMimeType = (path) => {
+    const mimeTypes = {
+        // Images
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.png': 'image/png',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml',
+        // Videos
+        '.mp4': 'video/mp4',
+        '.mov': 'video/quicktime',
+        '.avi': 'video/x-msvideo',
+        '.mkv': 'video/x-matroska',
+        '.webm': 'video/webm',
+        '.flv': 'video/x-flv',
+        '.wmv': 'video/x-ms-wmv',
+        '.m4v': 'video/x-m4v',
+        '.3gp': 'video/3gpp',
+        // Audio
+        '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav',
+        '.m4a': 'audio/mp4',
+        '.aac': 'audio/aac',
+        '.flac': 'audio/flac',
+        '.ogg': 'audio/ogg',
+    };
+    const extension = path.substring(path.lastIndexOf('.')).toLowerCase();
+    return mimeTypes[extension] || 'application/octet-stream';
+};
+exports.getMimeType = getMimeType;
+const isImage = (mimeType) => {
+    return mimeType.startsWith('image/');
+};
+exports.isImage = isImage;
+const isVideo = (mimeType) => {
+    return mimeType.startsWith('video/');
+};
+exports.isVideo = isVideo;
+const safeJsonParse = (jsonString) => {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (error) {
+        console.error('JSON parsing error:', error);
+        return null;
+    }
+};
+exports.safeJsonParse = safeJsonParse;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@authenta/core",
+  "version": "1.0.0",
+  "description": "Authenta API client — pure TypeScript, works in Node.js and React Native",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --passWithNoTests",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phospheneai/authenta-reactnative-sdk.git"
+  },
+  "keywords": ["authenta", "ekyc", "face", "liveness", "typescript"],
+  "author": "Authenta",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^4.0.0"
+  }
+}