@ekyc_qoobiss/qbs-ect-cmp 3.6.27 → 3.6.28

package/dist/collection/helpers/DeviceDetection.js

@@ -0,0 +1,85 @@
+import { Browser, DesktopOS, MobileOS } from '../models/IDevice';
+export class DeviceDetection {
+  constructor() {
+    var _a, _b, _c, _d;
+    this.supportedScreenOrientation = (_b = (_a = ((screen === null || screen === void 0 ? void 0 : screen.orientation) || {}).type) !== null && _a !== void 0 ? _a : screen.mozOrientation) !== null && _b !== void 0 ? _b : screen.msOrientation;
+    this.safariScreenOrientation = !(screen === null || screen === void 0 ? void 0 : screen.orientation) && matchMedia('(orientation: portrait)').matches ? 'portrait-primary' : 'landscape-primary';
+    this.initialScreenOrientation = (_d = (_c = this.supportedScreenOrientation) !== null && _c !== void 0 ? _c : this.safariScreenOrientation) !== null && _d !== void 0 ? _d : 'portrait-primary';
+    this.userAgent = navigator.userAgent || navigator.vendor || window.opera || undefined;
+    this.isMobile = this.isMobileDevice();
+    this.isTablet = this.isTabletDevice();
+    this.isDesktop = !this.isMobile && !this.isTablet;
+  }
+  // Device typology
+  isMobileDevice() {
+    const regexs = [/(Android)(.+)(Mobile)/i, /BlackBerry/i, /iPhone|iPod/i, /Opera Mini/i, /IEMobile/i];
+    return regexs.some(b => this.userAgent.match(b));
+  }
+  isTabletDevice() {
+    const regex = /(ipad|tablet|(android(?!.*mobile))|(windows(?!.*phone)(.*touch))|kindle|playbook|silk|(puffin(?!.*(IP|AP|WP))))/;
+    return regex.test(this.userAgent.toLowerCase());
+  }
+  // Device Operating System
+  getMobileOS() {
+    if (this.isMobileDevice()) {
+      if (/windows phone/i.test(this.userAgent))
+        return MobileOS.WindowsPhone;
+      else if (/android/i.test(this.userAgent))
+        return MobileOS.Android;
+      else if (/iPad|iPhone|iPod/.test(this.userAgent) && !window.MSStream)
+        return MobileOS.iOS;
+      return MobileOS.Unknown;
+    }
+    else
+      return undefined;
+  }
+  getDesktopOS() {
+    if (this.isDesktop) {
+      if (this.userAgent.indexOf('Win') !== -1)
+        return DesktopOS.Windows;
+      else if (this.userAgent.indexOf('Mac') !== -1)
+        return DesktopOS.MacOS;
+      else if (this.userAgent.indexOf('X11') !== -1)
+        return DesktopOS.Unix;
+      else if (this.userAgent.indexOf('Linux') !== -1)
+        return DesktopOS.Linux;
+      return DesktopOS.Unknown;
+    }
+    else
+      return undefined;
+  }
+  getDeviceOS() {
+    var _a;
+    return (_a = this.getMobileOS()) !== null && _a !== void 0 ? _a : this.getDesktopOS();
+  }
+  getBrowser() {
+    if (/XiaoMi/i.test(this.userAgent) || /MiuiBrowser/i.test(this.userAgent))
+      return Browser.Mi;
+    var isChrome = /chrome/i.test(this.userAgent);
+    if (isChrome)
+      return Browser.Chrome;
+    if (/firefox/i.test(navigator.userAgent))
+      return Browser.Firefox;
+    else if (!isChrome && /safari/i.test(navigator.userAgent))
+      return Browser.Safari;
+    else
+      return Browser.Unknown;
+  }
+  getDevice() {
+    var device = {
+      isDesktop: this.isDesktop,
+      desktopOS: this.getDesktopOS(),
+      isWindowsDesktop: this.getDeviceOS() === DesktopOS.Windows,
+      isLinuxOrUnixDesktop: this.getDeviceOS() === DesktopOS.Linux || this.getDeviceOS() === DesktopOS.Unix,
+      isMobile: this.isMobile,
+      mobileOS: this.getMobileOS(),
+      isAndroidDevice: this.getDeviceOS() === MobileOS.Android,
+      isAppleDevice: this.getDeviceOS() === MobileOS.iOS || this.getDeviceOS() === DesktopOS.MacOS,
+      isUnknownMobileDevice: this.getDeviceOS() === MobileOS.Unknown,
+      browser: this.getBrowser(),
+      isTablet: this.isTablet,
+      initialScreenOrientation: this.initialScreenOrientation,
+    };
+    return device;
+  }
+}

