@idscan/idvc2 2.6.0 → 2.6.2

package/dist/types/modules/face/SimpleFace.d.ts

@@ -0,0 +1,24 @@
+import Face from './Face';
+export declare class SimpleFace extends Face {
+    private initialized;
+    private readonly shiftFactor;
+    private readonly minSize;
+    private readonly maxSize;
+    private readonly scaleFactor;
+    constructor(core: any);
+    initPico(data: ImageData): void;
+    rgbaToGrayScale(rgba: any, width: any, height: any): Uint8Array;
+    findFaces({ height, width }: ImageData): void;
+    detect(faceData: ImageData, isUploader?: boolean): {
+        status: boolean;
+        image: any;
+        faceSuccessCount: number;
+        faceFailCount: number;
+        faceNotRecognizedCount: number;
+        touch: boolean;
+        cancel: boolean;
+        type: string;
+    };
+    dropResults(): void;
+}
+export default SimpleFace;

package/dist/types/modules/feature-detect/simd.d.ts

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

package/dist/types/modules/frameQuality.d.ts

@@ -0,0 +1,10 @@
+/**
+ * detect frame quality based on comparing pixels intesivity.
+ */
+interface IData {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+export declare const getFrameQuality: ({ data, width, height }: IData) => number;
+export {};

package/dist/types/modules/heic.d.ts

@@ -0,0 +1,11 @@
+export declare class HeicModule {
+    private core;
+    constructor(core?: any);
+    processSingleImage(image: any): Promise<unknown>;
+    private heifDecode;
+    convert(e: any): Promise<{
+        imageDataArr: any[];
+        error: string;
+    }>;
+}
+export default HeicModule;

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

@@ -0,0 +1,13 @@
+import { BrowserInfo } from 'detect-browser';
+export type Angle = 0 | 90 | 180 | 270;
+export declare function dataURItoBlob(dataURL: string): Blob;
+export declare const rotateImageByAngle: (src: string, angle: Angle) => Promise<unknown>;
+export declare const rotateImageByExif: (src: string, browser: BrowserInfo) => Promise<string>;
+/**
+ *
+ * @param src - string
+ * @param maxSize - integer
+ * @param browser - object
+ * @returns {Promise<DataURL>}
+ */
+export declare const resizeImage: (src: string, maxSize: number | 'none', browser: BrowserInfo) => Promise<string>;

package/dist/types/modules/initErrorHandler.d.ts

@@ -0,0 +1,10 @@
+import { CameraNotSupportedReason } from '../types/modules/camera.enum';
+/**
+ * The error object thrown when VideoRecognizer fails to open the camera feed.
+ */
+export declare class CameraError extends Error {
+    /** The reason why opening the camera failed. */
+    readonly reason: CameraNotSupportedReason;
+    constructor(reason: CameraNotSupportedReason, ...params: any[]);
+}
+export declare const CameraErrorHandler: (error: CameraError) => void;

package/dist/types/modules/licenseKeyChecker.d.ts

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

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

@@ -0,0 +1,7 @@
+import { Base64Image } from '../helpers/image';
+interface Base64Object {
+    data: ImageData | Base64Image | null;
+    err: boolean;
+}
+declare const dropFile: (base64Obj: Base64Object) => Promise<void>;
+export default dropFile;

package/dist/types/modules/manualUploadProcessing.d.ts

@@ -0,0 +1,27 @@
+import { Base64Image } from '../helpers/image';
+interface ICoord {
+    x: number;
+    y: number;
+}
+export interface IMRZLocation {
+    leftTop: ICoord;
+    rightTop: ICoord;
+    rightBottom: ICoord;
+    leftBottom: ICoord;
+}
+/**
+ * process manually uploaded image for MRZ
+ * @param {ImageData} smallImage - resized image data
+ * @return {Promise<boolean>}
+ */
+export declare const mrzProcess: (smallImage: ImageData) => Promise<boolean>;
+export declare const pdfProcess: (smallImage: ImageData) => boolean;
+/**
+ *
+ * @param {Base64Image} data - base64 image
+ */
+export declare const barCodeProcess: (data: Base64Image) => Promise<boolean>;
+export declare const frontProcess: (smallImage: ImageData) => Promise<boolean>;
+export declare const faceProcess: (smallImage: ImageData) => Promise<boolean>;
+export declare const backProcess: (smallImage: ImageData) => Promise<boolean>;
+export {};

package/dist/types/modules/mediaDevices.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (isiOS: boolean) => Promise<string>;
+export default _default;

package/dist/types/modules/moduleInitializer.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    hasModule: (name: any) => boolean;
+    pdf: (module: any) => any;
+    face: (module: any) => any;
+    docDetector: (module: any) => any;
+    barcode: (module: any) => any;
+};
+export default _default;

