@idscan/idvc2 2.6.0 → 2.6.2

package/dist/types/environment/langs.d.ts

@@ -0,0 +1,89 @@
+import { CameraNotSupportedReason } from '../types/modules/camera.enum';
+type LabelGroup = 'errorCodes' | 'hintTexts' | 'keyErrors' | 'camera' | 'general' | 'uploaderDescription' | 'documentsTypes' | 'spinnerText';
+type AllTypes = IErrorCodes | IHintTexts | KeyError | ICameraLabels | IGeneral | IDocumentsTypes | IUploaderDescription | ISpinnerText;
+type Label = Record<LabelGroup, AllTypes>;
+type KeyError = string[];
+type GetTranslation = {
+    (): Label;
+    (groupName: 'errorCodes'): IErrorCodes;
+    (groupName: 'hintTexts'): IHintTexts;
+    (groupName: 'keyErrors'): KeyError;
+    (groupName: 'camera'): ICameraLabels;
+    (groupName: 'general'): IGeneral;
+    (groupName: 'spinnerText'): ISpinnerText;
+    (groupName: LabelGroup): AllTypes;
+};
+export type ErrorCodeNames = 'mrzNotFound' | 'mrzNotRecognized' | 'barcodeNotFound' | 'barcodeNotRecognized' | 'heic' | 'fileType' | 'fileTypeHeic' | 'faceNotFound' | 'disableStepFileUpload' | 'notAllowedDocument' | 'documentSideLowPerimeter' | 'frontSideNotDetected' | 'backSideNotDetected' | 'default' | 'lowImageResolution' | 'imageIsBlurred' | 'faceLowArea' | keyof typeof CameraNotSupportedReason;
+export type SupportedLanguage = typeof supportedLanguages[number];
+type IErrorCodes = Record<ErrorCodeNames, string>;
+interface IHintTexts {
+    front: string;
+    frontMRZ: string;
+    mrz: string;
+    capturing: string;
+    pdf: string;
+    back: string;
+    barcode: string;
+    hold: string;
+    dontSee: string;
+    dontMove: string;
+    turnFaceLeft: string;
+    turnFaceRight: string;
+    turnFaceUp: string;
+    turnFaceDown: string;
+    faceCam: string;
+    camAway: string;
+    moveCenter: string;
+    comeCloser: string;
+    documentCloser: string;
+    holdCamera: string;
+}
+interface ICameraLabels {
+    loading: string;
+    awaiting: string;
+}
+interface IGeneral {
+    documentType: string;
+    selectDocumentTypeText: string;
+    changeBtn: string;
+    correctBtn: string;
+    cancelBtn: string;
+    doneBtn: string;
+    closeBtn: string;
+    retakeBtn: string;
+    continueBtn: string;
+    submitBtn: string;
+    resetAllStepsBtn: string;
+    btnUploader: string;
+    btnCamera: string;
+    pressToUpdateText: string;
+    pressToUpdateTextSuccess: string;
+}
+interface IDocumentsTypes {
+    ID: string;
+    Passport: string;
+    PassportCard: string;
+    GreenCard: string;
+    InternationalId: string;
+}
+interface IUploaderDescription {
+    textFront: string;
+    textBack: string;
+    textFace: string;
+    textPdf: string;
+    textMrz: string;
+    textFrontBack: string;
+    textPass: string;
+    textFacePosition: string;
+}
+interface ISpinnerText {
+    warmup: {
+        top: string;
+        bottom: string;
+    };
+}
+export type CameraLabels = keyof ICameraLabels;
+export declare const supportedLanguages: readonly ["en", "es"];
+export declare const setTranslation: (translationLang?: SupportedLanguage) => void;
+export declare const getTranslation: GetTranslation;
+export {};

package/dist/types/environment/loopResult.d.ts

@@ -0,0 +1,8 @@
+export interface ILoopResult {
+    status: boolean;
+    cancel: boolean;
+    touch: boolean;
+    image: ImageData | null;
+}
+declare const defaultLoopResult: ILoopResult;
+export default defaultLoopResult;

