@regulaforensics/vp-frontend-face-components 1.4.0 → 2.0.0

package/lib/services/FaceService.d.ts

@@ -1,11 +1,39 @@
-import { FaceLivenessResultType } from '../types';
-declare function getLivenessResult(encryptedBody: Uint8Array, { backendURL, uuid, try_id, headers, }: {
+import { ConfigLivenessParams, FaceLivenessResultType } from '../types';
+import CameraModel from '../models/CameraModel';
+declare type GetLivenessDetectionResultOptions = {
+    transactionId: string;
     backendURL?: string;
-    uuid: string;
-    try_id: number;
     headers?: Record<string, string>;
-}): Promise<FaceLivenessResultType | undefined>;
+    publicKey: string;
+};
+declare type DeviceMetadata = {
+    platform: string;
+    osVersion: string;
+    sdkVersion: string;
+    hostAppId: string;
+    deviceModel: string;
+    currentCameraId: string;
+    cameraState: CameraModel[];
+};
+declare type InitializedFaceLivenessDataResult = {
+    config: ConfigLivenessParams;
+    metadata: {
+        ctx: {
+            userIp: string;
+        };
+        serverTime: string;
+    };
+    publicKey: string;
+    schema: string;
+    sessionId: string;
+    transactionId: string;
+};
+declare function getLivenessDetectionResult(encryptedBody: Uint8Array, { transactionId, backendURL, headers, publicKey }: GetLivenessDetectionResultOptions): Promise<FaceLivenessResultType>;
+declare function getInitialisingData(deviceMetadata: DeviceMetadata, sessionId?: string, backendUrl?: string): Promise<InitializedFaceLivenessDataResult>;
+declare function sendVideoData(data: Uint8Array, transactionId: string, backendURL?: string, tag?: string): Promise<void>;
 declare const _default: {
-    getLivenessResult: typeof getLivenessResult;
+    getInitialisingData: typeof getInitialisingData;
+    getLivenessDetectionResult: typeof getLivenessDetectionResult;
+    sendVideoData: typeof sendVideoData;
 };
 export default _default;

package/lib/services/StreamRecorderService.d.ts

@@ -0,0 +1,24 @@
+import { VideoFinishStatus } from '../constants';
+declare class StreamRecorderService {
+    private chunks;
+    private recorder;
+    private mimeType;
+    private transactionId;
+    private debug;
+    private backendUrl;
+    private finishStatus;
+    constructor();
+    init(stream: MediaStream): void;
+    setParameters({ debug, backendUrl, transactionId, }: {
+        debug: boolean | undefined;
+        backendUrl: string | undefined;
+        transactionId: string;
+    }): void;
+    setFinishStatus(status: VideoFinishStatus): void;
+    stopRecord(): void;
+    private errorHandle;
+    private setChunk;
+    private sendFile;
+}
+declare const _default: StreamRecorderService;
+export default _default;

package/lib/types.d.ts

@@ -1,34 +1,86 @@
-import { Response } from '@regulaforensics/document-reader-webclient';
-import { documentEventActions, faceEventActions, responseCode, streamStatus, WebComponentsError } from './constants';
+import { Response } from './models/DocReaderWebclient/ext';
+import dictionaries from './i18n/dictionaries/_dictionaries';
+import { DocumentEventActions, FaceEventActions, InternalScenarios, ResponseCode, StreamStatus, ErrorTypes, CameraFacingMode } from './constants';
 import CameraModel from './models/CameraModel';