package/dist/types/modules/step-functions/back.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (data: ImageData) => Promise<any>;
+export default _default;

package/dist/types/modules/step-functions/face.d.ts

@@ -0,0 +1,2 @@
+export declare const uploadFace: (data: ImageData) => Promise<boolean>;
+export declare const videoFace: () => Promise<any>;

package/dist/types/modules/step-functions/pdf.d.ts

@@ -0,0 +1,20 @@
+import { Status } from '../FrontProcessing';
+import { ClassLocalExitType } from '../../neural models/classLocal/exits';
+interface ClassLocalResult {
+    type: ClassLocalExitType;
+    status: Status;
+}
+export declare const dropRes: () => void;
+declare const _default: (data: ImageData, result?: ClassLocalResult) => Promise<{
+    status: boolean;
+    predict: boolean;
+    touch: boolean;
+    image: ImageData;
+    type: string;
+    error: any;
+    coords: any[];
+    trackString: string;
+    pdfSuccessCount: number;
+    pdfCount: number;
+}>;
+export default _default;

package/dist/types/modules/step-result-processing/back.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/barcode.d.ts

@@ -0,0 +1,2 @@
+declare const barcode: (resultObject: any) => void;
+export default barcode;

package/dist/types/modules/step-result-processing/common.d.ts

@@ -0,0 +1 @@
+export declare const setDetectFace: (val: any) => void;

package/dist/types/modules/step-result-processing/mrz.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/pdf.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/simpleFace.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (resultObject: any) => void;
+export default _default;

package/dist/types/modules/step-result-processing/volumeFace.d.ts

@@ -0,0 +1,7 @@
+import { RealFaceResultObject } from '../../types/modules/realFace';
+import { Point } from '../../helpers/geometry';
+type DrawPath = (region: Path2D, points: Point[], closePath: boolean) => void;
+export declare const drawPath: DrawPath;
+export declare const drawFacePoints: (keypointList: any, color: string) => void;
+declare const _default: (resultObject: RealFaceResultObject) => void;
+export default _default;

package/dist/types/modules/stepFunctions.d.ts

@@ -0,0 +1,5 @@
+type ModuleNames = 'mrz' | 'pdf' | 'face' | 'front' | 'barcode';
+type FunctionNames = ModuleNames | 'photo' | 'back';
+declare const stepFunctionWrapper: (functionName: FunctionNames, ...args: any[]) => any;
+export declare const isStepFunctionExist: (functionName: FunctionNames) => boolean;
+export default stepFunctionWrapper;

package/dist/types/modules/stepResultProcessing.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    hasFn: (fnName: string) => boolean;
+    pdf: (resultObject: any) => void;
+    mrz: (resultObject: any) => void;
+    SimpleFace: (resultObject: any) => void;
+    VolumeFace: (resultObject: import("../types/modules/realFace").RealFaceResultObject) => void;
+    barcode: (resultObject: any) => void;
+    back: (resultObject: any) => void;
+};
+export default _default;

package/dist/types/modules/supaBaseClient.d.ts

@@ -0,0 +1,2 @@
+declare function InitClient(): import("@supabase/supabase-js").SupabaseClient<any, "public", any>;
+export { InitClient };

package/dist/types/modules/ui/Flashlight.d.ts