package/dist/types/environment/modalPosition.d.ts

@@ -0,0 +1,19 @@
+export type ModalPositionKeys = keyof typeof modalPositions;
+export declare const modalPositions: {
+    center: {
+        description: string;
+    };
+    bottom: {
+        description: string;
+    };
+    top: {
+        description: string;
+    };
+    'sticky-top': {
+        description: string;
+    };
+    'sticky-bottom': {
+        description: string;
+    };
+};
+export declare const modalPositionClasses: Record<ModalPositionKeys, string>;

package/dist/types/environment/realFaceModes.d.ts

@@ -0,0 +1,22 @@
+export type RealFaceMode = keyof typeof realFaceModes;
+declare const realFaceModes: {
+    /**
+     * enable "realFaceMode" only for iphone.
+     */
+    readonly auto: {
+        readonly description: "enable \"realFaceMode\" only for iphone.";
+    };
+    /**
+     * disable this option.
+     */
+    readonly none: {
+        readonly description: "disable this option.";
+    };
+    /**
+     * enable "realFaceMode" for all devices.
+     */
+    readonly all: {
+        readonly description: "enable \"realFaceMode\" for all devices.";
+    };
+};
+export default realFaceModes;

package/dist/types/environment/stepsDescription.d.ts

@@ -0,0 +1,62 @@
+export type StepType = 'mrz' | 'front' | 'pdf' | 'face' | 'barcode' | 'photo' | 'back';
+declare const _default: {
+    mrz: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        core: string[];
+        description: string;
+    };
+    front: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        max: number;
+        core: string[];
+        description: string;
+    };
+    pdf: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        core: string[];
+        description: string;
+    };
+    face: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        max: number;
+        core: string[];
+        description: string;
+    };
+    barcode: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        core: string[];
+        description: string;
+    };
+    photo: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        core: any[];
+        description: string;
+    };
+    back: {
+        id: number;
+        camera: string;
+        name: string;
+        time: number;
+        core: string[];
+        description: string;
+    };
+};
+export default _default;

package/dist/types/environment/triangulation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+export declare const TRIANGULATION: number[];
+export default TRIANGULATION;

package/dist/types/eventListeners/eventListeners.d.ts

@@ -0,0 +1,15 @@
+import { IConfig } from '../modules/Config';
+type BLTemp2 = {
+    postInit: () => Promise<void>;
+    mount: (() => Promise<void>) | (() => void);
+    start: (() => Promise<void>) | (() => void);
+    changeDocumentType: () => void;
+    resetAllSteps: () => Promise<void>;
+    loadModules?: () => Promise<void>;
+    hereGoes?: () => Promise<void>;
+    reloadComponent: (config: Partial<IConfig>) => Promise<void>;
+    showSpinner: (val: boolean) => void;
+};
+declare const addEventListeners: (bl: BLTemp2) => void;
+export declare const clearIsListenersSet: () => void;
+export default addEventListeners;

package/dist/types/eventListeners/selectDocumentType/selectHandler.d.ts

@@ -0,0 +1,5 @@
+import { DocumentSelectEvent } from '../../modules/ui/selectDocumentType/documentSelectedEvent';
+declare const _default: (bl: {
+    mount: () => void;
+}, { docType, id }: DocumentSelectEvent) => Promise<void>;
+export default _default;

package/dist/types/helpers/apiSupport.d.ts

@@ -0,0 +1 @@
+export declare const webpSupport: () => boolean;

package/dist/types/helpers/canvas.d.ts