+export declare type DocumentTranslations = {
+    scanIDInBrowser?: string;
+    useYourDeviceCamera?: string;
+    success?: string;
+    processingFinished?: string;
+    largeFile?: string;
+    selectSmallerFile?: string;
+    versionNotSupported?: string;
+    updateBrowser?: string;
+    licenseError?: string;
+    licenseExpired?: string;
+    fileCorrupt?: string;
+    selectAnotherFile?: string;
+    timeout?: string;
+    error?: string;
+    somethingWentWrong?: string;
+    tryAgain?: string;
+    fromCamera?: string;
+    fromGallery?: string;
+    processing?: string;
+    preparingService?: string;
+    detectingDocument?: string;
+    placeDocumentIntoFrame?: string;
+    positionDocumentCenter?: string;
+    noFocus?: string;
+    moveCloser?: string;
+    glaresOnDocument?: string;
+    holdDocumentStraight?: string;
+    documentProcessing?: string;
+    flipDocument?: string;
+    cameraUnavailable?: string;
+    preparingCamera?: string;
+    noCameraAvailable?: string;
+    incorrectCameraId?: string;
+    allowAccessToCamera?: string;
+    cameraConnection?: string;
+    checkCameraId?: string;
+    verified?: string;
+    photoCapturedSuccessfully?: string;
+    uploadPhoto?: string;
+    useCameraOrGallery?: string;
+};
+export declare type Locales = keyof typeof dictionaries | string;
+export declare type DocumentDictionaries = Partial<Record<Locales, DocumentTranslations>>;
+export declare type XY = {
+    x: number;
+    y: number;
+};
+export declare type Oval = {
+    axisX: number;
+    axisY: number;
+    center: XY;
+};
 export declare type FrameObject = {
     left: number;
     top: number;
     width: number;
     height: number;
 };
+export declare type WidthAndHeight = {
+    width: number;
+    height: number;
+};
 export declare type VideoParamsType = {
-    videoParams: {
-        width: number;
-        height: number;
-    };
-    videoContainerParams: {
-        width: number;
-        height: number;
-    };
+    videoElement: HTMLVideoElement | null;
+    videoParams: WidthAndHeight;
+    videoContainerParams: WidthAndHeight;
 };
-export declare type FacingModeType = 'user' | 'environment' | undefined;
+export declare type FacingModeType = keyof typeof CameraFacingMode;
 export declare type VideoStatusParamsType = {
-    videoStatus: streamStatus;
-    camera: CameraModel;
-    twoFacingModesAvailable: boolean;
+    videoStatus: StreamStatus;
+    camera: CameraTypes;
 };
 export declare type CaptureFrameType = {
-    capture: Uint8ClampedArray;
+    imageData: Array<ImageData>;
     raw: string;
     mimeType: string;
 };