@@ -0,0 +1,17 @@
+declare class Flashlight {
+    private icon;
+    private onIcon;
+    private offIcon;
+    private isEnableFlashLight;
+    constructor();
+    /**
+     * switches visible of lightning icon
+     * @param {boolean} val
+     */
+    show(val: boolean): void;
+    turnOff(): void;
+    turnOn(): void;
+    get isTurnedOn(): boolean;
+    addClickEventListener(fn?: () => void): void;
+}
+export default Flashlight;

package/dist/types/modules/ui/MaskCapture.d.ts

@@ -0,0 +1,52 @@
+declare class MaskCapture {
+    #private;
+    private svg;
+    private strokeMask;
+    private successMask;
+    private type;
+    private cssVarContainer;
+    private borders;
+    private cssVars;
+    _mainContainerSizes: {
+        width: string;
+        height: string;
+    };
+    constructor(cssVarContainer: any);
+    /**
+     * get computed width and height of element
+     * @param {HTMLElement} el
+     * @return {{width: string, height: string}}
+     */
+    getSizes: (el: any) => {
+        width: string;
+        height: string;
+    };
+    get svgSizes(): {
+        width: string;
+        height: string;
+    };
+    get strokeSizes(): {
+        width: number;
+        height: number;
+    };
+    get strokeLength(): number;
+    set sizes({ width, height }: {
+        width: any;
+        height: any;
+    });
+    set fillPercentage(percentage: any);
+    /**
+     * sets the type of capturing mask and it position on screen
+     * @param {VideoFacingModeEnum} type - 'environment', 'user'
+     */
+    set maskType(type: any);
+    /**
+     * resizes frame based on width and height of main container
+     * @param {{width: number, height: number}} param - width and height of main container
+     */
+    set mainContainerSizes({ width, height }: {
+        width: any;
+        height: any;
+    });
+}
+export default MaskCapture;

package/dist/types/modules/ui/MessageBox.d.ts

@@ -0,0 +1,20 @@
+type MessageBoxType = 'error' | 'primary' | null;
+type CallbackHandler = (event: Event) => void;
+declare class MessageBox {
+    #private;
+    constructor();
+    private setClass;
+    get type(): MessageBoxType;
+    /**
+     * sets the message in message-box
+     * @param {string} text - text to set in message-box
+     * @param {'error', 'primary'} type - type of message. Default: primary
+     */
+    message(text?: string, type?: string): void;
+    updateByTypesCount(typesCount?: number): void;
+    addChangeDocumentTypeListener(handler: CallbackHandler): void;
+    removeAllChangeDocumentTypeListener(): void;
+    setCaretVisible(val: boolean): void;
+    changeMessageBoxVisible(visibility: boolean): void;
+}
+export default MessageBox;

package/dist/types/modules/ui/Modal.d.ts

@@ -0,0 +1,20 @@
+interface DestructedOptions {
+    isMobile: boolean;
+    background: HTMLDivElement;
+    containerId: string;
+    mainId?: string;
+    doneBtnId: string;
+    cancelBtnId: string;
+}
+declare class Modal {
+    private background;
+    container: HTMLDivElement;
+    doneBtn: HTMLButtonElement;
+    cancelBtn: HTMLButtonElement;
+    constructor(opts: DestructedOptions);
+    addDoneHandler(handler: (e?: Event) => void): void;
+    addCancelHandler(handler: (e?: Event) => void): void;
+    hide(): void;
+    show(): void;
+}
+export default Modal;

package/dist/types/modules/ui/SelectDocumentType.d.ts

