@authme/id-recognition 2.2.0 → 2.2.1-rc.3

package/index.cjs

@@ -0,0 +1,263 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var engine = require('@authme/engine');
+require('core-js/modules/es.array.iterator.js');
+require('core-js/modules/es.object.from-entries.js');
+require('core-js/modules/web.dom-collections.iterator.js');
+var core = require('@authme/core');
+require('core-js/modules/es.symbol.description.js');
+
+exports.ResourceImageType = void 0;
+(function (ResourceImageType) {
+  ResourceImageType["Recognition"] = "Recognition";
+  ResourceImageType["Fraud"] = "Fraud";
+  ResourceImageType["Manual"] = "Manual";
+})(exports.ResourceImageType || (exports.ResourceImageType = {}));
+exports.CountryCode = void 0;
+(function (CountryCode) {
+  CountryCode["TWN"] = "TWN";
+})(exports.CountryCode || (exports.CountryCode = {}));
+exports.IdRecognitionCardType = void 0;
+(function (IdRecognitionCardType) {
+  IdRecognitionCardType["IDCard"] = "IDCard";
+  IdRecognitionCardType["DriverLicense"] = "DriverLicense";
+  IdRecognitionCardType["HealthCard"] = "HealthCard";
+  IdRecognitionCardType["ResidentCard"] = "ResidentCard";
+  IdRecognitionCardType["Passport"] = "Passport";
+})(exports.IdRecognitionCardType || (exports.IdRecognitionCardType = {}));
+exports.ServerSideEAuthMeCardClass = void 0;
+(function (ServerSideEAuthMeCardClass) {
+  ServerSideEAuthMeCardClass["Invalid"] = "Invalid";
+  ServerSideEAuthMeCardClass["Unknown"] = "UnknownCard";
+  ServerSideEAuthMeCardClass["Passport"] = "Passport";
+  ServerSideEAuthMeCardClass["TWN_IDCard_Front"] = "TWN_IDCard_Front";
+  ServerSideEAuthMeCardClass["TWN_IDCard_Back"] = "TWN_IDCard_Back";
+  ServerSideEAuthMeCardClass["TWN_DriverLicense_Front"] = "TWN_DriverLicense_Front";
+  ServerSideEAuthMeCardClass["TWN_DriverLicense_Back"] = "TWN_DriverLicense_Back";
+  ServerSideEAuthMeCardClass["TWN_ResidentCard_Front"] = "TWN_ResidentCard_Front";
+  ServerSideEAuthMeCardClass["TWN_ResidentCard_Back"] = "TWN_ResidentCard_Back";
+  ServerSideEAuthMeCardClass["TWN_HealthCard_Front"] = "TWN_HealthCard_Front";
+  ServerSideEAuthMeCardClass["TWN_VehiclesLicense_Front"] = "TWN_VehiclesLicense_Front";
+})(exports.ServerSideEAuthMeCardClass || (exports.ServerSideEAuthMeCardClass = {}));
+
+class CardOCR extends engine.AuthmeEngineModuleBase {
+  constructor(engine$1) {
+    super(engine$1);
+    this.type = engine.EAuthMeCardClass.Invalid;
+    this.moduleName = engine.EngineModule.CardOCR;
+  }
+  setType(type) {
+    this.type = type;
+    return this.engine.run(this.moduleName, 'setType', {
+      type
+    });
+  }
+  getType() {
+    return this.type;
+  }
+}
+class IdCardAntiFraudService extends engine.AuthmeEngineModuleBase {
+  constructor(engine$1) {
+    super(engine$1);
+    this.moduleName = engine.EngineModule.IdCardAntiFraud;
+  }
+  setStage(stageList) {
+    const stageStrList = stageList.map(x => x.split('_')[1]);
+    return this.engine.run(this.moduleName, 'setStage', stageStrList);
+  }
+}
+class MRZService extends engine.AuthmeEngineModuleBase {
+  constructor(engine$1) {
+    super(engine$1);
+    this.moduleName = engine.EngineModule.PassportService;
+  }
+  getFinalResult() {
+    return this.engine.run(this.moduleName, 'getFinalResult');
+  }
+  toJson(params) {
+    return this.engine.run(this.moduleName, 'toJson', params);
+  }
+}
+
+exports.IdType = void 0;
+(function (IdType) {
+  IdType["IdCard"] = "IDCard";
+  IdType["DriverLicense"] = "DriverLicense";
+  IdType["HealthCard"] = "HealthCard";
+  IdType["Passport"] = "Passport";
+})(exports.IdType || (exports.IdType = {}));
+const IdTypeConfig = {
+  [exports.IdType.IdCard]: {
+    front: true,
+    back: true
+  },
+  [exports.IdType.Passport]: {
+    front: true,
+    back: true
+  },
+  [exports.IdType.HealthCard]: {
+    front: true,
+    back: false
+  },
+  [exports.IdType.DriverLicense]: {
+    front: true,
+    back: true
+  }
+};
+
+const CardTypeMapping = {
+  [exports.IdRecognitionCardType.IDCard]: [engine.EAuthMeCardClass.TWN_IDCard_Front, engine.EAuthMeCardClass.TWN_IDCard_Back],
+  [exports.IdRecognitionCardType.HealthCard]: [engine.EAuthMeCardClass.TWN_HealthCard_Front],
+  [exports.IdRecognitionCardType.Passport]: [engine.EAuthMeCardClass.Passport],
+  [exports.IdRecognitionCardType.ResidentCard]: [engine.EAuthMeCardClass.TWN_ResidentCard_Front, engine.EAuthMeCardClass.TWN_ResidentCard_Back],
+  [exports.IdRecognitionCardType.DriverLicense]: [engine.EAuthMeCardClass.TWN_DriverLicense_Front, engine.EAuthMeCardClass.TWN_DriverLicense_Back]
+};
+const RECOGNITION_COLUMNS_ORDER = Object.fromEntries(['surname', 'givenName', 'name', 'gender', 'dateOfBirth', 'idNumber', 'dateOfIssue', 'issueCity', 'issueReason', 'father', 'mother', 'spouse', 'militaryService', 'placeOfBirth', 'serialNumber', 'expiry', 'controlNo', 'type', 'condition', 'address', 'country', 'documentNumber', 'documentType', 'nationality', 'expiryDate'].map((value, index) => [value, index]));
+function getCardSubTypes(type, country) {
+  return CardTypeMapping[type];
+}
+function getRecognitionColumnOrder(column) {
+  var _a;
+  return (_a = RECOGNITION_COLUMNS_ORDER[column]) !== null && _a !== void 0 ? _a : Number.MAX_VALUE;
+}
+const twoWayAuthmeCardClassMap = (() => {
+  const map = Object.fromEntries(Object.entries(exports.ServerSideEAuthMeCardClass).map(([key, value]) => [`EAuthMeCardClass_${key}`, value]));
+  const inverted = Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
+  return {
+    toServer(clientEnum) {
+      return map[clientEnum];
+    },
+    toClient(serverEnum) {
+      return inverted[serverEnum];
+    }
+  };
+})();
+
+function init(type, country, needConfirm) {
+  const body = {
+    scanType: type === exports.IdRecognitionCardType.Passport ? type : `${country}_${type}`,
+    cardTypes: getCardSubTypes(type).map(c => twoWayAuthmeCardClassMap.toServer(c)),
+    needConfirm
+  };
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/init-scan', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function initScanDocument(scanId, cardType) {
+  const body = {
+    scanId,
+    cardType
+  };
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/init-scan-doc', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function recognition(documentId, file) {
+  const formData = new FormData();
+  formData.append('scanDocumentId', documentId);
+  formData.append('image', file);
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/recognize', 'POST', {
+    body: formData,
+    contentType: 'multipart/form-data'
+  }).catch(error => {
+    var _a, _b, _c;
+    if (error instanceof core.AuthmeError && ((_c = (_b = (_a = error.cause) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.code) === 'AuthMe.IDRecognition:000201') {
+      return {
+        retry: true,
+        details: {}
+      };
+    }
+    throw error;
+  });
+}
+function saveResourceImage(documentId, type, file) {
+  const formData = new FormData();
+  formData.append('scanDocumentId', documentId);
+  formData.append('type', type);
+  formData.append('image', file);
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/upload-image', 'POST', {
+    body: formData,
+    contentType: 'multipart/form-data'
+  });
+}
+function finishScanDocument(documentId, details, fraud) {
+  const body = {
+    scanDocumentId: documentId,
+    details,
+    fraud
+  };
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/finish-scan-doc', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function confirmScan(scanId, details) {
+  const body = {
+    scanId,
+    details
+  };
+  return core.sendRequest('/api/identity-verification/id-recognition/v3/confirm-scan', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+
+var name = "@authme/id-recognition";
+var version$1 = "2.2.1-rc.3";
+var peerDependencies = {
+	"core-js": "^3.6.0"
+};
+var packageInfo = {
+	name: name,
+	version: version$1,
+	peerDependencies: peerDependencies
+};
+
+var _a;
+var _b, _c;
+const version = packageInfo.version;
+(_a = (_b = window)[_c = Symbol.for('authme-sdk')]) !== null && _a !== void 0 ? _a : _b[_c] = {};
+window[Symbol.for('authme-sdk')][packageInfo.name] = version;
+
+Object.defineProperty(exports, 'EAuthMeCardClass', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeCardClass; }
+});
+Object.defineProperty(exports, 'EAuthMeCardMatchStatus', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeCardMatchStatus; }
+});
+Object.defineProperty(exports, 'EAuthMeCardOCRStatus', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeCardOCRStatus; }
+});
+Object.defineProperty(exports, 'EAuthMeIDCardAntiFraudStage', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeIDCardAntiFraudStage; }
+});
+Object.defineProperty(exports, 'EAuthMeIDCardAntiFraudStatus', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeIDCardAntiFraudStatus; }
+});
+Object.defineProperty(exports, 'EAuthMeMRZRecogStatus', {
+  enumerable: true,
+  get: function () { return engine.EAuthMeMRZRecogStatus; }
+});
+Object.defineProperty(exports, 'EAuthMePassportServiceStatus', {
+  enumerable: true,
+  get: function () { return engine.EAuthMePassportServiceStatus; }
+});
+exports.CardOCR = CardOCR;
+exports.IdCardAntiFraudService = IdCardAntiFraudService;
+exports.IdTypeConfig = IdTypeConfig;
+exports.MRZService = MRZService;
+exports.confirmScan = confirmScan;
+exports.finishScanDocument = finishScanDocument;
+exports.getCardSubTypes = getCardSubTypes;
+exports.getRecognitionColumnOrder = getRecognitionColumnOrder;
+exports.init = init;
+exports.initScanDocument = initScanDocument;
+exports.recognition = recognition;
+exports.saveResourceImage = saveResourceImage;
+exports.twoWayAuthmeCardClassMap = twoWayAuthmeCardClassMap;
+exports.version = version;