@@ -0,0 +1,41 @@
+import { ISize } from './image';
+import { ICrop, IOffset } from './ts/common';
+import { Bbox } from '../types/geometry';
+type GetIDataFromCenter = (offsetVertical: number, offsetHorizontal: number) => ImageData;
+export declare const getOrigData: () => ImageData;
+export declare const getResizedData: () => ImageData;
+export declare const getFaceOrigData: () => Promise<ImageData>;
+/**
+ * returns ImageData of image offsets from center
+ * @param {number} offsetVertical
+ * @param {number} offsetHorizontal
+ * @return ImageData
+ */
+export declare const getIDataFromCenter: GetIDataFromCenter;
+export declare const getBase64Data: () => string;
+export declare const getDataURL: (canvas: HTMLCanvasElement, format?: string, quality?: number) => Promise<string>;
+export declare const getBlob: (canvas: HTMLCanvasElement, format?: string, quality?: number) => Promise<Blob>;
+export declare const cutBboxFromImageData: (imageData: any, bbox: any) => ImageData;
+export declare const drawImageOnTestCanvas: (idata: ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement, elId?: string) => {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};
+export declare const drawCropOnCanvas: (idata: ImageData, bbox: Bbox, ctx: CanvasRenderingContext2D) => void;
+export declare const resize: (src: HTMLCanvasElement | HTMLVideoElement, dst: HTMLCanvasElement, offsets?: IOffset, cropSizes?: ISize) => ImageData;
+export declare const cropAndResize: (src: HTMLCanvasElement | HTMLVideoElement, dst: HTMLCanvasElement) => {
+    crop: ICrop;
+    resized: ImageData;
+};
+export declare const createCanvas: (id: string, size: ISize) => HTMLCanvasElement;
+export declare const createCanvasFromImage: (id: string, image: HTMLImageElement) => HTMLCanvasElement;
+export declare const createCanvasFromImageData: (id: string, imageData: ImageData) => HTMLCanvasElement;
+declare const _default: {
+    getOrigData: () => ImageData;
+    getResizedData: () => ImageData;
+    getBase64Data: () => string;
+    cropAndResize: (src: HTMLCanvasElement | HTMLVideoElement, dst: HTMLCanvasElement) => {
+        crop: ICrop;
+        resized: ImageData;
+    };
+};
+export default _default;

package/dist/types/helpers/color.d.ts

@@ -0,0 +1,14 @@
+export interface Color {
+    rgbaToGrayscale(pixels: Uint8Array | number[], rgba: number[], nrows: number, ncols: number): void;
+}
+type TypedArray = Uint8Array | Uint8ClampedArray | Float32Array;
+export declare enum Normalization {
+    STANDART = 255,
+    HALF = 127.5,
+    WITHOUT = 1
+}
+export declare const rgbaToGrayscale: (pixels: Uint8Array | number[], rgba: number[], nrows: number, ncols: number) => void;
+export declare const normalize: <T extends TypedArray>(arr: T, normalization?: Normalization) => T;
+export declare const rgbaToRgb: (rgba: ImageData, normalization?: Normalization) => Float32Array;
+declare const _default: Color;
+export default _default;

package/dist/types/helpers/dataManipulation.d.ts

@@ -0,0 +1,27 @@
+interface Entity {
+    value: string;
+    name: string;
+    status: 'valid' | 'invalid';
+}
+/**
+ * convert mrz parsed data to html represent
+ * @param {Array} data - mrz parsed data
+ */
+export declare const mrzToHtml: (data: Entity[]) => HTMLElement;
+/**
+ * convert pdf parsed data to html represent
+ * @param {Array} data - pdf parsed data
+ */
+export declare const pdfToHtml: (data: Entity[]) => HTMLElement;
+/**
+ * convert barcode parsed data to html represent
+ * @param {String} data - barcode parsed data
+ */
+export declare const barcodeToHtml: (data: string) => HTMLElement;
+/**
+ *
+ * @param {*} data - data to represent in HTML
+ * @param {String} type - type of parsed data maybe mrz|pdf|barcode
+ */
+declare const jsonToHtml: (data: string | Entity[], type: 'mrz' | 'pdf' | 'barcode') => false | HTMLElement;
+export default jsonToHtml;

package/dist/types/helpers/detectLanguage.d.ts

@@ -0,0 +1,3 @@
+import { SupportedLanguage } from '../environment/langs';
+declare const _default: (language?: SupportedLanguage) => void;
+export default _default;

package/dist/types/helpers/geometry.d.ts