@@ -0,0 +1,37 @@
+import Modal from './Modal';
+import { DocumentRecord, DocumentTypeIndex, DocumentTypeName, HumanName } from '../../environment/documentTypes';
+import { ModalPositionKeys } from '../../environment/modalPosition';
+interface DocumentTypeElement {
+    name: DocumentTypeName;
+    element: HTMLLabelElement;
+    id: DocumentTypeIndex;
+    nName?: string;
+}
+interface ISpinner {
+    addSpinnerState: () => void;
+    showSpinner: () => void;
+    removeSpinnerState: () => void;
+    clearState: () => void;
+    hideSpinner: () => void;
+}
+declare class SelectDocumentType extends Modal {
+    private list;
+    elementsList: DocumentTypeElement[];
+    private cancelButtonContainer;
+    private doneButtonContainer;
+    private spinner;
+    constructor(isMobile: boolean, background: HTMLDivElement, spinner: ISpinner, modalPositionClass: ModalPositionKeys);
+    show(): void;
+    hide(): void;
+    showCancelButton(): void;
+    hideCancelButton(): void;
+    addDoneHandler(handler: (e?: Event) => void): void;
+    addCancelHandler(handler: (e?: Event) => void): void;
+    createElement: (docType: DocumentTypeName, humanName: HumanName) => HTMLLabelElement;
+    hasElement(docType: DocumentTypeName): boolean;
+    addElement(docType: DocumentTypeName, element: HTMLLabelElement, id: DocumentTypeIndex): void;
+    clearList(): void;
+    addType({ name: docType, humanName, id }: DocumentRecord): void;
+    render(): void;
+}
+export default SelectDocumentType;

package/dist/types/modules/ui/canvas.d.ts

@@ -0,0 +1,48 @@
+import { IOffset, ISize } from '../../helpers/image';
+import { Bbox } from '../../types/geometry';
+export default class CanvasUi {
+    canvasNames: Set<string>;
+    canvasCtxNames: Set<string>;
+    videoCanvas: HTMLCanvasElement;
+    resizedCanvas: HTMLCanvasElement;
+    mrzCanvas: HTMLCanvasElement;
+    borderCanvas: HTMLCanvasElement;
+    faceCanvas: HTMLCanvasElement;
+    classLocalCanvas: HTMLCanvasElement;
+    blazeFaceCanvas: HTMLCanvasElement;
+    meshFaceCanvas: HTMLCanvasElement;
+    mrzCtx: CanvasRenderingContext2D;
+    videoCtx: CanvasRenderingContext2D;
+    resizedCtx: CanvasRenderingContext2D;
+    borderCtx: CanvasRenderingContext2D;
+    faceCtx: CanvasRenderingContext2D;
+    classLocalCtx: CanvasRenderingContext2D;
+    blazeFaceCtx: CanvasRenderingContext2D;
+    meshFaceCtx: CanvasRenderingContext2D;
+    video: HTMLVideoElement;
+    faceOffset: IOffset;
+    constructor(video: HTMLVideoElement);
+    saveCanvas(): void;
+    restoreCanvas(): void;
+    toggleBorderCanvas(): void;
+    clearBorderCtx(): void;
+    setVideoCanvasSizes({ width, height }: ISize): void;
+    getBaseSizes(coefficient?: number): {
+        baseHeight: number;
+        baseWidth: number;
+    };
+    setResizedCanvas(): void;
+    setBorderCanvas(width: number, height: number): void;
+    recreateCanvas(canvas: HTMLCanvasElement): {
+        canvas: HTMLCanvasElement;
+        ctx: CanvasRenderingContext2D;
+    };
+    rectreateDistinctCanvas(canvasName: string): void;
+    prepareFaceCanvas(width: number, height: number): void;
+    drawVideo(): void;
+    drawResized(): void;
+    drawFace(): void;
+    recreateWorkingCanvas(): void;
+    drawResizedVideo(): void;
+    drawBbox(bbox: Bbox): void;
+}

package/dist/types/modules/ui/forceCaptruringBtn.d.ts

@@ -0,0 +1,12 @@
+type EventCallback = (e?: Event) => void;
+declare class ForceCapturingButton {
+    private isShowing;
+    private el;
+    private callback;
+    constructor();
+    get state(): boolean;
+    set state(val: boolean);
+    addClickCallback(cbl: EventCallback): void;
+    setAvailable(status: boolean): void;
+}
+export default ForceCapturingButton;

package/dist/types/modules/ui/hints.d.ts