-export declare type CaptureType = Array<Omit<CaptureFrameType, 'capture'>>;
+export declare type CaptureType = Array<Omit<CaptureFrameType, 'imageData'>>;
 export declare type CodeType = {
     code: number;
     images?: null;
@@ -46,97 +98,73 @@ export declare type UserAgentType = {
     vendor: string;
     vendorSub: string;
 };
-declare type FaceLivenessEyesType = {
-    predLeft: number;
-    predRight: number;
-    probLeft: number;
-    probRight: number;
-};
-declare type FaceLivenessOcclusionType = {
-    foreheadGlasses: boolean;
-    glasses: boolean;
-    hat: boolean;
-    medicineMask: boolean;
-    occlusion: boolean;
-    openedMouth: boolean;
-    sunglasses: boolean;
-};
-declare type FaceLivenessQualityType = {
-    blur: number;
-    brightness: number;
-    noise: number;
-};
-export declare type FaceLivenessServiceResponseType = {
+export declare type ConfigLivenessParams = {
+    ballSmoothingWeight: number;
+    circleRadiusToMinDim: number;
+    compressDepthMap: boolean;
+    debugOutput: boolean | undefined;
+    depthMapBits: number;
+    distNormalMaxDeviation: number;
+    dontShowReadinessTimeoutMs: number;
+    faceBestHeight: number;
+    fitFaceMultNear: number;
+    frameHeight: number;
+    frameWidth: number;
+    holdStillNearTimeoutMs: number;
+    holdStillNormalTimeoutMs: number;
+    maxPitchNear: number;
+    maxPitchNormal: number;
+    maxRollNormal: number;
+    maxYawNear: number;
+    maxYawNormal: number;
+    minReadinessNear: number;
+    minReadinessNormal: number;
+    moveAwayMultNear: number;
+    moveCloserMultNear: number;
+    nearTimeoutMs: number;
+    normalTimeoutMs: number;
+    numChannels: number;
+    numSectors: number;
+    pin: number[];
+    resizedFrameHeight: number;
+    resizedFrameWidth: number;
+    scenario: number;
+    showGraySectors: boolean;
+    showHintDurationMs: number;
+    showHintTimeoutMs: number;
+    sizeNormalMaxDeviation: number;
+    targetSectorRelChange: number;
+};
+export declare type FaceLivenessResultType = {
     code: number;
-    msg: string;
-    results: {
-        faceIdx: number;
-        livenessStatus: number;
-        metadata: {
-            ageNear: string;
-            ageNormal: string;
-            distance: number;
-            evaluationTime: number;
-            eyesNear: FaceLivenessEyesType;
-            eyesNormal: FaceLivenessEyesType;
-            faceQuality: {
-                details: Array<{
-                    attribute: string;
-                    score: number;
-                }>;
-                score: number;
-            };
-            faceTrackBreak: number;
-            occlusionNear: FaceLivenessOcclusionType;
-            occlusionNormal: FaceLivenessOcclusionType;
-            predArtMaskNear: number;
-            predArtMaskNormal: number;
-            predElectronicDeviceNear: number;
-            predElectronicDeviceNormal: number;
-            predGeometryClassifier: number;
-            predLivenessViewNear: number;
-            predLivenessViewNormal: number;
-            predOpticalFlow: number;
-            predShadesNear: number;
-            predShadesNormal: number;
-            predTotal: number;
-            probArtMaskNear: number;
-            probArtMaskNormal: number;
-            probElectronicDeviceNear: number;
-            probElectronicDeviceNormal: number;
-            probGeometryClassifier: number;
-            probOpticalFlow: number;
-            probShadesNear: number;
-            probShadesNormal: number;
-            qualityNear: FaceLivenessQualityType;
-            qualityNormal: FaceLivenessQualityType;
-            smileNear: string;
-            smileNormal: string;
-            symNear: number;
-            symNormal: number;
-        };
+    metadata: {
+        [key: string]: any;
     };
-    versionDescriptor: string;
-    versionSDK: string;
-    images: Array<string>;
+    sessionId: string;
+    status: number;
+    transactionId: string;
 };
-export declare type FaceLivenessResultType = Omit<FaceLivenessServiceResponseType, 'images'>;
-export declare type FaceLivenessResponseType = FaceLivenessServiceResponseType | {
-    code: number;
+export declare type FaceLivenessResponseType = FaceLivenessResultType & {
+    images: Array<string>;
 };
 export declare type FaceDetectionResponseType = {
     capture: Array<string>;
 };
-export declare type DocumentReaderResponseType = Response | {
-    code: number;
-};
-export declare type CameraSnapshotResponseType = Array<{
-    raw: string;
-    mimeType: string;
-}>;
-export declare type CustomErrorObjectType = {
-    type: WebComponentsError;
-    error?: Record<string, any> | string;
+export declare type DocumentReaderResponseType = Response;
+export declare type CameraSnapshotResponseType = CaptureType;
+export declare type FaceDebugOutput = {
+    cft: boolean;
+    face: {
+        height: number;
+        landmarks: Array<XY>;
+        pitch: number;
+        roll: number;
+        width: number;
+        x: number;
+        y: number;
+        yaw: number;
+    };
+    target: Oval;
 };
 export declare type ScenarioParamsType = {
     UVTorch?: number;
@@ -157,14 +185,6 @@ export declare type ScenarioParamsType = {
 export declare type InitDataType = {
     scenario: Array<ScenarioParamsType>;
 };
-export declare type UserFrameType = {
-    frameBottom: number;
-    frameLeft: number;
-    frameRight: number;
-    frameTop: number;
-    width: number;
-    height: number;
-};
 export declare type ImageInputParamType = {
     frameBottom: number;
     frameLeft: number;
@@ -173,10 +193,6 @@ export declare type ImageInputParamType = {
     light: number;
     resolutionType: number;
 };
-export declare type FrameParamsType = {
-    userFrame: UserFrameType;
-    serviceFrame: ImageInputParamType;
-} | null;
 export declare type ImageQualityCheck = {
     featureType: number;
     mean: number;
@@ -203,8 +219,8 @@ export declare type SupportedBrowserVersionsByOsType = {
     desktop: SupportedBrowserVersions;
 };
 declare type CustomEventDataType<R> = {
-    status: responseCode;
-    reason?: WebComponentsError;
+    status: ResponseCode;
+    reason?: keyof typeof ErrorTypes;
     response?: R;
 };
 interface DetailEvent<A, R> {
@@ -212,8 +228,134 @@ interface DetailEvent<A, R> {
     action: A;
     data: CustomEventDataType<R> | null;
 }
-export declare type FaceLivenessDetailType = DetailEvent<faceEventActions, FaceLivenessResponseType>;
-export declare type FaceCaptureDetailType = DetailEvent<faceEventActions, FaceDetectionResponseType>;
-export declare type DocumentReaderDetailType = DetailEvent<documentEventActions, DocumentReaderResponseType>;
-export declare type CameraSnapshotDetailType = DetailEvent<documentEventActions, CameraSnapshotResponseType>;
-export {};
+export declare type FaceLivenessDetailType = DetailEvent<FaceEventActions, FaceLivenessResponseType>;
+export declare type FaceCaptureDetailType = DetailEvent<FaceEventActions, FaceDetectionResponseType>;
+export declare type DocumentReaderDetailType = DetailEvent<DocumentEventActions, DocumentReaderResponseType>;
+export declare type CameraSnapshotDetailType = DetailEvent<DocumentEventActions, CameraSnapshotResponseType>;
+export declare type DocumentReaderImage = {
+    data: string;
+    light: number;
+    pageIdx: number;
+};
+export declare type DocumentReaderProcessParam = {
+    returnPackageForReprocess?: boolean;
+    returnUncroppedImage?: boolean;
+    scenario?: keyof typeof InternalScenarios;
+    multipageProcessing?: boolean;
+    timeout?: number;
+    timeoutFromFirstDetect?: number;
+    timeoutFromFirstDocType?: number;
+    resultTypeOutput?: Array<string>;
+    customParams?: Record<string, any>;
+    imageOutputMaxHeight?: number;
+    imageOutputMaxWidth?: number;
+    doublePageSpread?: boolean;
+    generateDoublePageSpreadImage?: boolean;
+    fieldTypesFilter?: Array<number>;
+    dateFormat?: string;
+    measureSystem?: number;
+    imageDpiOutMax?: number;
+    alreadyCropped?: boolean;
+    fastDocDetect?: boolean;
+    updateOCRValidityByGlare?: boolean;
+    returnCroppedBarcode?: boolean;
+    respectImageQuality?: boolean;
+    forceDocFormat?: number;
+    noGraphics?: boolean;
+    documentAreaMin?: number;
+    depersonalizeLog?: boolean;
+    multiDocOnImage?: boolean;
+    shiftExpiryDate?: number;
+    minimalHolderAge?: number;
+    mrzFormatsFilter?: Array<string>;
+    forceReadMrzBeforeLocate?: boolean;
+    parseBarcodes?: boolean;
+    splitNames?: boolean;
+    imageQa?: {
+        expectedPass?: Array<string>;
+        dpiThreshold?: number;
+        glaresCheck?: boolean;
+        glaresCheckParams?: {
+            imgMarginPart?: number;
+            maxGlaringPart?: number;
+        };
+    };
+};
+export declare type ProcessingRequest = {
+    processParam: DocumentReaderProcessParam;
+    imagesList?: Array<DocumentReaderImage>;
+    imageInputParam?: ImageInputParamType;
+};
+export declare type ImageProcessingRequest = {
+    processParam: Pick<DocumentReaderProcessParam, 'returnPackageForReprocess' | 'returnUncroppedImage' | 'scenario'>;
+};
+export declare type DevicesType = {
+    videoDevices: Array<MediaDeviceInfo>;
+    isCameraAllowed: boolean;
+};
+export interface StreamDataType {
+    status: StreamStatus;
+    stream: MediaStream | null;
+    camera: CameraTypes;
+}
+export declare type StreamParams = {
+    cameraMode: FacingModeType;
+    preferredCameraId: string;
+    resolution: WidthAndHeight;
+};
+export declare type CameraTypes = {
+    selectedCamera: CameraModel;
+    frontCameras: Array<CameraModel>;
+    backCameras: Array<CameraModel>;
+};
+export declare type CurrentPage = {
+    data: Response | null;
+    startNextPage: () => Promise<void>;
+    finishRecognition: () => void;
+};
+declare global {
+    interface HTMLElementEventMap {
+        'face-liveness': CustomEvent<FaceLivenessDetailType>;
+        'face-capture': CustomEvent<FaceCaptureDetailType>;
+        'document-reader': CustomEvent<DocumentReaderDetailType>;
+        'camera-snapshot': CustomEvent<CameraSnapshotDetailType>;
+    }
+}
+interface IBaseComponent {
+    locale?: Locales;
+    copyright?: boolean;
+    'camera-id'?: string;
+    'change-camera'?: boolean;
+    'start-screen'?: boolean;
+}
+interface IDocumentBaseComponent extends IBaseComponent {
+    'start-screen'?: boolean;
+    multiple?: boolean;
+}
+export interface IFaceLiveness extends IBaseComponent {
+    url?: string;
+    debug?: boolean;
+}
+export interface IDocumentReader extends IDocumentBaseComponent {
+    'internal-scenario'?: keyof typeof InternalScenarios;
+    'multipage-processing'?: boolean;
+    license?: string;
+}
+export interface IFaceDetection extends IBaseComponent {
+    debug?: boolean;
+}
+export declare type ICameraSnapshot = IDocumentBaseComponent;
+export declare type FacePositionLivenessDetection = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export { default as DocumentReaderService } from './services/DocumentReaderService';
+export { default as DocumentReaderProcessor } from './services/DocumentReaderProcessor';
+export { default as DocumentReaderCaptureWebComponent } from './web-components/CameraSnapshot';
+export { default as DocumentReaderWebComponent } from './web-components/DocumentReader';
+export { default as FaceDetectionWebComponent } from './web-components/FaceDetection';
+export { default as FaceLivenessWebComponent } from './web-components/FaceLiveness';
+export { default as FullScreenContainer } from './web-components/FullScreenContainer';
+export { defineComponents } from './index-document';

package/lib/utils.d.ts

@@ -1,48 +1,7 @@
+import { DocumentCaptureStatus, ImageOutputType, ObjectFit } from './constants';
 import CameraModel from './models/CameraModel';
-export declare function contains(a: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}, b: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}): boolean;
-export declare function overlaps(a: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}, b: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}): boolean;
-export declare function touches(a: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}, b: {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-}): boolean;
-export declare function geTwoCorners({ top, left, height, width, }: {
-    top: number;
-    left: number;
-    height: number;
-    width: number;
-}): {
-    x1: number;
-    x2: number;
-    y1: number;
-    y2: number;
-};
+import { CameraTypes, CaptureFrameType, DevicesType, FaceDebugOutput, FacingModeType, FrameObject, StreamDataType, VideoParamsType, WidthAndHeight } from './types';
+import { Response } from './models/DocReaderWebclient/ext';
 export declare function uint8ArrayToBase64(arr: Uint8ClampedArray, videoFrame: {
     width: number;
     height: number;
@@ -52,14 +11,20 @@ export declare function saveByteArray(data: Uint8ClampedArray, name: string | nu
 export declare const convertBooleanAttributeParam: (attributeValue: string | null) => boolean | undefined;
 export declare const convertNumberAttributeParam: (attributeValue: string | null) => number | undefined;
 export declare function compose(...argsA: any): any;
-export declare function translateDetectionParams(captureFrameWidth: number, captureFrameHeight: number, captureFrameLeft: number, captureFrameTop: number, videoElementWidth: number, videoElementHeight: number, containerWidth: number, containerHeight: number, debug?: boolean): {
-    width: number;
-    height: number;
-    left: number;
-    top: number;
-};
+export declare function recalculateFrameSizes(videoWidth: number, videoHeight: number, containerWidth: number, containerHeight: number, frameWidth: number, frameHeight: number, frameX: number, frameY: number, objectFit: ObjectFit): FrameObject;
 export declare function getByteCount(b64: Array<string> | string): number;
 export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
-export declare function getBase64(files: FileList, maxImageWidthAndHeight: number, maxImageSizeWithoutResize: number, maxInputFilesSize: number, resizeValue: number, compression: number): Promise<Array<Promise<string>>>;
+export declare function getUintImages(files: FileList | Array<Blob>, resizeValue: number, maxBrowserSupportedResolution: number): Promise<Array<Promise<ImageData>>>;
 export declare function generateEvent<T>(type: string, detail: T): CustomEvent;
-export declare const getAvailableCameras: (cameraPool: CameraModel[], preferredCameraId?: string | undefined) => CameraModel | undefined;
+export declare const getAvailableCameras: (cameraPool: CameraModel[], preferredCameraId?: string) => CameraModel | undefined;
+export declare function calculateFrame(videoSize: WidthAndHeight, isLandscape: boolean, ratio: number, frameOffset: number): FrameObject;
+export declare function getVideosDevices(): Promise<DevicesType>;
+export declare function isBackCameraLabel(label: string, keywords: Array<string>): boolean;
+export declare function getCameras(preferredCameraType: FacingModeType, mediaDevices: DevicesType, preferredCameraId?: string): Promise<CameraTypes>;
+export declare const closeStreamTracks: (stream: MediaStream) => void;
+export declare function getVideo(resolution: WidthAndHeight, cameraTypes: CameraTypes, preferredCameraId?: string): Promise<StreamDataType>;
+export declare function getImageFromVideo(videoElement: HTMLVideoElement, outputType: ImageOutputType): CaptureFrameType;
+export declare function getNextCamera(camerasInfo: CameraTypes): string;
+export declare function drawFaceDebugOutput(canvas: HTMLCanvasElement, videoElementParams: VideoParamsType, debugOutput: FaceDebugOutput): void;
+export declare function mergeDeep<T, S, R>(target: T, source: S): R | T;
+export declare function getStatus(response: Response, pageIdx: number, multipageProcessing?: boolean): DocumentCaptureStatus.FINDING | DocumentCaptureStatus.SUCCESS | DocumentCaptureStatus.RESOLUTION | DocumentCaptureStatus.GLARE | DocumentCaptureStatus.FOCUS | DocumentCaptureStatus.HOLD | DocumentCaptureStatus.START_NEXT_PAGE | DocumentCaptureStatus.TIMEOUT;

package/lib/web-components/CameraSnapshot.d.ts

@@ -0,0 +1,14 @@
+import { DocumentDictionaries } from '../types';
+export default class DocumentReaderCaptureWebComponent extends HTMLElement {
+    private _root;
+    private _mounted;
+    private _translations;
+    constructor();
+    static get observedAttributes(): Array<string>;
+    attributeChangedCallback(name: string): void;
+    connectedCallback(): void;
+    set translations(dictionary: DocumentDictionaries | null);
+    get translations(): DocumentDictionaries | null;
+    render(): void;
+    disconnectedCallback(): void;
+}

package/lib/web-components/DocumentReader.d.ts

@@ -0,0 +1,14 @@
+import { DocumentDictionaries } from '../types';
+export default class DocumentReaderWebComponent extends HTMLElement {
+    private _root;
+    private _mounted;
+    private _translations;
+    constructor();
+    static get observedAttributes(): Array<string>;
+    attributeChangedCallback(name: string): void;
+    connectedCallback(): void;
+    set translations(dictionary: DocumentDictionaries | null);
+    get translations(): DocumentDictionaries | null;
+    render(): void;
+    disconnectedCallback(): void;
+}

package/lib/web-components/FaceDetection.d.ts

@@ -1,9 +1,9 @@
 export default class FaceDetectionWebComponent extends HTMLElement {
-    root: ShadowRoot;
-    mounted: boolean;
-    initialStyles: string;
+    private _root;
+    private _mounted;
     constructor();
     static get observedAttributes(): Array<string>;
+    get version(): string;
     attributeChangedCallback(name: string): void;
     connectedCallback(): void;
     render(): void;

package/lib/web-components/FaceLiveness.d.ts

@@ -1,14 +1,17 @@
 export default class FaceLivenessWebComponent extends HTMLElement {
-    root: ShadowRoot;
-    mounted: boolean;
-    requestHeaders: Record<string, string>;
-    initialStyles: string;
+    private _root;
+    private _mounted;
+    private _headers;
+    private _sessionIdValue;
     constructor();
     static get observedAttributes(): Array<string>;
     attributeChangedCallback(name: string): void;
     connectedCallback(): void;
     set headers(headersData: Record<string, string>);
     get headers(): Record<string, string>;
+    get version(): string;
+    set sessionId(id: string);
+    get sessionId(): string;
     render(): void;
     disconnectedCallback(): void;
 }

package/lib/web-components/FullScreenContainer.d.ts

@@ -1,4 +1,4 @@
 export default class FullScreenContainer extends HTMLElement {
-    root: ShadowRoot;
+    private _root;
     constructor();
 }