@@ -0,0 +1,35 @@
+export type Point = [number, number];
+export interface ICoord {
+    x: number;
+    y: number;
+}
+export interface Geometry {
+    distanceBetweenPoints(p1: Point, p2: Point): number;
+    distanceBetweenPointsX(p1: Point, p2: Point): number;
+    distanceBetweenPointsXoR(p1: Point, p2: Point): number;
+    sizeByTwoPoints(p1: Point, p2: Point): number;
+    rectCenter(start: Point, end: Point): Point;
+    angleBetweenTwoVectors(vector1: number[], vector2: number[]): number;
+    triangleArea(a: number, b: number, c: number): number;
+}
+/**
+ * calculates distance between two points
+ * @param {Number[]} p1 - first coord [x1, y1]
+ * @param {Number[]} p2 - second coord [x2, y2]
+ * @return {number}
+ */
+export declare const distanceBetweenPoints: (p1: Point, p2: Point) => number;
+/**
+ * calculates distance between two points
+ * @param {Number[]} p1 - first coord [x1, y1]
+ * @param {Number[]} p2 - second coord [x2, y2]
+ * @return {number}
+ */
+export declare const distanceBetweenPointsX: (p1: Point, p2: Point) => number;
+export declare const sizeByTwoPoints: (p1: Point, p2: Point) => number;
+export declare const rectCenter: (start: Point, end: Point) => Point;
+export declare const angleBetweenTwoVectors: (vector1: number[], vector2: number[]) => number;
+export declare const distanceBetweenPointsXoR: (p1: Point, p2: Point) => number;
+export declare const triangleArea: (a: number, b: number, c: number) => number;
+declare const geometry: Geometry;
+export default geometry;

package/dist/types/helpers/html.d.ts

@@ -0,0 +1,26 @@
+interface AttributeCollection {
+    [name: string]: string | boolean;
+}
+type CreateElement = (tagName?: string, params?: AttributeCollection | null, classNames?: string[], parent?: HTMLElement | null, children?: HTMLElement[]) => HTMLElement;
+/**
+ * create and return HTMLElement
+ * @param { String } tagName - default 'div'
+ * @param { AttributeCollection | null } params
+ * @param { Array<String> } classNames - array of class names
+ * @param { HTMLElement } parent - element to which needs append created element
+ * @param { Array<HTMLElement> } children  - elements which will appended to created element
+ * @returns { HTMLElement } - created element
+ */
+export declare const createElement: CreateElement;
+/**
+ * creates a script tag
+ * @param {string} scriptUrl - url to remote script
+ * @param {'module'} type - create script as module
+ * @return {Promise<unknown>}
+ */
+export declare const loadScript: (scriptUrl: string) => Promise<unknown>;
+declare const _default: {
+    createElement: CreateElement;
+    loadScript: (scriptUrl: string) => Promise<unknown>;
+};
+export default _default;

package/dist/types/helpers/image.d.ts

@@ -0,0 +1,36 @@
+import { ICrop } from './ts/common';
+export type Base64Image = string;
+export type RGBAColor = string;
+export type RGBColor8 = Uint8ClampedArray;
+export type RGBColor32 = Float32Array;
+type PixelPosition = number;
+type Segmentize = (binarizedImg: Uint8ClampedArray, width: number) => Set<PixelPosition>[];
+type Binarize = (img: ImageData, threshold?: number) => Uint8ClampedArray;
+type GetResizedSizes = (size: number, baseSize: IBaseSize) => ISize;
+export interface IOffset {
+    top: number;
+    left: number;
+}
+/**
+ * { width: number, height: number }
+ */
+export interface ISize {
+    width: number;
+    height: number;
+}
+interface IBaseSize {
+    baseWidth: number;
+    baseHeight: number;
+}
+export declare const generateFaceColorFromAngle: (angle: number) => RGBAColor;
+/**
+ *
+ * @param {ImageData} iData
+ * @param {number} threshold
+ * @return number[] - black and whited array;
+ */
+export declare const binarize: Binarize;
+export declare const segmentize2: Segmentize;
+export declare const getResizedSizes: GetResizedSizes;
+export declare const getCrop: (src: ISize, dst: ISize) => ICrop;
+export {};