@@ -0,0 +1,17 @@
+import { RealFaceTurnSide } from '../../types/enums/realFace';
+declare class UiHints {
+    static holdText: HTMLSpanElement;
+    static arrowUpHintContainer: HTMLDivElement;
+    static arrowLeftHintContainer: HTMLDivElement;
+    static arrowRightHintContainer: HTMLDivElement;
+    static arrowLeftFaceTheCameraContainer: HTMLDivElement;
+    static arrowRightFaceTheCameraContainer: HTMLDivElement;
+    static currentArrowContainer: HTMLDivElement | null;
+    static init(): void;
+    static showFaceTheCameraArrows(): void;
+    static hideFaceTheCameraArrows(): void;
+    static showArrow(arrowNumber: RealFaceTurnSide, data: any, isCorrectDirection: any): void;
+    static hideArrows(): void;
+    static updateHoldText(data?: number, isCorrectDirection?: boolean): string;
+}
+export default UiHints;

package/dist/types/modules/ui/limitations.d.ts

@@ -0,0 +1,2 @@
+export declare const showLimitations: (errorText: any) => void;
+export declare const hideLimitations: () => void;

package/dist/types/modules/ui/manualSwitchBtn.d.ts

@@ -0,0 +1,30 @@
+import { IStepModeKeys } from '../../defaultConfig';
+type EventCallback = (e?: Event) => void;
+export interface IManualSwitchBtn {
+    el: HTMLButtonElement | null;
+    loadingEl: HTMLDivElement | null;
+    containerEl: HTMLDivElement | null;
+    state: IStepModeKeys | null;
+    callback: EventCallback | null;
+    setLoading(status: boolean): void;
+    setEnabled(status: boolean): void;
+    setAvailable(status: boolean): void;
+    setState(state: IStepModeKeys): void;
+    addClickCallback(cbl: EventCallback): void;
+    setText(): void;
+}
+declare class ManualSwitchBtn implements IManualSwitchBtn {
+    el: any;
+    loadingEl: any;
+    containerEl: any;
+    state: any;
+    callback: any;
+    constructor(cameraSupported: boolean);
+    setLoading(status: boolean): void;
+    setEnabled(status: boolean): void;
+    setAvailable(status: boolean): void;
+    setText(): void;
+    setState(state: IStepModeKeys): void;
+    addClickCallback(cbl: EventCallback): void;
+}
+export default ManualSwitchBtn;

package/dist/types/modules/ui/selectDocumentType/documentSelectedEvent.d.ts

@@ -0,0 +1,7 @@
+import { DocumentTypeIndex, DocumentTypeName } from '../../../environment/documentTypes';
+export interface DocumentSelectEvent {
+    docType: DocumentTypeName;
+    id: 0 | DocumentTypeIndex;
+}
+declare const _default: ({ docType, id }: DocumentSelectEvent) => CustomEvent<DocumentSelectEvent>;
+export default _default;

package/dist/types/modules/ui/spinner.d.ts

@@ -0,0 +1,13 @@
+export declare const addSpinnerState: (bottomText?: string, topText?: string) => void;
+export declare const removeSpinnerState: () => void;
+export declare const clearState: () => void;
+export declare const showSpinner: () => void;
+export declare const hideSpinner: () => void;
+declare const _default: {
+    addSpinnerState: (bottomText?: string, topText?: string) => void;
+    removeSpinnerState: () => void;
+    clearState: () => void;
+    showSpinner: () => void;
+    hideSpinner: () => void;
+};
+export default _default;

package/dist/types/modules/ui/swiper.d.ts

@@ -0,0 +1,3 @@
+import { SwiperCallback } from '../../types/modules/ui/swiper';
+declare const init: (el: HTMLElement, cbk: SwiperCallback) => void;
+export default init;

package/dist/types/modules/uploader.d.ts