package/dist/collection/helpers/Events.js

@@ -0,0 +1,58 @@
+export default class Events {
+  static init(element) {
+    this.callingModule = element;
+  }
+  static flowEvent(step, moment) {
+    const eventName = `ect-${step.toString()}-${moment.toString()}-event`;
+    this.callingModule.dispatchEvent(new CustomEvent(eventName, {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static flowStarted() {
+    this.callingModule.dispatchEvent(new CustomEvent('ect-started', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static flowAborted() {
+    sessionStorage.clear();
+    this.callingModule.dispatchEvent(new CustomEvent('ect-aborted', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static flowCompleted() {
+    sessionStorage.clear();
+    this.callingModule.dispatchEvent(new CustomEvent('ect-completed', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static flowError(error) {
+    sessionStorage.clear();
+    this.callingModule.dispatchEvent(new CustomEvent('ect-error', {
+      detail: { error },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static tokenExpired() {
+    sessionStorage.clear();
+    this.callingModule.dispatchEvent(new CustomEvent('ect-session-expired', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+}

package/dist/collection/helpers/ML5.js

@@ -0,0 +1,38 @@
+import ml5 from 'ml5';
+import store from './store';
+// @ts-ignore
+import preload from '../assets/ml5-preload.png';
+export class ML5 {
+  static getInstance() {
+    if (!ML5.instance) {
+      ML5.instance = new ML5();
+    }
+    return ML5.instance;
+  }
+  constructor() {
+    this.init();
+  }
+  async init() {
+    return new Promise(async (resolve) => {
+      const modelPath = store.hasIdBack ? 'https://ekyc.blob.core.windows.net/$web/md/model.json' : 'https://ekyc.blob.core.windows.net/$web/model.json';
+      this.classifier = await ml5.imageClassifier(modelPath, this.loaded);
+      this.faceapi = await ml5.faceApi({ withLandmarks: true, withDescriptors: false }, this.loaded);
+      //warmup
+      const img = new Image();
+      img.src = preload;
+      this.classifier.classify(img, this.gotResults);
+      this.faceapi.detect(img, this.gotResults);
+      resolve();
+    });
+  }
+  loaded() {
+    if (store.debug)
+      console.log('ML5 LOADED!!!');
+  }
+  gotResults(error, results) {
+    if (store.debug)
+      console.log(error);
+    if (store.debug)
+      console.log(results);
+  }
+}

package/dist/collection/helpers/Stream.js

@@ -0,0 +1,229 @@
+import { IDML5Detector } from '../libs/IDML5Detector/IDML5Detector';
+import { FaceML5Detector } from '../libs/FaceML5Detector/FaceML5Detector';
+import { FacePose } from '../libs/FaceML5Detector/FacePose';
+import { FacePosePick } from '../libs/FaceML5Detector/FacePose';
+import { addExifInImg } from './security';
+import store from './store';
+import { Browser, MobileOS } from '../models/IDevice';
+var ImageFormat;
+(function (ImageFormat) {
+  ImageFormat["JPEG"] = "image/jpeg";
+  ImageFormat["PNG"] = "image/png";
+})(ImageFormat || (ImageFormat = {}));
+export class Stream {
+  setFaceDetection(val) {
+    this.faceDetection = val;
+    this.idDetection = !val;
+  }
+  setIdDetection(val) {
+    this.idDetection = val;
+    this.faceDetection = !val;
+  }
+  // public setProbabilityThreshold(val: number): void {
+  //   Detector.getInstance().setProbabilityThreshold(val);
+  // }
+  setCallbackChangeTitle(fun) {
+    this.callbackChangeTitle = fun;
+  }
+  setCallbackVideoStarted(fun) {
+    this.callbackVideoStarted = fun;
+  }
+  setCallbackErrors(fun) {
+    this.callbackErrors = fun;
+  }
+  setCallbackAutoCapturing(fun) {
+    this.callbackAutoCapturing = fun;
+  }
+  // public setCallbackFaceDetectionErrors(fun: (e: PipelineResult) => void): void {
+  //   this.callbackFaceDetectionErrors = fun;
+  // }
+  setCallbackRecordingReady(fun) {
+    this.callbackRecordingReady = fun;
+  }
+  setCallbackTimeElapsed(fun) {
+    this.callbackTimeElapsed = fun;
+  }
+  setVerificationFinished(fun) {
+    this.verificationFinished = fun;
+  }
+  constructor(mode) {
+    this.streamPaused = false;
+    this.recordedChunks = [];
+    this.videoSize = { width: 0, height: 0 };
+    this.pauseStream = () => {
+      this.streamPaused = true;
+      this.mediaRecorder.pause();
+      this.videoElement.pause();
+      // this.dropMask();
+      // if (this.faceDetection) Detector.getInstance().stopDetector();
+    };
+    this.initFacePose();
+    this.idML5Detector = IDML5Detector.getInstance(this, store.device.isMobile);
+    this.faceML5Detector = FaceML5Detector.getInstance(this, store.device.isMobile);
+    this.verificationMode = mode;
+  }
+  static getInstance(mode) {
+    if (!Stream.instance) {
+      Stream.instance = new Stream(mode);
+    }
+    return Stream.instance;
+  }
+  // public returnErrors(errors: PipelineResult) {
+  //   this.callbackFaceDetectionErrors(errors);
+  // }
+  autoCapturing() {
+    this.callbackAutoCapturing();
+  }
+  timeElapsed() {
+    this.callbackTimeElapsed();
+  }
+  verificationReady() {
+    this.verificationFinished();
+  }
+  updateHtmlElements(videoElement, canvasElement, component) {
+    this.videoElement = videoElement;
+    this.canvasElement = canvasElement;
+    this.idML5Detector.updateHtmlElements(this.videoElement, this.canvasElement, component);
+    this.faceML5Detector.updateHtmlElements(this.videoElement, this.canvasElement, component);
+  }
+  static orientationChange() { }
+  startStream(stream) {
+    if (this.stream)
+      this.stream.getTracks().forEach((track) => track.stop());
+    this.stream = stream;
+    if (!this.videoElement || this.videoElement == null) {
+      return;
+    }
+    if ('srcObject' in this.videoElement) {
+      this.videoElement.srcObject = stream;
+    }
+    else {
+      // @ts-ignore
+      this.videoElement.src = window.URL.createObjectURL(stream);
+    }
+    this.videoElement.addEventListener('loadedmetadata', async (_e) => {
+      this.videoElement.play().then(() => {
+        this.streamPaused = false;
+        this.updateCanvasSize(this.canvasElement);
+        this.updateVideoSize(this.videoElement);
+        this.callbackVideoStarted();
+        if (this.idDetection)
+          this.startIdDetection();
+        if (this.faceDetection)
+          this.startFaceDetection();
+      });
+    }, false);
+  }
+  async initStream(stream) {
+    this.startStream(stream);
+    this.recordStream();
+  }
+  async resumeStream() {
+    this.streamPaused = false;
+    this.mediaRecorder.resume();
+    await this.videoElement.play();
+    // this.drawMask();
+    // if (this.faceDetection) await Detector.getInstance().startDetector();
+  }
+  recordStream() {
+    if (this.mediaRecorder && this.mediaRecorder.state == 'recording')
+      return;
+    var options = { mimeType: Stream.webmMimeType.mime, videoBitsPerSecond: 1500000 };
+    if (!MediaRecorder.isTypeSupported(options.mimeType)) {
+      if (store.device.mobileOS == MobileOS.iOS || store.device.browser == Browser.Safari)
+        options.mimeType = Stream.mp4MimeType.mime;
+    }
+    this.recordedChunks = [];
+    this.mediaRecorder = new MediaRecorder(this.stream, options);
+    this.mediaRecorder.ondataavailable = event => {
+      this.recordedChunks.push(event.data);
+    };
+    this.mediaRecorder.onstop = _e => {
+      var rec = new Blob(this.recordedChunks, {
+        type: options.mimeType.split(';')[0],
+      });
+      this.callbackRecordingReady(rec);
+    };
+    this.mediaRecorder.start(); // Start recording, and dump data every second
+  }
+  updateCanvasSize(canvas) {
+    this.videoSize = { width: this.videoElement.videoWidth, height: this.videoElement.videoHeight };
+    canvas.width = this.videoSize.width;
+    canvas.height = this.videoSize.height;
+  }
+  updateVideoSize(video) {
+    this.videoSize = { width: this.videoElement.videoWidth, height: this.videoElement.videoHeight };
+    video.width = this.videoSize.width;
+    video.height = this.videoSize.height;
+  }
+  dropStream() {
+    if (!this.streamStopped()) {
+      this.stream.getTracks().forEach((track) => track.stop());
+      this.videoElement.srcObject = null;
+    }
+    if (this.mediaRecorder && this.mediaRecorder.state != 'inactive') {
+      this.mediaRecorder.stop();
+    }
+    // if (this.faceDetection) Detector.getInstance().stopDetector();
+  }
+  streamStopped() {
+    return !(this.stream && this.stream.getTracks && this.stream.getTracks().length > 0);
+  }
+  async takePhoto() {
+    const canvas = document.createElement('canvas');
+    canvas.style.visibility = 'hidden';
+    canvas.width = this.videoElement.videoWidth;
+    canvas.height = this.videoElement.videoHeight;
+    return await this.getFrame(canvas);
+  }
+  getFrame(canvas) {
+    return new Promise(resolve => {
+      const context = canvas.getContext('2d');
+      context.drawImage(this.videoElement, 0, 0, canvas.width, canvas.height);
+      canvas.toBlob((frame) => {
+        if (frame.type === ImageFormat.JPEG && !store.device.isAppleDevice) {
+          try {
+            addExifInImg(frame, this.stream.getTracks()[0], this.videoSize).then(updatedFrame => resolve(updatedFrame));
+          }
+          catch (e) {
+            resolve(frame);
+            this.callbackErrors(e, false);
+          }
+        }
+        else {
+          resolve(frame);
+        }
+      }, ImageFormat.PNG, 1);
+      //let outCanvContext = this.canvasElement.getContext('2d');
+      //outCanvContext.drawImage(this.videoElement, 0, 0, this.canvasElement.width, this.canvasElement.height);
+    });
+  }
+  async startIdDetection() {
+    if (this.streamPaused)
+      return;
+    this.idML5Detector.initDetector(this.verificationMode);
+  }
+  async startFaceDetection() {
+    if (this.streamPaused)
+      return;
+    this.faceML5Detector.initDetector(this.verificationMode);
+  }
+  initFacePose() {
+    this.facePose = FacePosePick.randomEnum(FacePose);
+  }
+  requestFacePose() {
+    // var pose = FacePose.TiltLeft;
+    this.callbackChangeTitle(this.facePose);
+    return this.facePose;
+  }
+  changeFacePose() {
+    this.callbackChangeTitle(null);
+  }
+  changeIDPose(pose) {
+    this.callbackChangeTitle(pose);
+  }
+}
+Stream.mp4MimeType = { type: 'video/mp4', codec: 'codecs:h264', extension: 'mp4', mime: 'video/mp4;codecs:h264' };
+Stream.webmMimeType = { type: 'video/webm', codec: 'codecs=vp8', extension: 'webm', mime: 'video/webm;codecs=vp8' };
+window.addEventListener('resize', Stream.orientationChange, false);
+window.addEventListener('orientationchange', Stream.orientationChange, false);

package/dist/collection/helpers/TranslationUtils.js

@@ -0,0 +1,37 @@
+import store from './store';
+class TranslationsController {
+  async getValues() {
+    if (this.values) {
+      return this.values;
+    }
+    else {
+      this.values = await this.fetchTranslations();
+      return this.values;
+    }
+  }
+  getLocale(element = document.body) {
+    const closestElement = element.closest('[lang]');
+    return closestElement ? closestElement.lang : store.langIso;
+  }
+  async fetchTranslations() {
+    const locale = this.getLocale();
+    const existingTranslations = JSON.parse(sessionStorage.getItem(`i18n.${locale}`));
+    if (existingTranslations && Object.keys(existingTranslations).length > 0) {
+      return existingTranslations;
+    }
+    else {
+      try {
+        const result = await fetch(`/i18n/${locale}.json`);
+        if (result.ok) {
+          const data = await result.json();
+          sessionStorage.setItem(`i18n.${locale}`, JSON.stringify(data));
+          return data;
+        }
+      }
+      catch (exception) {
+        console.error(`Error loading locale: ${locale}`, exception);
+      }
+    }
+  }
+}
+export const Translations = new TranslationsController();

package/dist/collection/helpers/canvas.js

@@ -0,0 +1,10 @@
+export function videoRatio(videoElement) {
+  const hRatio = videoElement.clientWidth / videoElement.videoWidth;
+  const vRatio = videoElement.clientHeight / videoElement.videoHeight;
+  return Math.min(hRatio, vRatio);
+}
+export function getVideoRatio(videoElement) {
+  const hRatio = videoElement.clientWidth / videoElement.videoWidth;
+  const vRatio = videoElement.clientHeight / videoElement.videoHeight;
+  return Math.min(hRatio, vRatio);
+}

package/dist/collection/helpers/index.js

@@ -0,0 +1,21 @@
+export const convertToDataUrl = async (file) => {
+  return new Promise(async (resolve) => {
+    let arr = [];
+    for (let i = 0; i < file.length; i++) {
+      const fr = new FileReader();
+      fr.onload = () => {
+        arr.push(fr.result);
+        if (arr.length === file.length)
+          resolve(arr);
+      };
+      fr.readAsDataURL(file[i]);
+    }
+  });
+};
+export const blobToBase64 = (blob) => {
+  return new Promise((resolve, _) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.readAsDataURL(blob);
+  });
+};

package/dist/collection/helpers/security.js

@@ -0,0 +1,25 @@
+import { blobToBase64 } from '../utils/utils';
+import * as piexif from 'piexifjs';
+export const addExifInImg = async (blob, track, videoSize) => {
+  const base64 = await blobToBase64(blob);
+  const exif = piexif.load(base64);
+  const devices = await navigator.mediaDevices.enumerateDevices();
+  const cameraNames = devices.filter(device => device.kind === 'videoinput').map(device => device.label);
+  const json = {
+    width: videoSize.width,
+    height: videoSize.height,
+    usedCamera: track.label,
+    camerasOnDevice: cameraNames,
+  };
+  const newExif = {
+    '0th': Object.assign(Object.assign({}, exif['0th']), { [piexif.ImageIFD.Model]: json.usedCamera, [piexif.ImageIFD.ImageWidth]: json.width, [piexif.ImageIFD.ImageLength]: json.height }),
+    'Exif': Object.assign(Object.assign({}, exif['Exif']), { [piexif.ExifIFD.UserComment]: JSON.stringify(json) }),
+    'GPS': Object.assign({}, exif['GPS']),
+    'Interop': Object.assign({}, exif['Interop']),
+    '1st': Object.assign({}, exif['1st']),
+    'thumbnail': exif['thumbnail'],
+  };
+  const newExifBinary = piexif.dump(newExif);
+  const newPhotoData = piexif.insert(newExifBinary, base64);
+  return await fetch(newPhotoData).then(res => res.blob());
+};

package/dist/collection/helpers/store.js

@@ -0,0 +1,48 @@
+import { createStore } from '@stencil/store';
+import { FlowStatus } from '../models/FlowStatus';
+import { SessionKeys } from './textValues';
+const { state, onChange } = createStore({
+  flowStatus: FlowStatus.NONE,
+  environment: 'PROD',
+  debug: false,
+  requestId: '',
+  redirectId: '',
+  initialised: false,
+  token: '',
+  cameraIds: [],
+  cameraId: '',
+  hasIdBack: false,
+  hasSelfieGesture: false,
+  hasIdTilt: false,
+  agreementsValidation: true,
+  phoneValidation: true,
+  phoneNumber: '',
+  apiBaseUrl: 'https://apiro.id-kyc.com',
+  device: null,
+  langIso: 'ro',
+});
+onChange('environment', value => {
+  state.debug = value == 'QA';
+});
+onChange('flowStatus', value => {
+  sessionStorage.setItem(SessionKeys.FlowStatusKey, FlowStatus[value]);
+});
+onChange('token', value => {
+  sessionStorage.setItem(SessionKeys.TokenKey, value);
+});
+onChange('requestId', value => {
+  sessionStorage.setItem(SessionKeys.RequestIdKey, value);
+});
+onChange('initialised', value => {
+  sessionStorage.setItem(SessionKeys.InitialisedKey, String(value));
+});
+onChange('hasIdBack', value => {
+  sessionStorage.setItem(SessionKeys.HasIdBackKey, String(value));
+});
+onChange('agreementsValidation', value => {
+  sessionStorage.setItem(SessionKeys.AgreementValidationKey, String(value));
+});
+onChange('phoneValidation', value => {
+  sessionStorage.setItem(SessionKeys.PhoneValidationKey, String(value));
+});
+export default state;

package/dist/collection/helpers/textValues.js

@@ -0,0 +1,48 @@
+import store from './store';
+export class IdCaptureValues {
+}
+IdCaptureValues.IDPoseDemoMapping = {
+  0: 'https://ekyc.blob.core.windows.net/$web/animations/id/id_front.mp4',
+  1: 'https://ekyc.blob.core.windows.net/$web/animations/id/id_front_tilt.mp4',
+  2: 'https://ekyc.blob.core.windows.net/$web/animations/id/id_rotate.mp4',
+  3: 'https://ekyc.blob.core.windows.net/$web/animations/id/id_back.mp4',
+  4: 'https://ekyc.blob.core.windows.net/$web/animations/id/id_back_tilt.mp4',
+};
+export class SelfieCaptureValues {
+}
+SelfieCaptureValues.FacePoseDemoMapping = {
+  0: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_rotate_left.mp4',
+  1: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_rotate_right.mp4',
+  2: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_tilt_back.mp4',
+  3: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_tilt_front.mp4',
+  // 4: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_tilt_left.mp4',
+  // 5: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_tilt_right.mp4',
+  4: 'https://ekyc.blob.core.windows.net/$web/animations/selfie/selfie_main.mp4',
+};
+export class SessionKeys {
+}
+SessionKeys.FlowStatusKey = 'qbs-ect-flowstatus';
+SessionKeys.RequestIdKey = 'qbs-ect-requestid';
+SessionKeys.TokenKey = 'qbs-ect-token';
+SessionKeys.InitialisedKey = 'qbs-ect-initialised';
+SessionKeys.HasIdBackKey = 'qbs-ect-has-id-back';
+SessionKeys.AgreementValidationKey = 'qbs-ect-agreement-validation';
+SessionKeys.PhoneValidationKey = 'qbs-ect-phone-validation';
+SessionKeys.RefreshDoneKey = 'qbs-ect-refresh-done';
+export class ApiUrls {
+  constructor() {
+    this.uriEnv = '/';
+    this.uriEnv = store.environment == 'QA' ? '/dev_' : '/';
+    this.OtpSend = this.uriEnv + 'validation/otp/send';
+    this.OtpCheck = this.uriEnv + 'validation/otp/check';
+    this.IdentityInsert = this.uriEnv + 'validation/identity/insert';
+    this.UploadCapture = this.uriEnv + 'validation/upload/capture';
+    this.GetAgreement = this.uriEnv + 'validation/agreement/content';
+    this.GenerateAgreement = this.uriEnv + 'validation/agreement/generate';
+    this.SendLink = this.uriEnv + 'validation/otp/sendlink';
+    this.GetStatus = this.uriEnv + 'validation/identity/status';
+    this.AddLog = this.uriEnv + 'validation/logs/add';
+    this.AddStep = this.uriEnv + 'validation/logs/step';
+    this.AbortRequest = this.uriEnv + 'validation/identity/abort';
+  }
+}

package/dist/collection/index.js

@@ -0,0 +1 @@
+export {};