package/dist/types/helpers/imageprocessing.d.ts

@@ -0,0 +1,11 @@
+import { ILoopResult } from '../environment/loopResult';
+declare const _default: {
+    processImage4: () => {
+        status: boolean;
+        cancel: boolean;
+        touch: boolean;
+        image: ImageData;
+    };
+    processImage5: (sideDetect?: boolean) => Promise<ILoopResult>;
+};
+export default _default;

package/dist/types/helpers/licenceKeyError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * sets licence key error
+ * @param {Number} errorCode
+ */
+declare const _default: (errorCode?: number) => void;
+export default _default;

package/dist/types/helpers/manualUpload.d.ts

@@ -0,0 +1,7 @@
+export declare const resizeImageForStepProcessing: (data: any) => Promise<ImageData>;
+declare const _default: {
+    getSmallImage: (data: string) => Promise<ImageData>;
+    setCurrentImage: (data: any) => Promise<void>;
+    fixOrientation: (image: HTMLImageElement) => Promise<ImageData>;
+};
+export default _default;

package/dist/types/helpers/math.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Compute the mean value of values or a list with values.
+ * @param {number[]|number} args - (a, b, c) or []
+ * @returns {number}
+ */
+export declare const mean: (...args: number[] | [number[]]) => number;
+type NormalizationFunctionNames = 'unbiased' | 'biased' | 'uncorrected';
+export declare const normalizationFunction: {
+    unbiased: (arr: number[]) => number;
+    biased: (arr: number[]) => number;
+    uncorrected: (arr: number[]) => number;
+};
+/**
+ * calculate standard deviation or return -1
+ * @param {Number[]} vals
+ * @param {'unbiased'|'biased'|'uncorrected'} normalization - 'unbiased' - divide by n - 1,
+ * 'uncorrected' - divide by n,
+ * 'biased' - divide by n + 1. default 'unbiased'.
+ * @param {number} fixed - how many digits after the decimal.
+ * @return number -1 if input values are wrong
+ */
+export declare const STD: (vals: number[], normalization?: NormalizationFunctionNames, fixed?: number) => number;
+/**
+ * get random integer number from range, included min and max
+ * @param {number} min
+ * @param {number} max
+ * @return {number}
+ */
+export declare const randomIntFromInterval: (min: number, max: number) => number;
+declare const _default: {
+    randomIntFromInterval: (min: number, max: number) => number;
+    mean: (...args: number[] | [number[]]) => number;
+    STD: (vals: number[], normalization?: NormalizationFunctionNames, fixed?: number) => number;
+};
+export default _default;

package/dist/types/helpers/mobileChecker.d.ts

@@ -0,0 +1,13 @@
+export declare const isiOS: () => boolean;
+export declare const checkTouchPoints: () => boolean;
+export declare const detectTouchscreen: () => boolean;
+/**
+ *
+ * @param {Number} maxWidth - preferable max width device
+ */
+export declare const collectMobileDetectingData: () => Record<string, any>;
+declare const checkIfMobile: () => {
+    isMobile: boolean;
+    logsObject: Record<string, any>;
+};
+export default checkIfMobile;

package/dist/types/helpers/numbers.d.ts

@@ -0,0 +1,2 @@
+import { GetRandomNumber } from '../types/helpers/numbers';
+export declare const getRandomNumber: GetRandomNumber;

package/dist/types/helpers/step-background.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (stepName: string) => string;
+export default _default;

package/dist/types/helpers/strings.d.ts

@@ -0,0 +1,9 @@
+import { Base64Image } from './image';
+export declare const encodeMeta: (metadata: any) => string;
+export declare const decodeMeta: (str: string) => any;
+export declare const base64ToArrayBuffer: (base64: string) => Uint8Array;
+export declare const getDataFromBase64Img: (imgString: Base64Image) => string;
+export declare const splitWordByUpperLetters: (word: string) => string[];
+export declare const normalizeCamelCase: (word: string) => string;
+export declare const removeHtmlEntities: (str: string) => string;
+export declare const normalizeString: (str: string) => string;