@@ -0,0 +1,58 @@
+import { StepType } from '../environment/stepsDescription';
+import { Base64Image } from '../helpers/image';
+type SubmitHandler = (base64Obj: Base64Object) => Promise<void>;
+interface Base64Object {
+    data: ImageData | Base64Image | null;
+    err: boolean;
+}
+interface ISmallStep {
+    type: StepType;
+    img: Base64Image | null;
+    name?: string;
+    errorCode?: string | null | undefined;
+}
+declare class Uploader {
+    private onsubmit;
+    private onHandle;
+    private states;
+    private readonly types;
+    private dropArea;
+    private dropAreaBackground;
+    private fileInput;
+    private stepName;
+    private errorTextEl;
+    private pressToUpdate;
+    private readonly translation;
+    protected textFront: HTMLElement;
+    protected textBack: HTMLElement;
+    protected textFace: HTMLElement;
+    protected textPdf: HTMLElement;
+    protected textMrz: HTMLElement;
+    protected textFrontBack: HTMLElement;
+    protected textPass: HTMLElement;
+    protected textFacePosition: HTMLElement;
+    private moduleController;
+    private addedFileTypes;
+    constructor(uploaderId: string, type: ISmallStep, onsubmit: SubmitHandler, onHandle: () => void, moduleController: any, addedFileTypes: string[]);
+    checkType(typeForCheck: string): string | false;
+    handleFiles(data: {
+        target: {
+            files: FileList;
+        };
+    } | Event): void;
+    setText(): void;
+    /**
+     *
+     * @param {string} errorCode
+     */
+    showError(errorCode: string): void;
+    clearStates(): void;
+    resetInput(): void;
+    highlight(): void;
+    unhighlight(): void;
+    handleDrop(e: DragEvent): void;
+    changeType(step: ISmallStep): void;
+    transition(): void;
+    setDisabled(val: boolean): void;
+}
+export default Uploader;

package/dist/types/modules/validation/ValidateBool.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateBool implements IValidator<boolean> {
+    validate(val: any, fallback: boolean, configName: string): boolean;
+}
+export default ValidateBool;

package/dist/types/modules/validation/ValidateDocumentTypes.d.ts

@@ -0,0 +1,20 @@
+import { IDocumentType } from '../../defaultConfig';
+import { DocumentTypeName } from '../../environment/documentTypes';
+import { StepType } from '../../environment/stepsDescription';
+import { IDocumentTypeConfig, IValidator } from '../validator';
+declare class ValidateDocumentTypes implements IValidator<IDocumentType[]> {
+    types: any[];
+    steps: any[];
+    commonStepTypes: Set<StepType>;
+    documentTypes: IDocumentTypeConfig;
+    validate(val: IDocumentType[], fallback: IDocumentType[], configName: 'documentTypes'): {
+        types: any[];
+        steps: any[];
+        commonStepTypes: Set<StepType>;
+        documentTypes: IDocumentTypeConfig;
+    };
+    validateTypes(types: string[]): DocumentTypeName[];
+    transformDocType({ type, steps }: IDocumentType): void;
+    setCommonStepTypes(): void;
+}
+export default ValidateDocumentTypes;

package/dist/types/modules/validation/ValidateElement.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateElement implements IValidator<string> {
+    validate(elId: string, defaultValue: string): string;
+}
+export default ValidateElement;

package/dist/types/modules/validation/ValidateFunction.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateFunction implements IValidator<(arg?: undefined) => boolean> {
+    validate(val: any, fallback: (arg?: undefined) => boolean, configName: string): any;
+}
+export default ValidateFunction;

package/dist/types/modules/validation/ValidateNumber.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateNumber implements IValidator<number> {
+    validate(val: number, fallback: number, configName: string): number;
+}
+export default ValidateNumber;

package/dist/types/modules/validation/ValidateString.d.ts

@@ -0,0 +1,5 @@
+import { IValidator } from '../validator';
+declare class ValidateString implements IValidator<string> {
+    validate(val: string, fallback: string, configName: string): string;
+}
+export default ValidateString;

package/dist/types/modules/validation/ValidateStringInArray.d.ts

@@ -0,0 +1,12 @@
+import { IValidator } from '../validator';
+declare class ValidateDistinctStringInArray implements IValidator<string> {
+    /**
+     * validates string in given array and set its value
+     * @param {String} valueToSet - value that should be set
+     * @param {String} defaultValue - fallback if value is not in given array
+     * @param {String} configName - name of config
+     * @param {String[]} availableValues - array of available values
+     */
+    validate(valueToSet: string, defaultValue: string, configName: string, availableValues: string[]): string;
+}
+export default ValidateDistinctStringInArray;

package/dist/types/modules/validation/showValidationError.d.ts

@@ -0,0 +1,2 @@
+declare const showError: (configName: string, fallback: any) => void;
+export default showError;