package/index.js

@@ -0,0 +1,219 @@
+import { AuthmeEngineModuleBase, EAuthMeCardClass, EngineModule } from '@authme/engine';
+export { EAuthMeCardClass, EAuthMeCardMatchStatus, EAuthMeCardOCRStatus, EAuthMeIDCardAntiFraudStage, EAuthMeIDCardAntiFraudStatus, EAuthMeMRZRecogStatus, EAuthMePassportServiceStatus } from '@authme/engine';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.from-entries.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { sendRequest, AuthmeError } from '@authme/core';
+import 'core-js/modules/es.symbol.description.js';
+
+var ResourceImageType;
+(function (ResourceImageType) {
+  ResourceImageType["Recognition"] = "Recognition";
+  ResourceImageType["Fraud"] = "Fraud";
+  ResourceImageType["Manual"] = "Manual";
+})(ResourceImageType || (ResourceImageType = {}));
+var CountryCode;
+(function (CountryCode) {
+  CountryCode["TWN"] = "TWN";
+})(CountryCode || (CountryCode = {}));
+var IdRecognitionCardType;
+(function (IdRecognitionCardType) {
+  IdRecognitionCardType["IDCard"] = "IDCard";
+  IdRecognitionCardType["DriverLicense"] = "DriverLicense";
+  IdRecognitionCardType["HealthCard"] = "HealthCard";
+  IdRecognitionCardType["ResidentCard"] = "ResidentCard";
+  IdRecognitionCardType["Passport"] = "Passport";
+})(IdRecognitionCardType || (IdRecognitionCardType = {}));
+var ServerSideEAuthMeCardClass;
+(function (ServerSideEAuthMeCardClass) {
+  ServerSideEAuthMeCardClass["Invalid"] = "Invalid";
+  ServerSideEAuthMeCardClass["Unknown"] = "UnknownCard";
+  ServerSideEAuthMeCardClass["Passport"] = "Passport";
+  ServerSideEAuthMeCardClass["TWN_IDCard_Front"] = "TWN_IDCard_Front";
+  ServerSideEAuthMeCardClass["TWN_IDCard_Back"] = "TWN_IDCard_Back";
+  ServerSideEAuthMeCardClass["TWN_DriverLicense_Front"] = "TWN_DriverLicense_Front";
+  ServerSideEAuthMeCardClass["TWN_DriverLicense_Back"] = "TWN_DriverLicense_Back";
+  ServerSideEAuthMeCardClass["TWN_ResidentCard_Front"] = "TWN_ResidentCard_Front";
+  ServerSideEAuthMeCardClass["TWN_ResidentCard_Back"] = "TWN_ResidentCard_Back";
+  ServerSideEAuthMeCardClass["TWN_HealthCard_Front"] = "TWN_HealthCard_Front";
+  ServerSideEAuthMeCardClass["TWN_VehiclesLicense_Front"] = "TWN_VehiclesLicense_Front";
+})(ServerSideEAuthMeCardClass || (ServerSideEAuthMeCardClass = {}));
+
+class CardOCR extends AuthmeEngineModuleBase {
+  constructor(engine) {
+    super(engine);
+    this.type = EAuthMeCardClass.Invalid;
+    this.moduleName = EngineModule.CardOCR;
+  }
+  setType(type) {
+    this.type = type;
+    return this.engine.run(this.moduleName, 'setType', {
+      type
+    });
+  }
+  getType() {
+    return this.type;
+  }
+}
+class IdCardAntiFraudService extends AuthmeEngineModuleBase {
+  constructor(engine) {
+    super(engine);
+    this.moduleName = EngineModule.IdCardAntiFraud;
+  }
+  setStage(stageList) {
+    const stageStrList = stageList.map(x => x.split('_')[1]);
+    return this.engine.run(this.moduleName, 'setStage', stageStrList);
+  }
+}
+class MRZService extends AuthmeEngineModuleBase {
+  constructor(engine) {
+    super(engine);
+    this.moduleName = EngineModule.PassportService;
+  }
+  getFinalResult() {
+    return this.engine.run(this.moduleName, 'getFinalResult');
+  }
+  toJson(params) {
+    return this.engine.run(this.moduleName, 'toJson', params);
+  }
+}
+
+var IdType;
+(function (IdType) {
+  IdType["IdCard"] = "IDCard";
+  IdType["DriverLicense"] = "DriverLicense";
+  IdType["HealthCard"] = "HealthCard";
+  IdType["Passport"] = "Passport";
+})(IdType || (IdType = {}));
+const IdTypeConfig = {
+  [IdType.IdCard]: {
+    front: true,
+    back: true
+  },
+  [IdType.Passport]: {
+    front: true,
+    back: true
+  },
+  [IdType.HealthCard]: {
+    front: true,
+    back: false
+  },
+  [IdType.DriverLicense]: {
+    front: true,
+    back: true
+  }
+};
+
+const CardTypeMapping = {
+  [IdRecognitionCardType.IDCard]: [EAuthMeCardClass.TWN_IDCard_Front, EAuthMeCardClass.TWN_IDCard_Back],
+  [IdRecognitionCardType.HealthCard]: [EAuthMeCardClass.TWN_HealthCard_Front],
+  [IdRecognitionCardType.Passport]: [EAuthMeCardClass.Passport],
+  [IdRecognitionCardType.ResidentCard]: [EAuthMeCardClass.TWN_ResidentCard_Front, EAuthMeCardClass.TWN_ResidentCard_Back],
+  [IdRecognitionCardType.DriverLicense]: [EAuthMeCardClass.TWN_DriverLicense_Front, EAuthMeCardClass.TWN_DriverLicense_Back]
+};
+const RECOGNITION_COLUMNS_ORDER = Object.fromEntries(['surname', 'givenName', 'name', 'gender', 'dateOfBirth', 'idNumber', 'dateOfIssue', 'issueCity', 'issueReason', 'father', 'mother', 'spouse', 'militaryService', 'placeOfBirth', 'serialNumber', 'expiry', 'controlNo', 'type', 'condition', 'address', 'country', 'documentNumber', 'documentType', 'nationality', 'expiryDate'].map((value, index) => [value, index]));
+function getCardSubTypes(type, country) {
+  return CardTypeMapping[type];
+}
+function getRecognitionColumnOrder(column) {
+  var _a;
+  return (_a = RECOGNITION_COLUMNS_ORDER[column]) !== null && _a !== void 0 ? _a : Number.MAX_VALUE;
+}
+const twoWayAuthmeCardClassMap = (() => {
+  const map = Object.fromEntries(Object.entries(ServerSideEAuthMeCardClass).map(([key, value]) => [`EAuthMeCardClass_${key}`, value]));
+  const inverted = Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
+  return {
+    toServer(clientEnum) {
+      return map[clientEnum];
+    },
+    toClient(serverEnum) {
+      return inverted[serverEnum];
+    }
+  };
+})();
+
+function init(type, country, needConfirm) {
+  const body = {
+    scanType: type === IdRecognitionCardType.Passport ? type : `${country}_${type}`,
+    cardTypes: getCardSubTypes(type).map(c => twoWayAuthmeCardClassMap.toServer(c)),
+    needConfirm
+  };
+  return sendRequest('/api/identity-verification/id-recognition/v3/init-scan', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function initScanDocument(scanId, cardType) {
+  const body = {
+    scanId,
+    cardType
+  };
+  return sendRequest('/api/identity-verification/id-recognition/v3/init-scan-doc', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function recognition(documentId, file) {
+  const formData = new FormData();
+  formData.append('scanDocumentId', documentId);
+  formData.append('image', file);
+  return sendRequest('/api/identity-verification/id-recognition/v3/recognize', 'POST', {
+    body: formData,
+    contentType: 'multipart/form-data'
+  }).catch(error => {
+    var _a, _b, _c;
+    if (error instanceof AuthmeError && ((_c = (_b = (_a = error.cause) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.code) === 'AuthMe.IDRecognition:000201') {
+      return {
+        retry: true,
+        details: {}
+      };
+    }
+    throw error;
+  });
+}
+function saveResourceImage(documentId, type, file) {
+  const formData = new FormData();
+  formData.append('scanDocumentId', documentId);
+  formData.append('type', type);
+  formData.append('image', file);
+  return sendRequest('/api/identity-verification/id-recognition/v3/upload-image', 'POST', {
+    body: formData,
+    contentType: 'multipart/form-data'
+  });
+}
+function finishScanDocument(documentId, details, fraud) {
+  const body = {
+    scanDocumentId: documentId,
+    details,
+    fraud
+  };
+  return sendRequest('/api/identity-verification/id-recognition/v3/finish-scan-doc', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+function confirmScan(scanId, details) {
+  const body = {
+    scanId,
+    details
+  };
+  return sendRequest('/api/identity-verification/id-recognition/v3/confirm-scan', 'POST', {
+    body: JSON.stringify(body)
+  });
+}
+
+var name = "@authme/id-recognition";
+var version$1 = "2.2.1-rc.3";
+var peerDependencies = {
+	"core-js": "^3.6.0"
+};
+var packageInfo = {
+	name: name,
+	version: version$1,
+	peerDependencies: peerDependencies
+};
+
+var _a;
+var _b, _c;
+const version = packageInfo.version;
+(_a = (_b = window)[_c = Symbol.for('authme-sdk')]) !== null && _a !== void 0 ? _a : _b[_c] = {};
+window[Symbol.for('authme-sdk')][packageInfo.name] = version;
+
+export { CardOCR, CountryCode, IdCardAntiFraudService, IdRecognitionCardType, IdType, IdTypeConfig, MRZService, ResourceImageType, ServerSideEAuthMeCardClass, confirmScan, finishScanDocument, getCardSubTypes, getRecognitionColumnOrder, init, initScanDocument, recognition, saveResourceImage, twoWayAuthmeCardClassMap, version };

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "@authme/id-recognition",
-  "version": "2.2.0",
-  "main": "./src/index.js",
-  "typings": "./src/index.d.ts",
-  "dependencies": {},
+  "version": "2.2.1-rc.3",
   "peerDependencies": {
-    "@authme/core": "2.2.0",
-    "@authme/util": "2.2.0",
-    "three": "^0.136.0",
-    "lottie-web": "^5.9.2",
-    "@authme/engine": "2.2.0",
-    "rxjs": "~7.4.0",
-    "tslib": "^2.3.0"
-  }
+    "core-js": "^3.6.0",
+    "@authme/core": "2.2.1-rc.3",
+    "@authme/engine": "2.2.1-rc.3"
+  },
+  "module": "./index.js",
+  "main": "./index.cjs",
+  "type": "module",
+  "types": "./src/index.d.ts",
+  "dependencies": {}
 }

package/src/index.d.ts

@@ -1,6 +1,7 @@
-export * from './lib/modules-id-recognition-feature-id-recognition';
-export * from './lib/model';
-export * from './lib/enum';
-export * from './lib/interface';
-export * from './lib/util';
-export * from './lib/data-access';
+export * from './lib/modules-id-recognition-feature-id-recognition';
+export * from './lib/model';
+export * from './lib/enum';
+export * from './lib/interface';
+export * from './lib/util';
+export * from './lib/data-access';
+export { version } from './lib/version';

package/src/lib/data-access/api.d.ts

@@ -1,19 +1,19 @@
-import { CountryCode, EAuthMeCardClass, IdRecognitionCardType, ResourceImageType } from '../enum';
-import { InitScanResponse } from '../model';
-export declare function init(type: IdRecognitionCardType, country: CountryCode, needConfirm: boolean): Promise<InitScanResponse>;
-export declare function initScanDocument(scanId: string, type: EAuthMeCardClass): Promise<{
-    scanDocumentId: string;
-}>;
-export declare function recognition(documentId: string, file: Blob): Promise<{
-    retry?: boolean;
-    details: {
-        [key: string]: string | null;
-    };
-}>;
-export declare function saveResourceImage(documentId: string, type: ResourceImageType, file: Blob): Promise<any>;
-export declare function finishScanDocument(documentId: string, details: {
-    [key: string]: string | null;
-}, fraud: boolean | null): Promise<any>;
-export declare function confirmScan(scanId: string, details: {
-    [key: string]: string | null;
-}): Promise<any>;
+import { CountryCode, IdRecognitionCardType, ResourceImageType, ServerSideEAuthMeCardClass } from '../enum';
+import { InitScanResponse } from '../model';
+export declare function init(type: IdRecognitionCardType, country: CountryCode, needConfirm: boolean): Promise<InitScanResponse>;
+export declare function initScanDocument(scanId: string, cardType: `${ServerSideEAuthMeCardClass}`): Promise<{
+    scanDocumentId: string;
+}>;
+export declare function recognition(documentId: string, file: Blob): Promise<{
+    retry?: boolean;
+    details: {
+        [key: string]: string | null;
+    };
+}>;
+export declare function saveResourceImage(documentId: string, type: ResourceImageType, file: Blob): Promise<any>;
+export declare function finishScanDocument(documentId: string, details: {
+    [key: string]: string | null;
+}, fraud: boolean | null): Promise<any>;
+export declare function confirmScan(scanId: string, details: {
+    [key: string]: string | null;
+}): Promise<any>;

package/src/lib/data-access/index.d.ts

@@ -1 +1 @@
-export * from './api';
+export * from './api';