package/dist/types/helpers/time.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number} ms
+ * @returns {Promise<>}
+ */
+export declare const timeout: (ms: number) => Promise<unknown>;
+export declare const nextFrame: (fn?: () => Promise<any> | void) => Promise<unknown>;
+declare const _default: {
+    timeout: (ms: number) => Promise<unknown>;
+};
+export default _default;

package/dist/types/helpers/ts/common.d.ts

@@ -0,0 +1,17 @@
+export type PartialRecord<T extends string, U> = {
+    [V in T]?: U;
+};
+export interface IPosition {
+    x: number;
+    y: number;
+}
+export interface IOffset {
+    left: number;
+    top: number;
+}
+export interface ISize {
+    width: number;
+    height: number;
+}
+export interface ICrop extends ISize, IPosition {
+}

package/dist/types/helpers/updateSelecetTypes.d.ts

@@ -0,0 +1,3 @@
+import SelectDocumentType from '../modules/ui/SelectDocumentType';
+declare const updateSelectTypes: (selectDocumentType: SelectDocumentType) => void;
+export default updateSelectTypes;

package/dist/types/helpers/validators.d.ts

@@ -0,0 +1,44 @@
+/**
+ * check value to be boolean
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidBool: (val: any) => boolean;
+/**
+ * check value to be object
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidObject: (val: any) => boolean;
+/**
+ * check value to be function
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidFunction: (val: any) => boolean;
+/**
+ * check value to be string
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidString: (val: any) => boolean;
+/**
+ * check value to be finite number
+ * @param val
+ * @return {boolean}
+ */
+export declare const isValidNumber: (val: any) => boolean;
+/**
+ * validates string in given array and set its value
+ * @param {String[]} availableValues - array of available values
+ * @param {String} valueToSet - value that should be set
+ */
+export declare const isValidDistinctStringInArray: (availableValues: string[], valueToSet: string) => boolean;
+declare const _default: {
+    isValidBool: (val: any) => boolean;
+    isValidFunction: (val: any) => boolean;
+    isValidString: (val: any) => boolean;
+    isValidNumber: (val: any) => boolean;
+    isValidDistinctStringInArray: (availableValues: string[], valueToSet: string) => boolean;
+};
+export default _default;

package/dist/types/idvc.d.ts

@@ -0,0 +1,18 @@
+import './assets/scss/index.scss';
+import { IConfig } from './modules/Config';
+import { SupportedLanguage } from './environment/langs';
+import { IDocumentTypeConfig } from './modules/validator';
+export default class VideoCapturing {
+    constructor(config: IConfig);
+    private init;
+    /**
+     *
+     * @param language
+     */
+    changeLanguage(language: SupportedLanguage): void;
+    get version(): string;
+    resetAllSteps(): void;
+    reloadComponent(newConfig: Partial<IConfig>): void;
+    updateDocumentTypes(documentTypes: IDocumentTypeConfig): void;
+    showSpinner(val: any): void;
+}

package/dist/types/initialize.d.ts

@@ -0,0 +1,12 @@
+export declare const typesInit: () => void;
+declare const _default: {
+    typesInit: () => void;
+    checkCompatibility: () => void;
+    start: () => void;
+    isCameraRequired: () => any;
+    isUploaderRequired: () => any;
+    isCameraNeeded: () => any;
+    detectAndSetBrowser: () => void;
+    detectAndSetRealFaceMode: () => void;
+};
+export default _default;

package/dist/types/loader/asyncLoader.d.ts

@@ -0,0 +1 @@
+export declare const asyncLoader: () => Promise<void>;

package/dist/types/loader/loadAnglesModel.d.ts

@@ -0,0 +1,3 @@
+import { NeuralModelInitializer } from '../neural models/neuralModel';
+declare const _default: () => Promise<Array<NeuralModelInitializer>>;
+export default _default;