@jumio/websdk
Version:
Jumio WebSDK is a powerful, flexible software development kit that simplifies the integration of Jumio's services into your web applications.
10,323 lines • 341 kB
TypeScript
import { AcquisitionStatus as AcquisitionStatus_2 } from '../../../types/src/index.js';
import { ActionFunction } from 'xstate';
import { ActiveScreen as ActiveScreen_2 } from '../../../types/src/index.js';
import { ActiveScreen as ActiveScreen_3 } from '../../../../types/src/index.js';
import { ActiveTrackState as ActiveTrackState_2 } from '../../../../../websdk/src/index.js';
import { Actor } from 'xstate';
import { AnyEventObject } from 'xstate';
import { BehaviorSubject } from 'rxjs';
import { CameraFacingMode as CameraFacingMode_2 } from '../../../../../websdk/src/index.js';
import { CameraLivenessStatus as CameraLivenessStatus_2 } from '../../../types-internal/src/index.js';
import { Category as Category_2 } from '../../../api/src/index.js';
import { Category as Category_3 } from '../../../types/src/index.js';
import { Category as Category_4 } from '../../../../types/src/index.js';
import { ConsentDisplayType as ConsentDisplayType_2 } from '../../../api/src/index.js';
import { ConsentDisplayType as ConsentDisplayType_3 } from '../../../types/src/index.js';
import { ConsentDisplayType as ConsentDisplayType_4 } from '../../../../types/src/index.js';
import { Container } from 'inversify';
import { CountryCode as CountryCode_2 } from '../../../api/src/index.js';
import { CountryCode as CountryCode_3 } from '../../../../types/src/index.js';
import type { createStore } from '@ngneat/elf';
import { CrossDeviceOption as CrossDeviceOption_2 } from '../../../api/src/index.js';
import { CrossDeviceOption as CrossDeviceOption_3 } from '../../../types/src/index.js';
import { CrossDeviceOption as CrossDeviceOption_4 } from '../../../../types/src/index.js';
import { CSSResult } from 'lit';
import { DataStep as DataStep_2 } from '../../../types/src/index.js';
import { DataStep as DataStep_3 } from '../../../../types/src/index.js';
import { DeviceStore as DeviceStore_2 } from '../../../../../websdk/src/index.js';
import { DigitalIdentityType as DigitalIdentityType_2 } from '../../../api/src/index.js';
import { DigitalIdentityType as DigitalIdentityType_3 } from '../../../types/src/index.js';
import { DigitalIdentityType as DigitalIdentityType_4 } from '../../../../types/src/index.js';
import { DocumentStep as DocumentStep_2 } from '../../../types/src/index.js';
import { DocumentStep as DocumentStep_3 } from '../../../../types/src/index.js';
import { DocumentVariant as DocumentVariant_2 } from '../../../api/src/index.js';
import { DocumentVariant as DocumentVariant_3 } from '../../../types/src/index.js';
import { DocumentVariant as DocumentVariant_4 } from '../../../../types/src/index.js';
import { EntitiesRef } from '@ngneat/elf-entities';
import { EventCreator as EventCreator_2 } from '../../../../api/src/index.js';
import { EventCreator as EventCreator_3 } from '../../../api/src/index.js';
import { EventCreator as EventCreator_4 } from '../../../../../events/src/index.js';
import { EventDispatcher as EventDispatcher_2 } from '../../../../api/src/index.js';
import { EventDispatcher as EventDispatcher_3 } from '../../../api/src/index.js';
import { EventDispatcher as EventDispatcher_4 } from '../../../../../events/src/index.js';
import { EventMetadata as EventMetadata_2 } from '../../../../api/src/index.js';
import { EventMetadata as EventMetadata_3 } from '../../../api/src/index.js';
import { EventMetadata as EventMetadata_4 } from '../../../../../events/src/index.js';
import { EventObject } from 'xstate';
import { FacemapStep as FacemapStep_2 } from '../../../types/src/index.js';
import { FacemapStep as FacemapStep_3 } from '../../../../types/src/index.js';
import { FacemapVerificationMethod as FacemapVerificationMethod_2 } from '../../../api/src/index.js';
import { FacemapVerificationMethod as FacemapVerificationMethod_3 } from '../../../types/src/index.js';
import { FacemapVerificationMethod as FacemapVerificationMethod_4 } from '../../../../types/src/index.js';
import { FetchErrorParams as FetchErrorParams_2 } from '../../../types/src/index.js';
import { FileSource as FileSource_2 } from '../../../types/src/index.js';
import { FileStoreKey as FileStoreKey_2 } from '../../../types/src/index.js';
import { FinalizeResponse as FinalizeResponse_2 } from '../../../types/src/index.js';
import { getEntityType } from '@ngneat/elf-entities';
import { IdCaptureTypes as IdCaptureTypes_2 } from '../../../types/src/index.js';
import { IdFormat as IdFormat_2 } from '../../../api/src/index.js';
import { IdFormat as IdFormat_3 } from '../../../types/src/index.js';
import { IdFormat as IdFormat_4 } from '../../../../types/src/index.js';
import { IdSide as IdSide_2 } from '../../../api/src/index.js';
import { IdSide as IdSide_3 } from '../../../types/src/index.js';
import { IdSide as IdSide_4 } from '../../../../types/src/index.js';
import { IdStep as IdStep_2 } from '../../../types/src/index.js';
import { IdStep as IdStep_3 } from '../../../../types/src/index.js';
import { IdTypeUpload as IdTypeUpload_2 } from '../../../api/src/index.js';
import { IdTypeUpload as IdTypeUpload_3 } from '../../../../types/src/index.js';
import { interfaces } from 'inversify';
import { IproovTokenData as IproovTokenData_2 } from '../../../types/src/index.js';
import { JLiveFallbackPolicy as JLiveFallbackPolicy_2 } from '../../../api/src/index.js';
import { JLiveFallbackPolicy as JLiveFallbackPolicy_3 } from '../../../types/src/index.js';
import { JLiveFallbackPolicy as JLiveFallbackPolicy_4 } from '../../../../types/src/index.js';
import { JMediaDeviceInfo as JMediaDeviceInfo_2 } from '../../../../../websdk/src/index.js';
import { LitElement } from 'lit';
import { LivenessCaptureTypes as LivenessCaptureTypes_2 } from '../../../types/src/index.js';
import { LivenessFaceFinder as LivenessFaceFinder_2 } from '../../../../websdk/websdk/src/index.js';
import { Locale as Locale_2 } from '../../../types/src/index.js';
import { Locale as Locale_3 } from '../../../../types/src/index.js';
import { MachineContext } from 'xstate';
import { MediaDeviceMetadata as MediaDeviceMetadata_2 } from './events/types';
import { MetaObject } from 'xstate';
import { NavigationStep as NavigationStep_2 } from '../../../types/src/index.js';
import { NavigationStep as NavigationStep_3 } from '../../../../types/src/index.js';
import { NavigationStepCategoryData as NavigationStepCategoryData_2 } from '../../../types/src/index.js';
import { NavigationStepCategoryDocument as NavigationStepCategoryDocument_2 } from '../../../types/src/index.js';
import { NavigationStepCategoryFacemap as NavigationStepCategoryFacemap_2 } from '../../../types/src/index.js';
import { NavigationStepCategoryId as NavigationStepCategoryId_2 } from '../../../types/src/index.js';
import { NavigationStepVirtualStepFinish as NavigationStepVirtualStepFinish_2 } from '../../../types/src/index.js';
import { NavigationStepVirtualStepSetup as NavigationStepVirtualStepSetup_2 } from '../../../types/src/index.js';
import { NavigationStepVirtualStepStart as NavigationStepVirtualStepStart_2 } from '../../../types/src/index.js';
import { NavigationUrlTransformerParams as NavigationUrlTransformerParams_2 } from './types';
import { NonReducibleUnknown } from 'xstate';
import { nothing } from 'lit';
import { nothing as nothing_2 } from 'lit-html';
import { Observable } from 'rxjs';
import { PermissionStore as PermissionStore_2 } from '../../../../../websdk/src/index.js';
import { PredefinedType as PredefinedType_2 } from '../../../api/src/index.js';
import { PredefinedType as PredefinedType_3 } from '../../../types/src/index.js';
import { PredefinedType as PredefinedType_4 } from '../../../../types/src/index.js';
import { PropertyValues } from 'lit';
import type { PropsFactory } from '@ngneat/elf';
import { PublicError as PublicError_2 } from '../../../types/src/index.js';
import { QRCodeRenderersOptions } from 'qrcode';
import { QRCodeSegment } from 'qrcode';
import { ReactiveController } from 'lit';
import type { ReactiveControllerHost } from 'lit';
import { ReactiveElement } from 'lit';
import { ReasonCode as ReasonCode_2 } from '../../../types/src/index.js';
import { Ref } from 'lit/directives/ref.js';
import { Ref as Ref_2 } from 'lit-html/directives/ref.js';
import { RequestOutcome as RequestOutcome_2 } from '../../../types/src/index.js';
import { Resolution as Resolution_2 } from '../../../../../websdk/src/index.js';
import type { RumInitConfiguration } from '@datadog/browser-rum';
import { SdkType as SdkType_2 } from '../../../api/src/index.js';
import { SdkType as SdkType_3 } from '../../../types/src/index.js';
import { SdkType as SdkType_4 } from '../../../../types/src/index.js';
import { SensorData as SensorData_2 } from '../../../api/src/index.js';
import { StartStep as StartStep_2 } from '../../../types/src/index.js';
import { StartStep as StartStep_3 } from '../../../../types/src/index.js';
import { StateMachine } from 'xstate';
import { Static } from '@sinclair/typebox';
import { Store } from '@ngneat/elf';
import { Subject } from 'rxjs';
import { SVGTemplateResult } from 'lit';
import { TArray } from '@sinclair/typebox';
import { TBoolean } from '@sinclair/typebox';
import { TemplateResult } from 'lit-html';
import { TemplateResult as TemplateResult_2 } from 'lit';
import { TEnum } from '@sinclair/typebox';
import { TIntersect } from '@sinclair/typebox';
import { TLiteral } from '@sinclair/typebox';
import { TNull } from '@sinclair/typebox';
import { TNumber } from '@sinclair/typebox';
import { TObject } from '@sinclair/typebox';
import { Token as Token_2 } from '../../../types/src/index.js';
import { TOptional } from '@sinclair/typebox';
import { TRecord } from '@sinclair/typebox';
import { TSchema } from '@sinclair/typebox';
import { TString } from '@sinclair/typebox';
import { TUnion } from '@sinclair/typebox';
import { TUnknown } from '@sinclair/typebox';
import { UnaryFunction } from 'rxjs';
import { UploadResponse as UploadResponse_2 } from '../../../../types/src/index.js';
import { UploadStateBase as UploadStateBase_2 } from '../../../types/src/index.js';
import { url } from '*?url';
import { UsabilityCheckStateBase as UsabilityCheckStateBase_2 } from '../../../types/src/index.js';
import { UsabilityCheckStateBase as UsabilityCheckStateBase_3 } from '../../../../types/src/index.js';
import { UsabilityCheckStatus as UsabilityCheckStatus_2 } from '../../../../types/src/index.js';
import { UsabilityRejectResult as UsabilityRejectResult_2 } from '../../../../types/src/index.js';
import { UsabilityResult as UsabilityResult_2 } from '../../../types/src/index.js';
import { UUID as UUID_2 } from '../../../types/src/index.js';
import { VideoSizeInfo as VideoSizeInfo_2 } from '../../../../../websdk/src/index.js';
import { VideoSource as VideoSource_2 } from '../../../../../websdk/src/index.js';
import { VirtualStep as VirtualStep_2 } from '../../../types/src/index.js';
import { WorkflowStepDocumentController as WorkflowStepDocumentController_2 } from '../../../../core-api/src/index.js';
export declare type AcceptableConsentItem = Static<typeof TbAcceptableConsentItemSchema>;
export declare enum AcquisitionStatus {
Failed = "FAILED",
NotStarted = "NOT_STARTED",
Pending = "PENDING",
Retry = "RETRY",
Success = "SUCCESS"
}
export declare interface AcquisitionStatusResponse {
status: AcquisitionStatus;
error?: FetchError;
}
export declare type AcquisitionStatusType = Static<typeof TbAcquisitionStatus>;
export declare enum ActiveScreen {
Workflow = "workflow",
CrossDevice = "cross-device"
}
export declare enum ActiveScreenActions {
NavigateToWorkflow = "active-screen-navigate-to-workflow",
NavigateToCrossDevice = "active-screen-navigate-to-cross-device"
}
export declare type ActiveScreenType = Static<typeof TbActiveScreen>;
export declare type ActiveTrackState = Pick<MediaStreamTrack, 'contentHint' | 'enabled' | 'id' | 'kind' | 'label' | 'muted' | 'readyState'> & {
capabilities: MediaTrackCapabilities;
constraints: MediaTrackConstraints;
settings: MediaTrackSettings;
};
export declare interface Address {
addressLine?: string;
city?: string;
postcode?: string;
subdivision?: string;
}
export declare const aleKeyNotValid: ErrorCase;
export declare type AlternativeTexts = Static<typeof TbAlternativeTextsSchema>;
export declare class AnalyticEvent<T extends AnalyticEventBody = AnalyticEventBody> extends CustomEvent<T> {
constructor(detail: T);
}
export declare type AnalyticEventBody<ET extends EventType = EventType, EN extends string = string, M extends EventMetadata = EventMetadata> = EventBodyBase<ET, EN, M>;
export declare const analytics: {
createAttributesChanged: EventCreator_3<"trace", "custom element attributes changed", {
attributes: Partial<Record<"baseUrl" | "dc" | "locale" | "sessionUrl" | "token", string>>;
}>;
attributesChanged: EventDispatcher_3< {
attributes: Partial<Record<"baseUrl" | "dc" | "locale" | "sessionUrl" | "token", string>>;
}>;
createWorkflowRestarted: EventCreator_3<"trace", "workflow restarted", EventMetadata_3>;
workflowRestarted: EventDispatcher_3<EventMetadata_3>;
createSensorDataEvent: EventCreator_3<"trace", "sensor data", SensorData_2>;
sensorData: EventDispatcher_3<SensorData_2>;
createVideoPlayThrowsEvent: EventCreator_3<"trace", "video thrown an error", {
name: string;
message: string;
stack?: string;
state: unknown;
}>;
videoPlayThrows: EventDispatcher_3< {
name: string;
message: string;
stack?: string;
state: unknown;
}>;
createCameraCaptureHintsShownEvent: EventCreator_3<"trace", "shown camera capture hints", {
visible: boolean;
}>;
shownCameraCaptureHints: EventDispatcher_3< {
visible: boolean;
}>;
crateBackMissingEvent: EventCreator_3<"trace", "back side of ID is missing", EventMetadata_3>;
backMissingEvent: EventDispatcher_3<EventMetadata_3>;
createFailedToFetchEvent: EventCreator_3<"trace", "failed to fetch", {
error: FetchErrorParams_2;
}>;
failedToFetch: EventDispatcher_3< {
error: FetchErrorParams_2;
}>;
createLivenessManualSelfieFallbackEvent: EventCreator_3<"trace", "liveness - manual selfie fallback", {
step: string;
reason: string;
}>;
livenessManualSelfieFallback: EventDispatcher_3< {
step: string;
reason: string;
}>;
createLivenessInitializedEvent: EventCreator_3<"trace", "liveness - initialized", {
step: string;
}>;
livenessInitialized: EventDispatcher_3< {
step: string;
}>;
createLivenessModuleLoadingFailedEvent: EventCreator_3<"trace", "liveness - module loading failed", {
step: string;
}>;
livenessModuleLoadingFailed: EventDispatcher_3< {
step: string;
}>;
createLivenessProgressEvent: EventCreator_3<"trace", "liveness - progress", {
jliveProgressCurrentStep: number;
jliveProgressStepsTotal: number;
jLiveStepDuration: number;
jLiveDuration: number;
cls?: CameraLivenessStatus_2;
clsm?: CameraLivenessStatus_2;
}>;
livenessProgressEvent: EventDispatcher_3< {
jliveProgressCurrentStep: number;
jliveProgressStepsTotal: number;
jLiveStepDuration: number;
jLiveDuration: number;
cls?: CameraLivenessStatus_2;
clsm?: CameraLivenessStatus_2;
}>;
createAutocaptureStateChangeEvent: EventCreator_3<"trace", "id autocapture - state change event", {
step: string;
autocaptureState: string;
autocaptureFallbackReason?: string;
}>;
autocaptureStateChangeEvent: EventDispatcher_3< {
step: string;
autocaptureState: string;
autocaptureFallbackReason?: string;
}>;
createUnhandledrejectionEvent: EventCreator_3<"trace", "unhandled promise rejection", {
name: string;
message: string;
stack?: string;
}>;
unhandledrejectionEvent: EventDispatcher_3< {
name: string;
message: string;
stack?: string;
}>;
createUncaughtErrorEvent: EventCreator_3<"trace", "uncaught error", {
name: string;
message: string;
stack?: string;
}>;
uncaughtErrorEvent: EventDispatcher_3< {
name: string;
message: string;
stack?: string;
}>;
createDefaultToDL: EventCreator_3<"trace", "missing idType - defaulting to DL", EventMetadata_3>;
defaultToDL: EventDispatcher_3<EventMetadata_3>;
createShownCameraAccessRequestScreenEvent: EventCreator_3<"screen", "camera access request", {
kind: "denied" | "prompt";
devices: MediaDeviceMetadata_2[];
}>;
shownCameraAccessRequestScreen: EventDispatcher_3< {
kind: "denied" | "prompt";
devices: MediaDeviceMetadata_2[];
}>;
createShowRetryScreenEvent: EventCreator_3<"screen", "retry", {
category?: Category_3;
rejectionReasons: Partial<Record<FileStoreKey_2, ReasonCode_2>>;
rejectionCodeKeys: Partial<Record<ReasonCode_2, FileStoreKey_2[]>>;
codes: ReasonCode_2[];
}>;
showRetryScreen: EventDispatcher_3< {
category?: Category_3;
rejectionReasons: Partial<Record<FileStoreKey_2, ReasonCode_2>>;
rejectionCodeKeys: Partial<Record<ReasonCode_2, FileStoreKey_2[]>>;
codes: ReasonCode_2[];
}>;
createShownFinishScreenEvent: EventCreator_3<"screen", "finish", {
outcome: RequestOutcome_2<FinalizeResponse_2 | undefined, unknown>;
}>;
shownFinishScreen: EventDispatcher_3< {
outcome: RequestOutcome_2<FinalizeResponse_2 | undefined, unknown>;
}>;
createShownCrossDeviceScreenEvent: EventCreator_3<"screen", "cross device", EventMetadata_3>;
shownCrossDeviceScreen: EventDispatcher_3<EventMetadata_3>;
createShownCrossDeviceFinishScreenEvent: EventCreator_3<"screen", "cross device finish", {
acquisitionStatus: AcquisitionStatus_2;
error?: PublicError_2;
}>;
shownCrossDeviceFinishScreen: EventDispatcher_3< {
acquisitionStatus: AcquisitionStatus_2;
error?: PublicError_2;
}>;
createShownErrorEvent: EventCreator_3<"screen", "error", EventMetadata_3>;
shownError: EventDispatcher_3<EventMetadata_3>;
getShownScreenEventReporter: (eventName: string) => [EventCreator_3<"screen", string, {
acquisitionStatus: AcquisitionStatus_2;
}>, EventDispatcher_3< {
acquisitionStatus: AcquisitionStatus_2;
}>];
createPublicErrorEvent: EventCreator_3<"screen", "public error", {
errorCode: string;
}>;
publicError: EventDispatcher_3< {
errorCode: string;
}>;
createSelectedCountryEvent: EventCreator_3<"action", "selected country", {
country: string | undefined;
}>;
selectedCountry: EventDispatcher_3< {
country: string | undefined;
}>;
createSelectedDocumentEvent: EventCreator_3<"action", "selected document", {
document: string;
}>;
selectedDocument: EventDispatcher_3< {
document: string;
}>;
createSelectedDocumentVariantEvent: EventCreator_3<"action", "selected document variant", {
variant: string;
}>;
selectedDocumentVariant: EventDispatcher_3< {
variant: string;
}>;
createClickedStartButtonEvent: EventCreator_3<"action", "clicked start button", EventMetadata_3>;
clickedStartButton: EventDispatcher_3<EventMetadata_3>;
createClickedRetryButtonEvent: EventCreator_3<"action", "clicked retry button", EventMetadata_3>;
clickedRetryButton: EventDispatcher_3<EventMetadata_3>;
createClickedCrossDeviceButtonEvent: EventCreator_3<"action", "clicked cross device button", EventMetadata_3>;
clickedCrossDeviceButton: EventDispatcher_3<EventMetadata_3>;
createClickedSendEmailButtonEvent: EventCreator_3<"action", "clicked send email button", EventMetadata_3>;
clickedSendEmailButton: EventDispatcher_3<EventMetadata_3>;
getEidasUrlEvent: EventCreator_3<"action", "get eIDAS url", EventMetadata_3>;
getEidasUrl: EventDispatcher_3<EventMetadata_3>;
createEmailSentError: EventCreator_3<"action", "email sent error", EventMetadata_3>;
emailSentError: EventDispatcher_3<EventMetadata_3>;
createClickedUploadButtonEvent: EventCreator_3<"action", "clicked file upload button", EventMetadata_3>;
clickedUploadButton: EventDispatcher_3<EventMetadata_3>;
createUploadedFileEvent: EventCreator_3<"action", "uploaded file", {
source: FileSource_2;
}>;
uploadedFile: EventDispatcher_3< {
source: FileSource_2;
}>;
createSettingsEvent: EventCreator_3<"arbitrary", "settings", {
credentials: unknown;
}>;
settings: EventDispatcher_3< {
credentials: unknown;
}>;
createRuntimeEvent: EventCreator_3<"arbitrary", "runtime", EventMetadata_3>;
runtime: EventDispatcher_3<EventMetadata_3>;
createShownConsentMessageEvent: EventCreator_3<"arbitrary", "shown consent message", EventMetadata_3>;
shownConsentMessage: EventDispatcher_3<EventMetadata_3>;
createUsedCaptureTypesEvent: EventCreator_3<"arbitrary", "capture types", {
livenessCaptureType?: LivenessCaptureTypes_2;
idCaptureType?: IdCaptureTypes_2;
xDeviceJourney: boolean;
usedAllCaptureTypes: (IdCaptureTypes_2 | LivenessCaptureTypes_2)[];
}>;
usedCaptureTypesEvent: EventDispatcher_3< {
livenessCaptureType?: LivenessCaptureTypes_2;
idCaptureType?: IdCaptureTypes_2;
xDeviceJourney: boolean;
usedAllCaptureTypes: (IdCaptureTypes_2 | LivenessCaptureTypes_2)[];
}>;
};
export declare class AppContainerComponent extends BaseComponent {
#private;
static styles: CSSResult[];
type: DsAppContainerLayoutType;
footerVisible: boolean;
set cameraFilterFn(value: CameraFilterFn | undefined);
get cameraFilterFn(): CameraFilterFn | undefined;
readonly layout$: Observable<DsAppContainerLayout>;
readonly layoutController: AsyncController<DsAppContainerLayout>;
constructor();
update(changedProperties: PropertyValues<this>): void;
render(): TemplateResult<1>;
}
export declare interface AppDisplayMode {
fullscreen: boolean;
standalone: boolean;
minimalUI: boolean;
browser: boolean;
windowControlsOverlay: boolean;
}
declare const appleOs: readonly ["macos", "ios", "ipad"];
declare type AppleOsNames = (typeof appleOs)[number];
export declare const areAllActiveConsentsGiven$: () => Observable<boolean>;
export declare const areAllFilesUploaded$: (credentialId: UUID) => Observable<boolean>;
export declare const areAllFilesUploadedSuccessfully: (credentialId: UUID) => boolean;
export declare const areWorkflowSetupParametersValid$: () => Observable<boolean>;
export declare const areWorkflowSetupParametersValid: (params?: unknown) => boolean;
export declare const asyncAnimationFrame: (callback: AsyncCallback) => Promise<void>;
declare type AsyncCallback = () => void;
declare class AsyncController<T, HasInitial extends boolean = false> implements ReactiveController {
#private;
constructor(host: ReactiveControllerHost, source$: Observable<T>);
constructor(host: ReactiveControllerHost, source$: Observable<T>, value: T);
hostConnected(): void;
hostDisconnected(): void;
get value(): HasInitial extends true ? T : T | undefined;
}
export declare const attributesChanged: EventDispatcher_2< {
attributes: Partial<Record<"baseUrl" | "dc" | "locale" | "sessionUrl" | "token", string>>;
}>;
export declare const authFailed: ErrorCase;
export declare type AutocaptureConditionCallback = (params: AutocaptureStore) => boolean;
export declare interface AutocaptureDocCornerData {
topLeft: AutocaptureDocXY;
topRight: AutocaptureDocXY;
bottomLeft: AutocaptureDocXY;
bottomRight: AutocaptureDocXY;
}
export declare interface AutocaptureDocPose {
timestamp: number;
cornerData: AutocaptureDocCornerData;
middlePoint: AutocaptureDocXY;
width: number;
height: number;
aspectRatio: number;
shift?: number;
shiftTime?: number;
}
export declare interface AutocaptureDocXY {
x: number;
y: number;
}
export declare interface AutocaptureFallbackToManualCaptureOnUserStrugglingParams {
smoothedFeedback$: Observable<AutocaptureFeedbackSmoothed | undefined>;
uniqueMessageCount?: number;
debounceTimeMs?: number;
}
export declare interface AutocaptureFeedback {
cornersVisible: boolean;
tooFar: boolean;
tooClose: boolean;
middlePointAligned: boolean;
allChecksPassed: boolean;
}
export declare interface AutocaptureFeedbackSmoothed extends AutocaptureFeedback {
successRate: number;
}
export declare interface AutocaptureGetPoseFeedbackParameters {
pose$: Observable<AutocaptureDocPose | undefined>;
docFinder$: Observable<AutocaptureStateDocFinderPosition>;
videoResolution$: Observable<Resolution>;
}
export declare enum AutocaptureState {
NOT_LOADED = "not-loaded",
LOADING = "loading",
ACTIVE = "active",
MANUAL_CAPTURE_FALLBACK = "manual-capture-fallback"
}
export declare const autocaptureStateChangeEvent: EventDispatcher_2< {
step: string;
autocaptureState: string;
autocaptureFallbackReason?: string;
}>;
export declare interface AutocaptureStateDocFinderPosition {
type: AutocaptureStateType.DocFinder;
edgeMarginRatio: number;
minFillRatio: number;
maxFillRatio: number;
cx: number;
cy: number;
radius: number;
}
export declare enum AutocaptureStateType {
DocFinder = "doc-finder"
}
export declare interface AutocaptureStore {
activationTime?: number;
docFinder: AutocaptureStateDocFinderPosition;
fallbackReason?: ManualCaptureFallbackReason;
feedback: AutocaptureFeedback | undefined;
fps?: number;
minMovementData: number;
smoothedFeedback: AutocaptureFeedbackSmoothed | undefined;
state: AutocaptureState;
}
export declare interface AutocaptureWorkerProcessedMessageCallback {
messageNotifier$: Subject<DaOutputEvent>;
errorNotifier$: Subject<unknown>;
docPoseNotifier$: Subject<AutocaptureDocPose | undefined>;
initializedSuccessfully?: () => void;
}
export declare class BackdropComponent extends BaseComponent {
#private;
static styles: CSSResult[];
clickToClose: boolean;
hidden: boolean;
dialogRole?: 'alertdialog' | 'dialog';
ariaLabelledBy: string;
connectedCallback(): void;
disconnectedCallback(): void;
firstUpdated(changedProperties: PropertyValues<this>): void;
render(): TemplateResult<1>;
}
export declare const backMissingEvent: EventDispatcher_2<EventMetadata_2>;
export declare interface BackupEntry {
backupGuid: string;
workflowState: WorkflowState;
navigationStep: NavigationStep;
}
export declare interface BackupEntryDescriptor extends BackupEntry {
descriptor: string;
}
export declare const backupRestoreState: (storesToIgnore?: string[]) => string;
export declare enum BarcodeFormat {
Pdf417 = "PDF417"
}
export declare type BarcodeFormatType = Static<typeof TbBarcodeFormat>;
export declare abstract class BaseComponent extends LitElement {
static styles: CSSResult[];
colorScheme: ColorScheme;
}
declare interface BaseEvent<T> extends EventLike<T>, TimestampLike {
}
export declare const blockingNetworkError: ErrorCase;
export declare class ButtonClickEvent extends CustomEvent<Event> {
constructor(detail: Event);
}
export declare type ButtonClickEventHandler = (e: ButtonClickEvent) => void;
export declare class ButtonComponent extends BaseComponent {
static styles: CSSResult[];
fluid: boolean;
type: ButtonType;
size: ButtonSize;
shape: ButtonShape;
padding: boolean;
disabled: boolean;
label: string;
render(): TemplateResult<1>;
handleClickEvent(event: Event): void;
}
export declare enum ButtonShape {
Default = "default",
Round = "round"
}
export declare enum ButtonSize {
Small = "small",
Medium = "medium",
Large = "large",
ExtraLarge = "extra-large"
}
export declare enum ButtonType {
Primary = "primary",
Secondary = "secondary",
Tertiary = "tertiary",
Quiet = "quiet",
QuietIcon = "quiet-icon",
Destructive = "destructive"
}
export declare const cameraCapture: EventDispatcher_4< {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
} & {
width: number;
height: number;
size: number;
type: string;
idAutocapture?: boolean;
idAutocaptureState?: CameraCaptureIdAutocaptureStateLogEvent;
idAutocaptureFallbackReason?: string;
timeSpentInStepMs?: number;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
}>;
export declare type CameraCaptureIdAutocaptureStateLogEvent = 'auto-capture' | 'manual-capture-fallback' | 'manual-capture';
export declare class CameraComponent extends BaseComponent implements CameraRenderingEngine {
#private;
static styles: CSSResult[];
applyConstraintCallback?: ConstraintsApply;
videoConstraints: GetMediaTrackConstraintSet;
backdropRenderingEngineCollection: CameraRenderingEngine[];
videoBackdropRenderingEngineCollection: CameraRenderingEngine[];
videoEngineRenderingCollection: CameraRenderingEngine[];
videoOverlayRenderingEngineCollection: CameraRenderingEngine[];
overlayRenderingEngineCollection: CameraRenderingEngine[];
semanticRenderingEngineCollection: CameraRenderingEngine[];
readonly videoRef: Ref_2<HTMLVideoElement>;
readonly canvasRendererRef: Ref_2<CameraRendererComponent>;
readonly controller: CameraComponentController;
originalResolution: Resolution | undefined;
connectedCallback(): void;
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
captureImage(): Promise<Blob>;
switchStream(e: SwitchCameraCommand | SwitchStreamCommand): Promise<VideoSource_2 | undefined>;
onVideoTick: VideoTickCallback;
onYuvProcessorAvailable: GetYuvProcessorCallback;
getImageData: GetImageDataCallback;
getBlob: GetBlobCallback;
getVideoElement(): HTMLVideoElement;
}
export declare class CameraComponentController implements ReactiveController {
#private;
constructor(host: CameraComponent);
hostConnected(): void;
restartStream(params: SwitchStreamCommand): Promise<VideoSource | undefined>;
stopStream({ videoSource, resetBusyState }: Pick<StopStreamParams, 'resetBusyState' | 'videoSource'>): void;
onVideoTick: VideoTickCallback;
onYuvProcessorAvailable: GetYuvProcessorCallback;
getCanvasProcessorCollection(): CameraRenderingEngine[];
}
export declare class CameraError extends DOMException {
constructor(message?: string);
}
export declare const CameraErrorName = "CameraError";
export declare enum CameraFacingMode {
Front = "front",
Back = "back",
NotAvailable = "not-available"
}
export declare const cameraFilterFn$: BehaviorSubject<CameraFilterFn | undefined>;
export declare type CameraFilterFn = (device: JMediaDeviceInfo | MediaDeviceInfo) => boolean | undefined;
export declare class CameraIconComponent extends BaseComponent {
static styles: CSSResult[];
selected: boolean;
enabled: boolean;
label: string;
info: string;
render(): TemplateResult<1>;
}
export declare const cameraInitializing: EventDispatcher_4<EventMetadata_4>;
export declare class CameraInternalLayoutComponent extends BaseComponent {
static styles: CSSResult[];
readonly containerElRef: Ref_2<HTMLDivElement>;
readonly refresh$: Subject<void>;
readonly size$: Observable<VideoSizeInfo_2>;
readonly sizeController: AsyncController<VideoSizeInfo_2, false>;
firstUpdated(changedProperties: PropertyValues<this>): void;
render(): TemplateResult<1>;
}
export declare class CameraLifecycleComponent extends LitElement {
#private;
static styles: CSSResult[];
set videoElement(value: HTMLVideoElement | undefined);
get videoElement(): HTMLVideoElement | undefined;
connectedCallback(): void;
disconnectedCallback(): void;
updatePlayingStatusVideo$: () => Observable<Partial<CameraStoreState>>;
render(): TemplateResult<1>;
}
declare type CameraLivenessStatus = CameraLivenessStatusWithDuplicates | CameraLivenessStatusWithoutDuplicates;
declare interface CameraLivenessStatusBase<T extends boolean = false> {
t: number;
l?: string;
y: T;
}
declare interface CameraLivenessStatusWithDuplicates extends CameraLivenessStatusBase<true> {
p: number;
q: number;
}
declare type CameraLivenessStatusWithoutDuplicates = CameraLivenessStatusBase;
export declare class CameraLoggerComponent extends BaseComponent {
#private;
static styles: CSSResult[];
debounceTime: number;
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
}
export declare const cameraMediaStreamTrack$: BehaviorSubject<MediaStreamTrack | undefined>;
export declare const cameraMediaStreamTrackProcessor$: BehaviorSubject<MediaStreamTrackProcessor<VideoFrame> | undefined>;
export declare const cameraPlaying: EventDispatcher_4< {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
}>;
export declare interface CameraPlayParams<T extends MediaStreamConstraints = MediaStreamConstraints> {
constraints: T;
applyConstraints?: ConstraintsApply;
timeoutMs?: number;
}
export declare class CameraRendererComponent extends LitElement implements CameraRenderingEngine {
#private;
static styles: CSSResult[];
originalResolution: Resolution | undefined;
targetResolution: Resolution | undefined;
flipped: boolean;
renderingAllowed: boolean;
fitMode: CanvasFitMode;
render(): TemplateResult<1>;
onVideoTick: VideoTickCallback;
getImageData: GetImageDataCallback;
getBlob: GetBlobCallback;
onYuvProcessorAvailable: GetYuvProcessorCallback;
}
export declare interface CameraRenderingEngine {
getImageData?: GetImageDataCallback;
getBlob?: GetBlobCallback;
onVideoTick?: VideoTickCallback;
onYuvProcessorAvailable?: GetYuvProcessorCallback;
}
export declare class CameraSelectorComponent extends BaseComponent {
#private;
orientation: CameraSelectorOrientation;
set cameraFilterFn(value: CameraFilterFn | undefined);
get cameraFilterFn(): CameraFilterFn | undefined;
disconnectedCallback(): void;
update(changedProperties: PropertyValues<this>): void;
render(): TemplateResult<1>;
}
export declare enum CameraSelectorOrientation {
Vertical = "vertical",
Horizontal = "horizontal"
}
export declare const cameraStateChanged: EventDispatcher_4< {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
}>;
export declare const cameraStoreReset: () => void;
export declare interface CameraStoreState {
resolution: Resolution;
activeTrackState: ActiveTrackState | undefined;
cameraFacingMode: CameraFacingMode;
isPlaying: boolean;
isBusy: boolean;
}
export declare class CameraVideoTickerComponent extends LitElement {
#private;
static styles: CSSResult[];
set videoElement(value: HTMLVideoElement | undefined);
get videoElement(): HTMLVideoElement | undefined;
set videoTickCallback(value: VideoTickCallback | undefined);
get videoTickCallback(): VideoTickCallback | undefined;
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
}
export declare const cancelTypeUser: ErrorCase;
export declare enum CanvasFitMode {
Contain = "contain",
Cover = "cover"
}
export declare class CaptureButtonComponent extends BaseComponent {
static styles: CSSResult[];
disabled: boolean;
inactive: boolean;
label: string;
render(): TemplateResult<1>;
handleClickEvent(event: Event): void;
}
export declare class CaptureLabelComponent extends BaseComponent {
#private;
static styles: CSSResult[];
size: CaptureLabelSize;
ariaLiveMode: 'assertive' | 'off' | 'polite';
render(): unknown;
}
export declare enum CaptureLabelSize {
Medium = "medium",
Large = "large"
}
export declare class CaptureMessageContainerComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare const captureRequest$: BehaviorSubject<number | undefined>;
declare interface CaptureRequest {
dateNow: number;
performanceNow: number;
autocapture: boolean;
autocaptureFps?: number;
}
export declare interface CaptureStateMessageRenderer {
renderContents: RenderCaptureState;
renderCaptureImage: RenderCaptureState;
renderFront: RenderCaptureState;
renderFlipToBack: RenderCaptureState;
renderCaptured: RenderCaptureState;
capturePromptText: (step?: IdStep) => string;
}
export declare class CardClickEvent extends CustomEvent<Event> {
constructor(detail: Event);
}
export declare class CardComponent extends BaseComponent {
#private;
static styles: CSSResult[];
type: CardType;
header: string;
subheader: string;
tag: string;
size: CardSize;
disabled: boolean;
iconElements: HTMLElement[];
render(): TemplateResult_2<1> | symbol;
}
export declare class CardLightComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare class CardListComponent extends BaseComponent {
static styles: CSSResult[];
headerElements: HTMLElement[];
footerElements: HTMLElement[];
render(): TemplateResult<1>;
}
export declare enum CardSize {
Small = "small",
Medium = "medium",
Large = "large"
}
export declare enum CardType {
Primary = "primary",
Secondary = "secondary",
Tertiary = "tertiary"
}
export declare class CarrouselComponent extends BaseComponent {
#private;
static styles: CSSResult[];
innerWrapperEl: HTMLElement | null;
outerWrapperEl: HTMLElement | null;
images: HTMLImageElement[];
offset: number;
tileWidth: number;
tileHeight: number;
getOffsetTranslateX(): string;
isNavigationForwardEnabled(): boolean;
isNavigationBackwardEnabled(): boolean;
connectedCallback(): void;
disconnectedCallback(): void;
isScrollingAvailable(): boolean;
navigateTo(offset: number): void;
render(): TemplateResult_2<1>;
}
export declare class CarrouselNavigationEvent extends CustomEvent<number> {
constructor(detail: number);
}
export declare enum Category {
Id = "ID",
Facemap = "FACEMAP",
Document = "DOCUMENT",
Data = "DATA"
}
export declare type CategoryType = Static<typeof TbCategory>;
export declare const ccrLoadingFailed: ErrorCase;
export declare const certificateError: ErrorCase;
export declare interface CheckUsabilityParams {
resultKey: string;
}
export declare interface CheckUsabilityParamsWithId {
id: FileStoreKey;
usability: CheckUsabilityParams;
}
export declare const clickedCrossDeviceButton: EventDispatcher_2<EventMetadata_2>;
export declare const clickedRetryButton: EventDispatcher_2<EventMetadata_2>;
export declare const clickedSendEmailButton: EventDispatcher_2<EventMetadata_2>;
export declare const clickedStartButton: EventDispatcher_2<EventMetadata_2>;
export declare const clickedUploadButton: EventDispatcher_2<EventMetadata_2>;
export declare const clsAppendItem: (item: CameraLivenessStatus) => void;
export declare const clsr: () => void;
export declare enum ColorScheme {
Light = "light",
Dark = "dark",
Auto = "auto"
}
export declare class ColorSchemeComponent extends LitElement {
#private;
static styles: CSSResult[];
colorSchemeService: ColorSchemeService;
colorScheme: ColorScheme;
colorSchemeConfigs: ColorSchemeConfig[];
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
getBrowserColorScheme(): ColorScheme;
render(): TemplateResult<1>;
applyColorScheme(): void;
}
export declare interface ColorSchemeConfig {
colorScheme: ColorScheme;
}
export declare class ColorSchemeConfigComponent extends LitElement implements ColorSchemeConfig {
colorScheme: ColorScheme;
}
export declare const colorSchemeContext: {
__context__: ColorScheme;
};
export declare class ColorSchemeService {
#private;
readonly colorScheme$: Observable<ColorScheme>;
constructor();
setUserColorScheme(value: ColorScheme): void;
setBrowserColorScheme(value: ColorScheme): void;
getColorScheme(): ColorScheme;
}
export declare const colorSchemeServiceContext: {
__context__: ColorSchemeService;
};
declare interface ComponentControllerProvider<TComponentController> {
readonly componentController: TComponentController;
}
declare enum ConfigName {
FaceFinder = "face_finder",
FaceFinderLiveness = "face_finder_liveness",
FaceIdFinder = "face_id_finder",
FaceIdFinderLiveness = "face_id_finder_liveness",
IdFinder = "id_finder",
IdFinderLiveness = "id_finder_liveness",
IdLiveness = "id_liveness",
Premium = "premium",
PremiumWeb = "premium_web",
Standard = "standard",
StandardWeb = "standard_web"
}
export declare type ConfigurationAutocaptureSettings = Static<typeof TbConfigurationAutocaptureSettingsSchema>;
export declare type ConfigurationCamera = Static<typeof TbConfigurationCameraSchema>;
export declare type ConfigurationCameraResolution = Static<typeof TbConfigurationCameraResolutionSchema>;
export declare type ConfigurationCdnEnc = Static<typeof TbConfigurationCdnEncSchema>;
export declare type ConfigurationDataDog = Static<typeof TbConfigurationDataDogSchema>;
export declare type ConfigurationDocFinder = Static<typeof TbConfigurationDocFinderSchema>;
export declare type ConfigurationFileUpload = Static<typeof TbConfigurationFileUploadSchema>;
export declare type ConfigurationHelpScreen = Static<typeof TbConfigurationHelpScreenSchema>;
export declare type ConfigurationNetworkTimeouts = Static<typeof TbConfigurationNetworkTimeoutsSchema>;
export declare type Configurations = Static<typeof TbConfigurationsSchema>;
export declare type ConfigurationsLike = Static<typeof TbConfigurationsLikeSchema>;
export declare type ConfigurationSupplementalImage = Static<typeof TbConfigurationSupplementalImageSchema>;
export declare type ConfigurationSupplementalImageClassifier = Static<typeof TbConfigurationSupplementalImageClassifierSchema>;
export declare type ConfigurationSupplementalImagesV2 = Static<typeof TbConfigurationSupplementalImagesV2Schema>;
export declare class ConsentChangeEvent extends CustomEvent<ConsentData> {
constructor(detail: ConsentData);
}
export declare interface ConsentData {
consentGiven: boolean;
timestamp: number;
id: string;
}
export declare enum ConsentDisplayType {
Passive = "PASSIVE",
Active = "ACTIVE"
}
export declare type ConsentDisplayTypeType = Static<typeof TbConsentDisplayType>;
export declare type ConsentItem = Static<typeof TbConsentItemSchema>;
export declare type ConsentItemCollection = Static<typeof TbConsentItemCollectionSchema>;
export declare class ConsentPolicyComponent extends BaseComponent {
#private;
static styles: CSSResult[];
locale: Locale;
consentDto: ConsentItem[];
consentGiven: boolean;
render(): TemplateResult<1>;
}
export declare type ConstraintsApply = (params: ConstraintsParams) => Promise<MediaTrackSettings>;
export declare interface ConstraintsParams {
stream: MediaStream;
track: MediaStreamTrack;
}
declare type ControllerProvider<TWorkflowStepController, TComponentController> = ComponentControllerProvider<TComponentController> & WorkflowStepControllerProvider<TWorkflowStepController>;
declare interface Country {
code: CountryCode;
label: string;
}
export declare enum CountryCode {
ABW = "ABW",
AFG = "AFG",
AGO = "AGO",
AIA = "AIA",
ALA = "ALA",
ALB = "ALB",
AND = "AND",
ARE = "ARE",
ARG = "ARG",
ARM = "ARM",
ASM = "ASM",
ATA = "ATA",
ATF = "ATF",
ATG = "ATG",
AUS = "AUS",
AUT = "AUT",
AZE = "AZE",
BDI = "BDI",
BEL = "BEL",
BEN = "BEN",
BES = "BES",
BFA = "BFA",
BGD = "BGD",
BGR = "BGR",
BHR = "BHR",
BHS = "BHS",
BIH = "BIH",
BLM = "BLM",
BLR = "BLR",
BLZ = "BLZ",
BMU = "BMU",
BOL = "BOL",
BRA = "BRA",
BRB = "BRB",
BRN = "BRN",
BTN = "BTN",
BVT = "BVT",
BWA = "BWA",
CAF = "CAF",
CAN = "CAN",
CCK = "CCK",
CHE = "CHE",
CHL = "CHL",
CHN = "CHN",
CIV = "CIV",
CMR = "CMR",
COD = "COD",
COG = "COG",
COK = "COK",
COL = "COL",
COM = "COM",
CPV = "CPV",
CRI = "CRI",
CUB = "CUB",
CUW = "CUW",
CXR = "CXR",
CYM = "CYM",
CYP = "CYP",
CZE = "CZE",
DEU = "DEU",
DJI = "DJI",
DMA = "DMA",
DNK = "DNK",
DOM = "DOM",
DZA = "DZA",
ECU = "ECU",
EGY = "EGY",
ERI = "ERI",
ESH = "ESH",
ESP = "ESP",
EST = "EST",
ETH = "ETH",
FIN = "FIN",
FJI = "FJI",
FLK = "FLK",
FRA = "FRA",
FRO = "FRO",
FSM = "FSM",
GAB = "GAB",
GBR = "GBR",
GEO = "GEO",
GGY = "GGY",
GHA = "GHA",
GIB = "GIB",
GIN = "GIN",
GLP = "GLP",
GMB = "GMB",
GNB = "GNB",
GNQ = "GNQ",
GRC = "GRC",
GRD = "GRD",
GRL = "GRL",
GTM = "GTM",
GUF = "GUF",
GUM = "GUM",
GUY = "GUY",
HKG = "HKG",
HMD = "HMD",
HND = "HND",
HRV = "HRV",
HTI = "HTI",
HUN = "HUN",
IDN = "IDN",
IMN = "IMN",
IND = "IND",
IOT = "IOT",
IRL = "IRL",
IRN = "IRN",
IRQ = "IRQ",
ISL = "ISL",
ISR = "ISR",
ITA = "ITA",
JAM = "JAM",
JEY = "JEY",
JOR = "JOR",
JPN = "JPN",
KAZ = "KAZ",
KEN = "KEN",
KGZ = "KGZ",
KHM = "KHM",
KIR = "KIR",
KNA = "KNA",
KOR = "KOR",
KWT = "KWT",
LAO = "LAO",
LBN = "LBN",
LBR = "LBR",
LBY = "LBY",
LCA = "LCA",
LIE = "LIE",
LKA = "LKA",
LSO = "LSO",
LTU = "LTU",
LUX = "LUX",
LVA = "LVA",
MAC = "MAC",
MAF = "MAF",
MAR = "MAR",
MCO = "MCO",
MDA = "MDA",
MDG = "MDG",
MDV = "MDV",
MEX = "MEX",
MHL = "MHL",
MKD = "MKD",
MLI = "MLI",
MLT = "MLT",
MMR = "MMR",
MNE = "MNE",
MNG = "MNG",
MNP = "MNP",
MOZ = "MOZ",
MRT = "MRT",
MSR = "MSR",
MTQ = "MTQ",
MUS = "MUS",
MWI = "MWI",
MYS = "MYS",
MYT = "MYT",
NAM = "NAM",
NCL = "NCL",
NER = "NER",
NFK = "NFK",
NGA = "NGA",
NIC = "NIC",
NIU = "NIU",
NLD = "NLD",
NOR = "NOR",
NPL = "NPL",
NRU = "NRU",
NZL = "NZL",
OMN = "OMN",
PAK = "PAK",
PAN = "PAN",
PCN = "PCN",
PER = "PER",
PHL = "PHL",
PLW = "PLW",
PNG = "PNG",
POL = "POL",
PRI = "PRI",
PRK = "PRK",
PRT = "PRT",
PRY = "PRY",
PSE = "PSE",
PYF = "PYF",
QAT = "QAT",
REU = "REU",
ROU = "ROU",
RUS = "RUS",
RWA = "RWA",
SAU = "SAU",
SDN = "SDN",
SEN = "SEN",
SGP = "SGP",
SGS = "SGS",
SHN = "SHN",
SJM = "SJM",
SLB = "SLB",
SLE = "SLE",
SLV = "SLV",
SMR = "SMR",
SOM = "SOM",
SPM = "SPM",
SRB = "SRB",
SSD = "SSD",
STP = "STP",
SUR = "SUR",
SVK = "SVK",
SVN = "SVN",
SWE = "SWE",
SWZ = "SWZ",
SXM = "SXM",
SYC = "SYC",
SYR = "SYR",
TCA = "TCA",
TCD = "TCD",
TGO = "TGO",
THA = "THA",
TJK = "TJK",
TKL = "TKL",
TKM = "TKM",
TLS = "TLS",
TON = "TON",
TTO = "TTO",
TUN = "TUN",
TUR = "TUR",
TUV = "TUV",
TWN = "TWN",
TZA = "TZA",
UGA = "UGA",
UKR = "UKR",
UMI = "UMI",
URY = "URY",
USA = "USA",
UZB = "UZB",
VAT = "VAT",
VCT = "VCT",
VEN = "VEN",
VGB = "VGB",
VIR = "VIR",
VNM = "VNM",
VUT = "VUT",
WLF = "WLF",
WSM = "WSM",
XKX = "XKX",
YEM = "YEM",
ZAF = "ZAF",
ZMB = "ZMB",
ZWE = "ZWE"
}
export declare const crateBackMissingEvent: EventCreator_2<"trace", "back side of ID is missing", EventMetadata_2>;
export declare function createAnalyticEventCreatorAndDispatcher<ET extends EventType, EN extends string, M extends EventMetadata>(eventBody: Omit<AnalyticEventBody<ET, EN, M>, 'timestamp' | 'value'>): [EventCreator<ET, EN, M>, EventDispatcher<M>];
export declare const createAndAppendSlotFallback: <K extends keyof HTMLElementTagNameMap>({ root, slotName, fallbackContentTagName }: CreateAndAppendSlotParams<K>) => HTMLElementTagNameMap[K] | undefined;
export declare interface CreateAndAppendSlotParams<K extends keyof HTMLElementTagNameMap> {
root: ShadowRoot | null | undefined;
slotName: string;
fallbackContentTagName: K;
}
export declare const createAttributesChanged: EventCreator_2<"trace", "custom element attributes changed", {
attributes: Partial<Record<"baseUrl" | "dc" | "locale" | "sessionUrl" | "token", string>>;
}>;
export declare const createAutocaptureStateChangeEvent: EventCreator_2<"trace", "id autocapture - state change event", {
step: string;
autocaptureState: string;
autocaptureFallbackReason?: string;
}>;
export declare const createCameraCaptureEvent: EventCreator_4<"trace", "capture", {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
} & {
width: number;
height: number;
size: number;
type: string;
idAutocapture?: boolean;
idAutocaptureState?: CameraCaptureIdAutocaptureStateLogEvent;
idAutocaptureFallbackReason?: string;
timeSpentInStepMs?: number;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
}>;
export declare const createCameraCaptureHintsShownEvent: EventCreator_2<"trace", "shown camera capture hints", {
visible: boolean;
}>;
export declare const createCameraInitializing: EventCreator_4<"trace", "camera initializing", EventMetadata_4>;
export declare const createCameraPlaying: EventCreator_4<"trace", "camera playing", {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
}>;
export declare const createCameraStateChanged: EventCreator_4<"trace", "camera state changed", {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
}>;
export declare const createClickedCrossDeviceButtonEvent: EventCreator_2<"action", "clicked cross device button", EventMetadata_2>;
export declare const createClickedRetryButtonEvent: EventCreator_2<"action", "clicked retry button", EventMetadata_2>;
export declare const createClickedSendEmailButtonEvent: EventCreator_2<"action", "clicked send email button", EventMetadata_2>;
export declare const createClickedStartButtonEvent: EventCreator_2<"action", "clicked start button", EventMetadata_2>;
export declare const createClickedUploadButtonEvent: EventCreator_2<"action", "clicked file upload button", EventMetadata_2>;
export declare function createDatastoreContainer(overrides?: Partial<CreateDatastoreParams>): Container;
export declare interface CreateDatastoreParams {
credentialIdStoreFactory?: interfaces.SimpleFactory<CredentialIdStore, [string]>;
credentialFacemapStoreFactory?: interfaces.SimpleFactory<CredentialFacemapStore, [string]>;
credentialDocumentStoreFactory?: interfaces.SimpleFactory<CredentialDocumentStore, [string]>;
}
export declare const createDefaultToDL: EventCreator_2<"trace", "missing idType - defaulting to DL", EventMetadata_2>;
export declare const createEmailSentError: EventCreator_2<"action", "email sent error", EventMetadata_2>;
export declare const createErrorEvent: (error: unknown) => ErrorEvent;
export declare const createFailedToFetchEvent: EventCreator_2<"trace", "failed to fetch", {
error: FetchErrorParams;
}>;
export declare const createLivenessInitializedEvent: EventCreator_2<"trace", "liveness - initialized", {
step: string;
}>;
export declare const createLivenessManualSelfieFallbackEvent: EventCreator_2<"trace", "liveness - manual selfie fallback", {
step: string;
reason: string;
}>;
export declare const createLivenessModuleLoadingFailedEvent: EventCreator_2<"trace", "liveness - module loading failed", {
step: string;
}>;
export declare const createLivenessProgressEvent: EventCreator_2<"trace", "liveness - progress", {
jliveProgressCurrentStep: number;
jliveProgressStepsTotal: number;
jLiveStepDuration: number;
jLiveDuration: number;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
}>;
export declare const createPublicError: (errorCase: ErrorCase, call: RequestCode, detailCode: number) => PublicError;
export declare const createPublicErrorEvent: EventCreator_2<"screen", "public error", {
errorCode: string;
}>;
export declare function createReportEventCreatorAndDispatcher<ET extends EventType, EN extends string, M extends EventMetadata>(eventBody: Omit<ReportEventBody<ET, EN, M>, 'timestamp' | 'value'>): [EventCreator<ET, EN, M>, EventDispatcher<M>];
export declare const createRuntimeEvent: EventCreator_2<"arbitrary", "runtime", EventMetadata_2>;
export declare const createSelectedCountryEvent: EventCreator_2<"action", "selected country", {
country: string | undefined;
}>;
export declare const createSelectedDocumentEvent: EventCreator_2<"action", "selected document", {
document: string;
}>;
export declare const createSelectedDocumentVariantEvent: EventCreator_2<"action", "selected document variant", {
variant: string;
}>;
export declare const createSensorDataEvent: EventCreator_2<"trace", "sensor data", SensorData>;
export declare const createSettingsEvent: EventCreator_2<"arbitrary", "settings", {
credentials: unknown;
}>;
export declare const createShownCameraAccessRequestScreenEvent: EventCreator_2<"screen", "camera access request", {
kind: "denied" | "prompt";
devices: MediaDeviceMetadata[];
}>;
export declare const createShownConsentMessageEvent: EventCreator_2<"arbitrary", "shown consent message", EventMetadata_2>;
export declare const createShownCrossDeviceFinishScreenEvent: EventCreator_2<"screen", "cross device finish", {
acquisitionStatus: AcquisitionStatus;
error?: PublicError;
}>;
export declare const createShownCrossDeviceScreenEvent: EventCreator_2<"screen", "cross device", EventMetadata_2>;
export declare const createShownErrorEvent: EventCreator_2<"screen", "error", EventMetadata_2>;
export declare const createShownFinishScreenEvent: EventCreator_2<"screen", "finish", {
outcome: RequestOutcome<FinalizeResponse | undefined, unknown>;
}>;
export declare const createShowRetryScreenEvent: EventCreator_2<"screen", "retry", {
category?: Category;
rejectionReasons: Partial<Record<FileStoreKey, ReasonCode>>;
rejectionCodeKeys: Partial<Record<ReasonCode, FileStoreKey[]>>;
codes: ReasonCode[];
}>;
export declare interface CreateStateMachine {
credentials: JCredential[];
setWorkflowStepCallback?: SetWorkflowStep;
initialState?: CredentialStep | string;
snapshotValue?: StateMachineSnapshotValue;
}
export declare const createUncaughtErrorEvent: EventCreator_2<"trace", "uncaught error", {
name: string;
message: string;
stack?: string;
}>;
export declare const createUnhandledrejectionEvent: EventCreator_2<"trace", "unhandled promise rejection", {
name: string;
message: string;
stack?: string;
}>;
export declare const createUploadedFileEvent: EventCreator_2<"action", "uploaded file", {
source: FileSource;
}>;
export declare const createUsedCaptureTypesEvent: EventCreator_2<"arbitrary", "capture types", {
livenessCaptureType?: LivenessCaptureTypes;
idCaptureType?: IdCaptureTypes;
xDeviceJourney: boolean;
usedAllCaptureTypes: (IdCaptureTypes | LivenessCaptureTypes)[];
}>;
export declare const createVideoPlayThrowsEvent: EventCreator_2<"trace", "video thrown an error", {
name: string;
message: string;
stack?: string;
state: unknown;
}>;
export declare const createWorkflowFailedEvent: (metadata: WorkflowEventMetadata) => CustomEvent<WorkflowEventBody<"workflow:failed">>;
export declare const createWorkflowRestarted: EventCreator_2<"trace", "workflow restarted", EventMetadata_2>;
export declare const createWorkflowRetryEvent: (metadata: WorkflowEventMetadata) => CustomEvent<WorkflowEventBody<"workflow:retry">>;
export declare const createWorkflowStartEvent: (metadata: WorkflowEventMetadata) => CustomEvent<WorkflowEventBody<"workflow:start">>;
export declare const createWorkflowSuccessEvent: (metadata: WorkflowEventMetadata) => CustomEvent<WorkflowEventBody<"workflow:success">>;
export declare const credentailError: ErrorCase;
export declare interface CredentialDocumentStore {
getPageById: (id: string) => FilePartState | undefined;
removePagesWithOriginalFileGuid: () => void;
selectPagesFromStore$: () => Observable<FilePartState[]>;
upsertPageInStore: (data: FilePartState) => void;
destroy: () => void;
}
export declare class CredentialDocumentStoreImpl implements CredentialDocumentStore {
#private;
constructor(credential: JCredential<Category.Document>);
destroy(): void;
getPageById(id: string): FilePartState | undefined;
selectPagesFromStore$(): Observable<FilePartState[]>;
upsertPageInStore(data: FilePartState): void;
removePagesWithOriginalFileGuid(): void;
}
export declare interface CredentialFacemapState {
activeVerificationMethod: FacemapVerificationMethod | undefined;
}
export declare interface CredentialFacemapStore {
setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
setJLiveManualCaptureFallbackReason: (reason: ManualCaptureFallbackReason | undefined) => void;
selectJLiveManualCaptureFallbackReason$: () => Observable<ManualCaptureFallbackReason | undefined>;
selectJLiveFallbackError$: () => Observable<JLiveFallbackError | undefined>;
setJLiveFallbackError: (error: JLiveFallbackError | undefined) => void;
selectLivenessState$: () => Observable<CredentialFacemapState & LivenessState>;
setLivenessVisibleFaceFinder: (oval: LivenessRefDistance) => void;
selectLivenessVisibleFaceFinder$: () => Observable<LivenessRefDistance>;
selectLivenessAttempt$: () => Observable<number>;
selectLivenessFeedbackMessage$: () => Observable<UXDisplayMessage>;
selectLivenessScanning$: () => Observable<boolean>;
selectLivenessBackgroundColor$: () => Observable<string | undefined>;
setLivenessStoreToNextAttempt: () => void;
setLivenessStoreProgress: (progress: string) => void;
setLivenessStorePhotinusColor: (photinusColor: string | undefined) => void;
setLivenessStoreDisplayMessage: (displayMessage: UXDisplayMessage) => void;
setLivenessStoreCameraCommand: (cameraCommand: UXCameraCommand | undefined) => void;
setLivenessStoreUiCommand: (uiCommand: UXUICommand | undefined) => void;
selectLivenessProgress$: () => Observable<[number, number]>;
selectIproovTokenState$: () => Observable<IproovTokenState>;
getIproovTokenState: () => IproovTokenState;
patchIproovTokenState: (tokenData: Partial<IproovTokenState>) => void;
reset: () => void;
destroy: () => void;
}
export declare class CredentialFacemapStoreImpl implements CredentialFacemapStore {
#private;
constructor(credential: JCredential<Category.Facemap>);
destroy(): void;
setActiveFaceVerificationMethod(activeVerificationMethod: FacemapVerificationMethod | undefined): void;
setJLiveFallbackError(error: JLiveFallbackError | undefined): void;
selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason | undefined): void;
selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
getActiveFaceVerificationMethod(): FacemapVerificationMethod | undefined;
selectActiveFaceVerificationMethod$(): Observable<FacemapVerificationMethod | undefined>;
selectLivenessState$(): Observable<CredentialFacemapState & IproovTokenState & LivenessState>;
setLivenessVisibleFaceFinder(oval: LivenessRefDistance): void;
selectLivenessVisibleFaceFinder$(): Observable<LivenessRefDistance>;
selectLivenessAttempt$(): Observable<number>;
selectLivenessFeedbackMessage$(): Observable<UXDisplayMessage>;
selectLivenessScanning$(): Observable<boolean>;
selectLivenessBackgroundColor$(): Observable<string | undefined>;
setLivenessStoreToNextAttempt(): void;
setLivenessStoreProgress(progress: string): void;
setLivenessStorePhotinusColor(photinusColor: string | undefined): void;
setLivenessStoreDisplayMessage(displayMessage: UXDisplayMessage): void;
setLivenessStoreCameraCommand(cameraCommand: UXCameraCommand | undefined): void;
setLivenessStoreUiCommand(uiCommand: UXUICommand | undefined): void;
reset(): void;
selectLivenessProgress$(): Observable<[number, number]>;
selectIproovTokenState$(): Observable< {
iproovStatus: IproovTokenStatus;
iproovTokenData: IproovTokenData_2 | undefined;
iproovError: unknown;
iproovLatestOutcome: string;
iproovReady: boolean;
}>;
getIproovTokenState(): {
iproovStatus: IproovTokenStatus;
iproovTokenData: IproovTokenData_2 | undefined;
iproovError: unknown;
iproovLatestOutcome: string;
iproovReady: boolean;
};
patchIproovTokenState(tokenData: Partial<IproovTokenState>): void;
}
export declare interface CredentialIdStore {
patchIdUserSelection: (params: Partial<IdCredentialSelection>, settings?: Settings) => void;
selectSidesForSelectedDocument$: () => Observable<IdSide[]>;
selectIdTypesForCountryWithVariants$: () => Observable<IdType[]>;
selectIdTypesForCountry$: () => Observable<IdTypeUpload[]>;
selectIdTypeVariantCollection$: () => Observable<IdTypeVariant[]>;
selectIdTypeVariant$: () => Observable<IdTypeVariant>;
getIdUserSelection: () => IdCredentialSelection;
are2FilesUploaded: (credentialId: UUID) => boolean;
isUsabilityBackMissing: (credentialId: UUID) => IsUsabilityBackMissing;
selectIdUserSelection$: () => Observable<IdCredentialSelection>;
isCountryAndDocTypePredefined: () => boolean;
destroy: () => void;
}
export declare class CredentialIdStoreImpl implements CredentialIdStore {
#private;
constructor(credential: JCredential<Category.Id>);
are2FilesUploaded(credentialId: UUID): boolean;
isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
destroy(): void;
patchIdUserSelection(params: Partial<IdCredentialSelection>, settings?: {
linked?: boolean | undefined;
dvFileUploadEnabled?: boolean | undefined;
merchantSettings?: {
autoCapture?: {
idEnabled?: boolean | undefined;
docVEnabled?: boolean | undefined;
} | undefined;
branding?: {
primaryColor?: string | undefined;
accentColor?: string | undefined;
logoUri?: string | undefined;
} | undefined;
crossDevice?: {
link?: string | undefined;
crossDeviceOption?: CrossDeviceOption_3 | undefined;
enabled: boolean;
} | undefined;
crossDeviceOnly?: boolean | undefined;
datadog?: {
enabled: boolean;
merchantName: string;
} | undefined;
isExplicitUploadEnabled?: boolean | undefined;
isFileUploadEnabled?: boolean | undefined;
jLiveEnabled?: boolean | undefined;
skipLivenessGuidancePage?: boolean | undefined;
jLiveFallbackPolicy: JLiveFallbackPolicy_3;
} | undefined;
networkThrottlingLimit?: number | undefined;
redirects?: {
error?: string | undefined;
success?: string | undefined;
} | undefined;
returnImages?: boolean | undefined;
skipDocTypeSelection?: boolean | undefined;
iproovTokenData?: {
url: string;
token: string;
productType: "IPROOV_STANDARD" | "IPROOV_PREMIUM";
remainingAttempts: number;
} | undefined;
skipStartScreen?: boolean | undefined;
eidasUrl?: string | undefined;
timestamp: string;
configurations: {
focusScore?: string | undefined;
cvAnalytics?: string | undefined;
networkTimeouts?: {
finalize: number;
upload: number;
usability: number;
extractdata: number;
analytics: number;
reporting: number;
iproovtoken: number;
iproovvalidate: number;
cdn: number;
} | undefined;
cdnEnc?: {
name: string;
file: string;
key: string;
iv: string;
}[] | undefined;
shakeDetection?: string | undefined;
instantFeedback?: string | undefined;
docFinder?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
} | undefined;
consentURL?: string | undefined;
iproovMaxAttempts?: string | undefined;
skipConfirm?: string | undefined;
consentRequired?: string | undefined;
cvMrzThreshold?: string | undefined;
cdnPublicKey?: string | undefined;
maxRetries?: string | undefined;
iproovEnabled?: string | undefined;
maxPollingTime?: string | undefined;
barcodeScannerKey?: string | undefined;
dataPrivacyUrl?: string | undefined;
dataDog?: {
appId: string;
clientId: string;
} | undefined;
shakeScore?: string | undefined;
sardineClientId?: string | undefined;
fileUpload?: {
fallbackTimeInMs: number;
isFallbackUploadEnabled: boolean;
} | undefined;
jumioLiveness?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
retries: number;
minNearFarRatio: number;
maxFaceCenterDifference: number;
tooFarThreshold: number;
tooNearThreshold: number;
initialImages: number;
transitionImages: number;
nearImages: number;
farImages: number;
minTimePerDistanceInMs: number;
maxConsecutiveImageTimespanInMs: number;
imageResolutionWidth: number;
imageResolutionHeight: number;
imageCompression: number;
fallbackTimeInMs: number;
userFallbackAllowed: boolean;
minimumPseudoPitch: number;
maximumPseudoPitch: number;
minimumPseudoYaw: number;
maximumPseudoYaw: number;
} | undefined;
idAutocapture?: {
fallbackTimeInMs?: number | undefined;
excludeDevices?: string[] | undefined;
focusTimeInMs?: number | undefined;
} | undefined;
helpScreen?: {
ID: number;
FACEMAP: number;
DOCUMENT: number;
DATA: number;
} | undefined;
cameraData?: {
cameraTimeoutMs?: number | undefined;
resolutionId?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionFacemap?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionDocument?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
} | undefined;
sensorData?: {
intervalLog: number;
intervalSend: number;
} | undefined;
supplementalImagesV2?: {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
} | {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
}[] | undefined;
};
accountId: string;
acquisitionReference: string;
analyticsEnabled: boolean;
brandingEnabled: boolean;
consents: {
privacyPolicyUrl?: string | undefined;
id: string;
text: string;
displayType: ConsentDisplayType_3;
alternativeTexts: {
ar?: string | undefined;
bg?: string | undefined;
cs?: string | undefined;
da?: string | undefined;
de?: string | undefined;
el?: string | undefined;
en?: string | undefined;
en_GB?: string | undefined;
"en-GB"?: string | undefined;
en_US?: string | undefined;
"en-US"?: string | undefined;
es?: string | undefined;
es_MX?: string | undefined;
"es-MX"?: string | undefined;
et?: string | undefined;
fi?: string | undefined;
fr?: string | undefined;
he?: string | undefined;
hr?: string | undefined;
hu?: string | undefined;
hy?: string | undefined;
id?: string | undefined;
it?: string | undefined;
ja?: string | undefined;
ka_GE?: string | undefined;
"ka-GE"?: string | undefined;
km?: string | undefined;
km_KH?: string | undefined;
"km-KH"?: string | undefined;
ko?: string | undefined;
lt?: string | undefined;
ms?: string | undefined;
nl?: string | undefined;
no?: string | undefined;
pl?: string | undefined;
pt?: string | undefined;
pt_BR?: string | undefined;
"pt-BR"?: string | undefined;
ro?: string | undefined;
ru?: string | undefined;
sk?: string | undefined;
sr_Cyrl?: string | undefined;
"sr-Cyrl"?: string | undefined;
sr?: string | undefined;
sr_Latn?: string | undefined;
"sr-Latn"?: string | undefined;
sv?: string | undefined;
sw?: string | undefined;
th?: string | undefined;
tr?: string | undefined;
uk?: string | undefined;
vi?: string | undefined;
zh?: string | undefined;
zh_CN?: string | undefined;
"zh-CN"?: string | undefined;
zh_HK?: string | undefined;
"zh-HK"?: string | undefined;
};
}[];
countryForIp: string;
credentials: (({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload[];
predefinedType: PredefinedType;
} | undefined;
country?: {
values: CountryCode[];
predefinedType: PredefinedType;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category.Id;
requiredParts: IdSide_3[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_3[];
predefinedType: PredefinedType;
};
category: Category.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType;
};
category: Category.Document;
country: {
values: CountryCode[];
predefinedType: PredefinedType;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[];
deviceRiskTokenData: {
token: string;
sdkType: SdkType_3.Iovation;
}[];
maxFileUploadSize: number;
stateForIp: string;
supportedCountries: {
country: CountryCode;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
idType: IdTypeUpload;
variants: {
format?: IdFormat_3 | undefined;
variant: DocumentVariant_3;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[];
supportedDocumentTypes: {
translations?: {
[x: string]: string;
} | undefined;
code: string;
name: string;
maxPages: number;
}[];
workflowDefinitionKey: number;
}): void;
selectSidesForSelectedDocument$(): Observable<IdSide_3[]>;
selectIdTypesForCountryWithVariants$(): Observable< {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
idType: IdTypeUpload;
variants: {
format?: IdFormat_3 | undefined;
variant: DocumentVariant_3;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[]>;
selectIdTypesForCountry$(): Observable<IdTypeUpload[]>;
selectIdTypeVariantCollection$(): Observable< {
format?: IdFormat_3 | undefined;
variant: DocumentVariant_3;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[]>;
selectIdTypeVariant$(): Observable< {
format?: IdFormat_3 | undefined;
variant: DocumentVariant_3;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}>;
getIdUserSelection(): IdCredentialSelection;
selectIdUserSelection$(): Observable< {
selectedCountry: CountryCode | undefined;
selectedDigitalIdentity: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
selectedIdType: IdTypeUpload | undefined;
selectedDocumentVariant: DocumentVariant_3 | undefined;
selectedIdFormat: IdFormat_3 | undefined;
}>;
isCountryAndDocTypePredefined(): boolean;
}
export declare type CredentialStep = Category | VirtualStep;
export declare type CredentialStepType = Static<typeof TbCredentialStep>;
export declare enum CrossDeviceOption {
Default = "default",
EmailOnly = "email_only",
QrOnly = "qr_only"
}
declare const DaCameraEventName: {
readonly CameraInfo: "camera_info";
readonly CameraLivenessData: "camera_liveness_data";
readonly CameraLivenessEnd: "camera_liveness_end";
readonly CameraLivenessReqStatus: "camera_liveness_req_status";
readonly CameraLivenessStart: "camera_liveness_start";
readonly CameraLivenessStatus: "camera_liveness_status";
readonly ReqCameraLivenessData: "req_camera_liveness_data";
};
declare interface DaCameraInfoEvent extends BaseEvent<typeof DaCameraEventName.CameraInfo> {
}
declare interface DaCameraLivenessDataEvent extends BaseEvent<typeof DaCameraEventName.CameraLivenessData> {
}
declare type DaCameraLivenessStatusEvent = DaCameraLivenessWithDuplicatesEvent | DaCameraLivenessWithoutDuplicatesEvent;
declare interface DaCameraLivenessWithDuplicatesEvent extends BaseEvent<typeof DaCameraEventName.CameraLivenessStatus> {
duplicate_sequences: string;
duplicates_start_time: string;
have_duplicates: 'true';
num_duplicate_frames: string;
}
declare interface DaCameraLivenessWithoutDuplicatesEvent extends BaseEvent<typeof DaCameraEventName.CameraLivenessStatus> {
duplicate_sequences: string;
duplicates_start_time: string;
have_duplicates: 'false';
}
declare type DaCameraOutputEvent = DaCameraInfoEvent | DaCameraLivenessDataEvent | DaCameraLivenessStatusEvent | DaReqCameraLivenessDataEvent;
declare const DaDocIdEventName: {
readonly DocIdEnd: "doc_id_end";
readonly DocIdInfo: "doc_id_info";
readonly DocIdStart: "doc_id_start";
};
declare interface DaDocIdInfo extends BaseEvent<typeof DaDocIdEventName.DocIdInfo> {
corners: string;
}
declare type DaDocIdOutputEvent = DaDocIdInfo;
declare const DaImageEventName: {
readonly Image: "image";
readonly ImageWithEyes: "image_with_eyes";
};
declare type DaImageOutputEvent = DaImageWithEyesEvent;
declare interface DaImageWithEyesEvent extends BaseEvent<typeof DaImageEventName.ImageWithEyes> {
}
declare const DaLifecycleEventName: {
readonly GetConfig: "get_config";
readonly GetConfigResult: "get_config_result";
readonly Initialize: "initialize";
readonly InitializeError: "initialize_error";
readonly InitializeSuccess: "initialize_success";
readonly Ready: "ready";
readonly StartSession: "start_session";
readonly Terminate: "terminate";
};
declare interface DaLifecycleGetConfigResultEvent extends BaseEvent<typeof DaLifecycleEventName.GetConfigResult> {
names: string;
output_events: string;
}
declare interface DaLifecycleInitializeErrorEvent extends BaseEvent<typeof DaLifecycleEventName.InitializeError> {
reason: string;
}
declare interface DaLifecycleInitializeSuccessEvent extends BaseEvent<typeof DaLifecycleEventName.InitializeSuccess> {
event_names?: string;
throttled_events?: string;
max_events?: string;
}
declare type DaLifecycleOutputEvent = DaLifecycleGetConfigResultEvent | DaLifecycleInitializeErrorEvent | DaLifecycleInitializeSuccessEvent | DaLifecycleReadyEvent | DaLifecycleReadyWithMaxEventsEvent;
declare interface DaLifecycleReadyEvent extends BaseEvent<typeof DaLifecycleEventName.Ready> {
max_events?: string;
trigger_event?: string;
}
declare interface DaLifecycleReadyWithMaxEventsEvent extends BaseEvent<typeof DaLifecycleEventName.Ready> {
max_events: string;
trigger_event?: string;
}
declare interface DaLivenessDataBlobEvent extends BaseEvent<typeof DaLivenessEventName.DataBlob> {
}
declare interface DaLivenessEmptyPoseEvent extends BaseEvent<typeof DaLivenessEventName.Pose> {
}
declare const DaLivenessEventName: {
readonly DataBlob: "data_blob";
readonly Enroll: "enroll";
readonly FarNearImage: "far_near_image";
readonly FarPhotinusEnd: "far_photinus_end";
readonly FarPhotinusStart: "far_photinus_start";
readonly FmaEmaResult: "fma_ema_result";
readonly NearPhotinusEnd: "near_photinus_end";
readonly NearPhotinusStart: "near_photinus_start";
readonly PhotinusColorChanged: "photinus_color_changed";
readonly PhotinusPattern: "photinus_pattern";
readonly PhotinusResult: "photinus_result";
readonly Pose: "pose";
readonly PoseReady: "pose_ready";
readonly PoseStart: "pose_start";
readonly RefDistance: "ref_distance";
readonly RefDistanceCancel: "ref_distance_cancel";
readonly RefDistanceEnd: "ref_distance_end";
readonly SFSDResult: "sfsd_result";
readonly ServerDataBlob: "server_data_blob";
readonly SetMode: "set_mode";
readonly StartSession: "start_session";
readonly UserJourneyImage: "user_journey_image";
readonly Verify: "verify";
readonly VisorInfo: "visor_info";
readonly WebpEncodeTime: "webp_encode_time";
};
declare interface DaLivenessFarNearImageEvent extends BaseEvent<typeof DaLivenessEventName.FarNearImage> {
}
declare interface DaLivenessFarPhotinusEndEvent extends BaseEvent<typeof DaLivenessEventName.FarPhotinusEnd> {
}
declare interface DaLivenessFarPhotinusStartEvent extends BaseEvent<typeof DaLivenessEventName.FarPhotinusStart> {
}
declare interface DaLivenessFmaEmaResultEvent extends BaseEvent<typeof DaLivenessEventName.FmaEmaResult> {
}
declare type DaLivenessImagePropertyKey = `liveness_${number}`;
declare type DaLivenessImageTimestampPropertyKey = `liveness_${number}_timestamp`;
declare type DaLivenessImageTypePropertyKey = `liveness_${number}_type`;
declare interface DaLivenessLivenessSFSDResultEvent extends BaseEvent<typeof DaLivenessEventName.SFSDResult> {
}
declare interface DaLivenessNearPhotinusEndEvent extends BaseEvent<typeof DaLivenessEventName.NearPhotinusEnd> {
}
declare interface DaLivenessNearPhotinusStartEvent extends BaseEvent<typeof DaLivenessEventName.NearPhotinusStart> {
}
declare interface DaLivenessNonEmptyPoseEvent extends BaseEvent<typeof DaLivenessEventName.Pose> {
face_roi: string;
iod: string;
pseudo_pitch: string;
pseudo_yaw: string;
sequence_id: string;
shift?: string;
shift_time?: string;
}
declare type DaLivenessOutputEvent = DaLivenessDataBlobEvent | DaLivenessFarNearImageEvent | DaLivenessFarPhotinusEndEvent | DaLivenessFarPhotinusStartEvent | DaLivenessFmaEmaResultEvent | DaLivenessLivenessSFSDResultEvent | DaLivenessNearPhotinusEndEvent | DaLivenessNearPhotinusStartEvent | DaLivenessPhotinusPatternEvent | DaLivenessPhotinusResultEvent | DaLivenessPoseEvent | DaLivenessPoseReadyEvent | DaLivenessPoseStartEvent | DaLivenessRefDistanceCancelEvent | DaLivenessRefDistanceEndEvent | DaLivenessRefDistanceEvent | DaLivenessServerDataBlobEvent | DaLivenessSetModeEvent | DaLivenessUserJourneyImageEvent;
declare interface DaLivenessPhotinusPatternEvent extends BaseEvent<typeof DaLivenessEventName.PhotinusPattern> {
pattern: string;
}
declare interface DaLivenessPhotinusResultEvent extends BaseEvent<typeof DaLivenessEventName.PhotinusResult> {
}
declare type DaLivenessPoseEvent = DaLivenessEmptyPoseEvent | DaLivenessNonEmptyPoseEvent;
declare interface DaLivenessPoseReadyEvent extends BaseEvent<typeof DaLivenessEventName.PoseReady> {
}
declare interface DaLivenessPoseStartEvent extends BaseEvent<typeof DaLivenessEventName.PoseStart> {
}
declare interface DaLivenessRefDistanceCancelEvent extends BaseEvent<typeof DaLivenessEventName.RefDistanceCancel> {
}
declare interface DaLivenessRefDistanceEndEvent extends BaseEvent<typeof DaLivenessEventName.RefDistanceEnd> {
}
declare interface DaLivenessRefDistanceEvent extends BaseEvent<typeof DaLivenessEventName.RefDistance> {
is_near: '0' | '1';
}
declare type DaLivenessServerDataBlobEvent = DaLivenessServerDataBlobEventWithoutLivenessImagesEvent | DaLivenessServerDataBlobWithLivenessImagesEvent;
declare interface DaLivenessServerDataBlobEventWithoutLivenessImagesEvent extends BaseEvent<typeof DaLivenessEventName.ServerDataBlob> {
server_data: Uint8Array;
}
declare interface DaLivenessServerDataBlobWithLivenessImagesEvent extends BaseEvent<typeof DaLivenessEventName.ServerDataBlob> {
liveness_blob: Uint8Array;
[key: DaLivenessImagePropertyKey]: Uint8Array | undefined;
[key: DaLivenessImageTypePropertyKey | DaLivenessImageTimestampPropertyKey]: string | undefined;
best_image: DaLivenessImagePropertyKey;
capture_error?: string;
}
declare interface DaLivenessSetModeEvent extends BaseEvent<typeof DaLivenessEventName.SetMode> {
mode: Mode;
}
declare interface DaLivenessUserJourneyImageEvent extends BaseEvent<typeof DaLivenessEventName.UserJourneyImage> {
}
declare type DaOutputEvent = DaCameraOutputEvent | DaDocIdOutputEvent | DaImageOutputEvent | DaLifecycleOutputEvent | DaLivenessOutputEvent | DaServiceOutputEvent;
declare interface DaReqCameraLivenessDataEvent extends BaseEvent<typeof DaCameraEventName.ReqCameraLivenessData> {
}
export declare const darken: (hex: string, ratio: number) => string;
declare interface DaServiceCreateWasmInstanceSuccessEvent extends BaseEvent<typeof DaServiceEventMap.CreateWasmInstanceSuccess> {
}
declare interface DaServiceEncodedResponseEvent extends BaseEvent<typeof DaServiceEventMap.EncodedResponses> {
encoded_responses: Uint8Array<ArrayBuffer>;
encoded_responses_layouts: EncodedResponseLayout[];
}
declare const DaServiceEventMap: {
readonly CreateWasmInstance: "_create_wasm_instance";
readonly CreateWasmInstanceSuccess: "_create_wasm_instance_success";
readonly EncodedRequests: "encoded_requests";
readonly EncodedResponses: "encoded_responses";
readonly GetWorkerAvailabilityRequest: "_get_worker_availability_request";
readonly GetWorkerAvailabilityResponse: "_get_worker_availability_response";
readonly InitializeWasm: "_initialize_wasm";
};
declare interface DaServiceGetWorkerAvailabilityResponse extends BaseEvent<typeof DaServiceEventMap.GetWorkerAvailabilityResponse> {
state: Record<string, WorkerAvailability>;
}
declare type DaServiceOutputEvent = DaServiceCreateWasmInstanceSuccessEvent | DaServiceEncodedResponseEvent | DaServiceGetWorkerAvailabilityResponse;
export declare interface DataAcquisitionFetchParameters {
wasmModule: BufferSource;
assets: Uint8Array;
}
export declare interface DataAcquisitionParameters extends DataAcquisitionFetchParameters {
configName: ConfigName;
}
export declare enum DataCenter {
Eu = "eu",
Us = "us",
Sgp = "sgp"
}
export declare type DataCenterType = Static<typeof TbDataCenter>;
export declare enum DataStep {
Start = "data-start",
Finish = "data-finish"
}
export declare enum DecisionType {
PASS = "PASS",
REJECT = "REJECT",
NOT_AVAILABLE = "NOT_AVAILABLE"
}
export declare type DecisionTypeType = Static<typeof TbDecisionType>;
export declare const defaultToDL: EventDispatcher_2<EventMetadata_2>;
export declare const DEV: boolean;
export declare enum DeviceCategory {
Smartphone = "SMARTPHONE",
Tablet = "TABLET",
Desktop = "DESKTOP",
Other = "OTHER"
}
export declare type DeviceCategoryType = Static<typeof TbDeviceCategory>;
export declare interface DeviceDetails extends Record<string, unknown> {
'sdk-platform': string;
ua: string;
hostname: string;
runtime: string;
iframe: boolean;
jumioHosted: boolean;
webview: boolean;
version: string;
browserName?: string;
browserVersion?: string;
browserMajor?: string;
deviceModel?: string;
deviceVendor?: string;
osName?: string;
osVersion?: string;
}
export declare type DeviceIdConstraint = Static<typeof TbDeviceIdConstraintSchema>;
export declare const deviceIsOffline: ErrorCase;
export declare class DeviceListLifecycleComponent extends BaseComponent {
#private;
static styles: CSSResult[];
connectedCallback(): void;
disconnectedCallback(): void;
render(): symbol;
}
export declare interface DeviceRisk {
token: string;
sdkType: SdkType;
}
export declare type DeviceRiskToken = Static<typeof TbDeviceRiskTokenSchema>;
declare const deviceStore$: Store< {
name: string;
state: DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
};
config: never;
}, DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
}>;
export declare interface DeviceStore {
deviceId: string | undefined;
}
export declare type DeviceStoreState = UnwrapObservable<typeof deviceStore$>;
export declare type DigitalIdentityProps = Static<typeof TbDigitalIdentityPropsSchema>;
export declare enum DigitalIdentityType {
BrazilianDrivingLicense = "BRA_PDF_DRIVING_LICENSE",
Mastercard = "MASTERCARD",
Eidas = "EIDAS"
}
export declare type DigitalIdentityTypesType = Static<typeof TbDigitalIdentityTypeSchema>;
export declare const dim: (hex: string, ratio: number) => string;
export declare const dispatchCameraErrorMessage: (message: Error) => void;
export declare const docPose$: Subject<AutocaptureDocPose | undefined>;
export declare interface DocumentResultResponse {
acquisitionGuid: string;
credentialGuid: string;
originCredentialFileGuid: string;
pageCount: number;
parts: Record<string, string>;
}
export declare enum DocumentStep {
UploadScreen = "document-upload",
MobileCapture = "document-mobile-capture",
Finish = "document-finish"
}
export declare enum DocumentTypeCode {
BC = "BC",// birth certificate
BS = "BS",// bank statement
CAAP = "CAAP",// cash advance application
CB = "CB",// council bill
CC = "CC",// credit card
CCS = "CCS",// credit card statement
CRC = "CRC",// corporate resolution certificate
HCC = "HCC",// health care card
IC = "IC",// insurance card
LAG = "LAG",// lease agreement
LOAP = "LOAP",// loan application
MEDC = "MEDC",// medicare card
MOAP = "MOAP",// mortgage application
PB = "PB",// phone bill
SEL = "SEL",// school enrollment letter
SENC = "SENC",// seniors card
SS = "SS",// superannuation statement
SSC = "SSC",// social security card
STUC = "STUC",// student card
TAC = "TAC",// trade association card
TR = "TR",// tax return
UB = "UB",// utility bill
USSS = "USSS",// US social security card
VC = "VC",// voided check
VT = "VT",// vehicle title
WWCC = "WWCC",// working with children check
WP = "WP",
CUSTOM = "CUSTOM"
}
export declare type DocumentTypeCodeType = Static<typeof TbDocumentTypeCode>;
export declare enum DocumentVariant {
Paper = "PAPER",
Plastic = "PLASTIC"
}
export declare type DocumentVariantType = Static<typeof TbDocumentVariant>;
export declare class DropdownComponent extends BaseComponent {
#private;
static styles: CSSResult[];
options: DropdownOption[];
selection: string;
disabled: boolean;
label: string;
render(): TemplateResult<1>;
}
export declare interface DropdownOption {
label: string;
value: string;
}
export declare class DropdownSelectionEvent extends CustomEvent<DropdownOption> {
constructor(params: DropdownOption);
}
export declare type DsAppContainerLayout = DsAppContainerLayoutCaptureScreen | DsAppContainerLayoutGeneric;
export declare interface DsAppContainerLayoutCaptureScreen {
type: DsAppContainerLayoutType.CaptureScreen;
variant: DsAppContainerLayoutCaptureScreenVariant;
}
export declare enum DsAppContainerLayoutCaptureScreenVariant {
Small = "small",
Large = "large"
}
export declare interface DsAppContainerLayoutGeneric {
type: DsAppContainerLayoutType.Generic;
}
export declare enum DsAppContainerLayoutType {
Generic = "generic",
CaptureScreen = "capture-screen"
}
export declare class DsCameraSelectorComponent extends BaseComponent {
static styles: CSSResult[];
orientation: CameraSelectorOrientation;
items?: CameraIconComponent[];
render(): TemplateResult<1>;
}
export declare interface DsDimensions {
width: number;
height: number;
}
export declare const E2E_MESSAGE_WAIT_TIME_MS: number;
export declare const E2E_MIN_WAIT_TIME_MS: number;
export declare interface EidasResult {
state: EidasResultType;
}
export declare enum EidasResultType {
SUCCESS = "SUCCESS",
FAILURE = "FAILURE",
NOT_AVAILABLE = "NOT_AVAILABLE"
}
export declare interface EIDASUrlResponse {
url: string;
}
export declare enum EmailErrorReason {
NOT_TURNED_ON = 890,
OUT_OF_ATTEMPTS = 891,
INVALID_ADDRESS = 892,
UNKNOWN = 893
}
export declare type EmailErrorReasonType = Static<typeof TbEmailErrorReason>;
export declare interface EmailRequest {
locale: Locale;
address: string;
}
export declare interface EmailResponse {
success: boolean;
reason?: string;
rejectionCode?: number;
}
export declare const emailSentError: EventDispatcher_2<EventMetadata_2>;
export declare const embargoedCountry: ErrorCase;
declare interface EncodedResponseLayout {
startOffset: number;
dataBufferOffset: number;
length: number;
}
export declare const enumerateDevices$: (intervalMs?: number) => Observable<MediaDeviceInfo[]>;
export declare interface EPassport {
authenticationValid?: boolean;
authenticationSteps?: string;
additionalData?: string;
}
export declare interface ErrorCase {
domain: ErrorDomain;
message: string;
retry: boolean;
legacyCode: LegacyErrorCode;
}
export declare enum ErrorDomain {
NetworkProblems = "A",
SecureConnectionFailed = "B",
AuthenticationFailed = "C",
DeviceIsOffline = "E",
ResourceFailedToLoad = "F",
CancelledByEndUser = "G",
NoCameraConnection = "H",
ALEKeyInvalid = "I",
TransactionAlreadyFinished = "J",
UnsupportedDocumentCode = "K",
TransactionReferenceInvalid = "L",
TransactionCannotBeCompleted = "M",
SDKTokenError = "N"
}
export declare type ErrorDomainType = Static<typeof TbErrorDomain>;
export declare type ErrorHandler = (exception: unknown) => void;
export declare const errorHandler: <T = unknown>(element: HTMLElement, ...handlers: ErrorHandler[]) => UnaryFunction<Observable<T>, Observable<T>>;
export declare class ErrorMessageComponent extends BaseComponent {
static styles: CSSResult[];
title: string;
message: string;
overlay: boolean;
errorCode: string;
date: Date | null;
transactionId: string;
showDate: boolean;
buttonElements: HTMLElement[];
render(): TemplateResult_2<1>;
}
export declare interface EuAddress {
city?: string;
province?: string;
streetName?: string;
streetNumber?: string;
unitDetails?: string;
postalCode?: string;
}
export declare interface EventBody {
eventType: number;
timestamp: number;
payload: Record<string, unknown> & {
value: string;
level: LogLevel;
};
}
export declare interface EventBodyAttachments<M extends EventMetadata = EventMetadata> {
tags?: Tags;
metadata?: M;
}
export declare interface EventBodyBase<ET extends EventType, EN extends string, M extends EventMetadata> {
eventType: ET;
eventName: EN;
value: `${ET}:${EN}`;
level: LogLevel;
code: number;
timestamp: Date;
metadata?: M;
tags?: Tags;
}
export declare type EventBodyCreator<ET extends EventType = EventType, EN extends string = string, M extends EventMetadata = EventMetadata> = (params: EventBodyAttachments<M>) => LogEventBody<ET, EN, M>;
export declare type EventCreator<ET extends EventType, EN extends string, M extends EventMetadata> = (params?: EventBodyAttachments<M>) => LogEventBody<ET, EN, M>;
export declare type EventDispatcher<M extends EventMetadata = EventMetadata> = (self: HTMLElement, params?: EventBodyAttachments<M>) => void;
declare interface EventLike<T> {
event: T;
}
export declare type EventMetadata = Record<string, unknown>;
export declare type EventType = 'action' | 'arbitrary' | 'error' | 'screen' | 'trace';
declare interface EventWithToken {
event: Event;
token?: IproovTokenData;
}
export declare const EXECUTION_ENVIRONMENT: ExecutionEnvironment;
export declare enum ExecutionEnvironment {
EndToEnd = "e2e",
Production = "production",
Development = "development"
}
export declare interface ExtractedData {
country?: CountryCode;
idType?: IdTypeUpload;
issuingCountry?: CountryCode;
firstName?: string;
lastName?: string;
dateOfBirth?: string;
issuingDate?: string;
expiryDate?: string;
documentNumber?: string;
personalNumber?: string;
gender?: string;
nationality?: string;
placeOfBirth?: string;
address?: string;
city?: string;
subdivision?: string;
postalCode?: string;
mrzLine1?: string;
mrzLine2?: string;
mrzLine3?: string;
rawBarcodeData?: string;
}
export declare type ExtractedDataResponse = Record<string, ExtractedData>;
export declare enum ExtractionSide {
Front = "FRONT",
Back = "BACK"
}
export declare type ExtractionSideType = Static<typeof TbExtractionSide>;
export declare const extractNavigationStepInfo: <CS extends CredentialStep, NS extends NavigationStep<CS>>({ step, substep, credentialId, activeScreen, shouldStoreNavigationState }: NS) => NavigationStepMap[CS];
export declare type EyeTrackingData = Static<typeof TbEyeTrackingDataSchema>;
export declare enum FaceFinderBorderWidth {
Idle = "idle",
Scanning = "scanning"
}
export declare class FaceFinderComponent extends BaseComponent {
#private;
static styles: CSSResult[];
readonly canvasRef: Ref<HTMLCanvasElement>;
constructor();
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
handleScanningChange(scanning: boolean, withAnimation?: boolean): void;
render(): TemplateResult<1>;
restartAnimationLoop(): void;
stopAnimationLoop(): void;
drawCanvas(withAnimation?: boolean): void;
}
export declare type FaceFinderState = UnwrapObservable<ReturnType<typeof selectFaceFinderState$>>;
export declare enum FacemapStep {
Start = "identity-start",
VerificationMethodFailed = "identity-verification-method-failure",
Iproov = "identity-liveness",
IproovFailureSystem = "identity-liveness-failure-system",
IproovFinish = "identity-liveness-finish",
JumioStandard = "identity-jumio-standard",
JumioStandardGuidance = "identity-jumio-standard-guidance",
JumioStandardCaptureScreen = "identity-jumio-standard-capture-screen",
JumioStandardCaptureScreenLiveness = "identity-jumio-standard-capture-screen-liveness",
JumioStandardCaptureScreenLivenessLoading = "identity-jumio-standard-capture-screen-liveness-loading",
JumioStandardCaptureScreenCaptureFinish = "identity-jumio-standard-capture-screen-capture-finish",
JumioStandardCaptureScreenSelfie = "identity-jumio-standard-capture-screen-manual-selfie",
JumioStandardCaptureScreenUpload = "identity-jumio-standard-capture-screen-upload",
JumioStandardCaptureScreenUploadFailed = "identity-jumio-standard-capture-screen-upload-failed",
JumioStandardUsabilityCheck = "identity-jumio-standard-usability-check",
JumioStandardUsabilityCheckFailure = "identity-jumio-standard-usability-check-failure",
JumioStandardFinish = "identity-jumio-standard-finish",
NoVerificationMethodsLeft = "identity-no-verification-methods-left",
Finish = "identity-finish"
}
export declare type FacemapStore = ReturnType<typeof createStore<[PropsFactory<CredentialFacemapState & IproovTokenState & LivenessState, undefined>]>>;
export declare enum FacemapVerificationMethod {
IproovStandard = "IPROOV_STANDARD",
IproovPremium = "IPROOV_PREMIUM",
JumioStandard = "JUMIO_STANDARD",
JumioLiveness = "JUMIO_LIVENESS",
JumioPremium = "JUMIO_PREMIUM",
LivenessSeries = "LIVENESS_SERIES"
}
export declare type FacemapVerificationMethodType = Static<typeof TbFacemapVerificationMethodSchema>;
export declare type FacingModeConstraint = Static<typeof TbFacingModeConstraintSchema>;
export declare enum FacingModePreference {
User = "user",
Environment = "environment"
}
export declare const failedToFetch: EventDispatcher_2< {
error: FetchErrorParams;
}>;
export declare const FEATURE_WEBP_ENABLED: boolean;
export declare class FetchError extends DOMException {
readonly details: FetchErrorParams;
constructor(details: FetchErrorParams);
}
export declare interface FetchErrorParams {
httpStatus: number;
errorJson?: unknown;
errorText?: string;
message: string;
requestURI: string;
publicError?: PublicError;
}
export declare type FileListFilter = (files: File[]) => File[];
export declare class FileMultiUploadComponent extends BaseComponent {
#private;
static styles: CSSResult[];
loading: boolean;
images: FileMultiUploadComponentThumbnail[];
render(): TemplateResult_2;
}
declare interface FileMultiUploadComponentThumbnail {
id: string;
base64: string;
}
export declare interface FilePartResponse {
type?: string;
acquisitionGuid?: string;
credentialGuid?: string;
originCredentialFileGuid?: string;
credentialFileGuid: string;
classifier?: string;
base64?: string;
}
export declare interface FilePartState extends FilePartResponse {
selected?: boolean;
filename?: string;
}
export declare type FilePickerError = 'file-type' | 'max-file-size';
export declare const FilePickerErrorMessage = "filepickererror";
export declare class FilePickerErrorMessageEvent extends CustomEvent<FilePickerError> {
constructor(error: FilePickerError);
}
export declare class FileRemoveEvent extends CustomEvent<unknown> {
constructor();
}
export declare class FileSinkComponent extends BaseComponent {
#private;
static styles: CSSResult[];
filter: FileListFilter;
disconnectedCallback(): void;
render(): unknown;
firstUpdated(changedProperties: PropertyValues<this>): void;
}
export declare enum FileSource {
Camera = "camera",
Upload = "upload"
}
declare enum FileSource_3 {
Upload = "upload",
Clipboard = "clipboard"
}
export declare class FileSourceClipboardComponent extends BaseComponent {
#private;
disconnectedCallback(): void;
render(): unknown;
firstUpdated(changedProperties: PropertyValues<this>): void;
}
export declare class FileSourcePickerComponent extends BaseComponent {
#private;
static styles: CSSResult[];
dragging: boolean;
dragOver: boolean;
fileInputMultiple: boolean;
fileInputAccept: string;
fileInputDirectory: boolean;
fileInputAllowDirs: boolean;
fileInputWebkitDirectory: boolean;
fileInputCapture: boolean;
disconnectedCallback(): void;
render(): unknown;
firstUpdated(changedProperties: PropertyValues<this>): void;
clearFile(): void;
}
export declare type FileSourceType = Static<typeof TbFileSource>;
export declare type FileStoreKey = FileStoreKeyBRA_ID | FileStoreKeyDocument | FileStoreKeyFacemap | FileStoreKeyId | IdSequencePartName | LivenessSeriesPartName;
export declare type FileStoreKeyBRA_ID = `${UUID}_${IdTypeUpload.DigitalIdentity}_${UploadType.FrontSide}`;
declare type FileStoreKeyDocument = `${UUID}_${UploadType.Document}`;
declare type FileStoreKeyFacemap = JLivePartName | `${string}_JUMIO_LIVENESS_BLOB` | `${UUID}_${UploadType.Face}`;
declare type FileStoreKeyId = `${UUID}_${IdTypeUpload}_${UploadType.BackSide | UploadType.FrontSide}`;
declare type FileStoreRecord<T = string> = Partial<Record<FileStoreKey, T>>;
export declare class FilesUploadedEvent extends CustomEvent<FileUploadedParams> {
constructor(type: UploadEvents, params: FileUploadedParams);
}
export declare enum FileType {
WebP = "WEBP",
Png = "PNG",
Jpg = "JPG",
Jpeg = "JPEG",
Jpeg2000 = "JPEG_2000",
Pdf = "PDF",
Dat = "DAT"
}
export declare const fileTypeMessage: () => string;
export declare type FileTypeType = Static<typeof TbFileType>;
export declare class FileUploadComponent extends BaseComponent {
#private;
static styles: CSSResult[];
status: UploadStatus;
maxFileSize: number;
accept: string;
key: FileStoreKey | undefined;
previewImageUrl: string | undefined;
render(): TemplateResult_2;
}
declare interface FileUploadedParams {
source: FileSource_3;
files: File[];
}
export declare class FileUploadEvent extends CustomEvent<FileUploadParams> {
constructor(params: FileUploadParams);
}
export declare interface FileUploadParams {
file: File;
mimeType: string;
extension: string;
}
declare interface FileWithNameBase64Url {
name: FileStoreKey;
base64: string;
id: FileStoreKey;
}
export declare const filterOutUndesiredIphoneCameras: <T extends JMediaDeviceInfo | MediaDeviceInfo>(value: T) => boolean;
export declare interface FinalizeResponse {
extractDataExecuted: boolean;
}
export declare class FullscreenManager {
#private;
private static instance;
readonly fullscreenChange$: Observable<boolean>;
readonly fullscreenError$: Observable<void>;
private constructor();
static getInstance(): FullscreenManager;
static resetInstance(): void;
enterFullscreen(element?: HTMLElement): Promise<void>;
exitFullscreen(): Promise<void>;
isFullscreen(): boolean;
isFullscreenEnabled(): boolean;
getStrategy(): FullscreenStrategy | undefined;
toggleFullscreenMode(element?: HTMLElement): Promise<void>;
}
export declare class FullscreenModeButtonComponent extends BaseComponent {
#private;
static styles: CSSResult[];
elRef: Ref<HTMLElement> | undefined;
render(): TemplateResult<1>;
}
declare interface FullscreenStrategy {
requestFullscreen(element: HTMLElement): Promise<void>;
exitFullscreen(): Promise<void>;
isFullscreen(): boolean;
isFullscreenEnabled(): boolean;
cleanUp(): void;
}
export declare const generalNetworkError: ErrorCase;
declare const generateAction: (params: Partial<NavigationStep>) => {
type: string;
params: Partial<NavigationStep>;
};
export declare const generateBrazilianIdLink: () => string;
export declare interface GenerateCredentialParams {
credentialId: UUID;
previousStep: StepCallback;
nextStep: StepCallback;
}
/**
* You can visualize the state machine with [Stately](https://stately.ai/viz)
*/
export declare const generateStateMachineFromCredentials: ({ credentials, setWorkflowStepCallback, initialState }: CreateStateMachine) => StateMachine<MachineContext, AnyEventObject, {}, never, {
type: "setWorkflowStep";
params: NavigationStep;
}, never, never, {
step: VirtualStep.Setup | VirtualStep.Finish | {
start: StartStep;
};
activeScreen: ActiveScreen;
}, string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
readonly id: "@jumio/websdk workflow state machine";
readonly type: "parallel";
readonly states: {
readonly step: {
readonly id: "step";
readonly initial: string;
readonly states: {
readonly finish: {
readonly on: {
readonly "step-navigation-previous-step": string;
};
};
readonly start: {
readonly initial: StartStep.Start;
readonly states: {
readonly "start-screen-start": {
readonly on: {
readonly "start-screen-consent-screen": {
readonly target: StartStep.ConsentScreen;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep.ConsentScreen;
shouldStoreNavigationState: true;
activeScreen: ActiveScreen.Workflow;
};
};
};
readonly "start-screen-finish": {
readonly target: StartStep.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen.Workflow;
};
};
};
};
};
readonly "start-screen-consent": {
readonly on: {
readonly "start-screen-provide-consent": {
readonly target: StartStep.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: undefined;
step: VirtualStep.Start;
substep: StartStep.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen.Workflow;
};
};
};
};
};
readonly "start-screen-finish": {
readonly type: "final";
};
};
readonly on: {
readonly "step-navigation-next-step": {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen.Workflow;
};
};
};
};
readonly onDone: {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen.Workflow;
};
};
};
};
readonly setup: {
readonly on: {
readonly "step-navigation-next-step": {
readonly target: VirtualStep.Start;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
readonly step: VirtualStep.Start;
readonly substep: StartStep.Start;
readonly shouldStoreNavigationState: false;
readonly credentialId: undefined;
readonly activeScreen: ActiveScreen.Workflow;
};
};
};
};
};
};
readonly entry: ActionFunction<MachineContext, AnyEventObject, AnyEventObject, undefined, never, {
type: "setWorkflowStep";
params: NavigationStep;
}, never, never, EventObject>;
};
readonly activeScreen: {
readonly id: "active screen state machine";
readonly initial: ActiveScreen.Workflow;
readonly states: {
readonly workflow: {};
readonly "cross-device": {};
};
readonly on: {
readonly "active-screen-navigate-to-cross-device": {
readonly target: ".cross-device";
readonly actions: any;
};
readonly "active-screen-navigate-to-workflow": {
readonly target: ".workflow";
readonly actions: any;
};
};
};
};
}>;
export declare const generateUaVariations: () => string[];
export declare const getActiveCredentialId: () => string;
export declare const getActiveDevice: () => JMediaDeviceInfo | undefined;
export declare const getActiveTrackState: (store?: CameraStoreState & {
clsEntities: Record<number, CameraLivenessStatus>;
clsIds: number[];
}) => ActiveTrackState_2 | undefined;
export declare const getAllFileEntities: () => {
uploadEntities: Record<FileStoreKey, UploadState>;
uploadIds: FileStoreKey[];
} & {
usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
usabilityIds: FileStoreKey[];
};
export declare const getAutocaptureDocFinder: () => AutocaptureStateDocFinderPosition;
export declare const getAutocaptureFocusTime: () => number;
export declare const getAutocaptureState: () => AutocaptureStore;
export declare const getBackupByGuid: (guid: string) => RestoreFromBackup | undefined;
export declare type GetBlobCallback = () => Promise<Blob>;
export declare const getCameraConfiguration: () => {
cameraTimeoutMs?: number | undefined;
resolutionId?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionFacemap?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionDocument?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
} | undefined;
export declare const getCameraErrorMessage$: () => Observable<Error>;
export declare const getCameraStateLogData$: () => Observable< {
cameraState: {
resolution: Resolution_2;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode_2;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore_2 & {
deviceEntities: Record<string, JMediaDeviceInfo_2>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo_2>;
mockDeviceIds: string[];
};
permissionState: PermissionStore_2;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
};
}>;
export declare const getCaptureHintsState: () => HelpStore;
export declare const getClsItems: () => CameraLivenessStatus[];
export declare const getClsLatestItem: (timestamp?: number) => CameraLivenessStatus | undefined;
export declare const getClsMax: (timestamp?: number) => CameraLivenessStatus;
export declare const getConsents: () => MultipartConsent[];
export declare const getCredentialById: (credentialId: UUID) => JCredential;
export declare const getCustomerId: () => string;
export declare const getDefaultFaceCaptureConstraints: () => MediaTrackConstraintSet;
export declare const getDefaultVideoConstraints: () => MediaTrackConstraintSet;
export declare const getDisplayMode$: () => Observable<AppDisplayMode>;
export declare const getDocumentTranslationForLocale: (locale: Locale, translations: Record<string, string>) => string;
export declare const getEidasUrl: EventDispatcher_2<EventMetadata_2>;
export declare const getEidasUrlEvent: EventCreator_2<"action", "get eIDAS url", EventMetadata_2>;
export declare const getFallbackVideoResolution: () => {
width: number;
height: number;
};
export declare interface GetFilePartParams {
acquisitionId: string;
credentialId: UUID;
partId: string;
}
export declare const getGenericBrowserPermission: (name: PermissionName) => Observable<PermissionState>;
export declare function getIdVariant(params: IdCredentialSelection, supportedCountries: SupportedCountry[]): Generator<{
format?: IdFormat_3 | undefined;
variant: DocumentVariant_3;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}, void, unknown>;
export declare type GetImageDataCallback = () => Promise<ImageData>;
export declare const getJLiveFallbackPolicy: () => JLiveFallbackPolicy;
export declare const getLatestBackupGuid: () => string;
export declare const getMaxFileUploadLimit: () => number;
declare type GetMediaTrackConstraintSet = () => MediaTrackConstraintSet;
export declare const getMockedDeviceById: (deviceId: string) => JMediaDeviceInfo | undefined;
export declare const getPermissionByName$: (name: PermissionName) => Observable<never> | Promise<PermissionStatus>;
export declare const getPermissionState$: (name: PermissionName) => Observable<PermissionState>;
export declare const getPersistedTags: () => Tags;
export declare const getRecoveringState: () => boolean;
export declare const getSafariPermission: (name: PermissionName) => Observable<PermissionState>;
export declare const getSettings: () => {
linked?: boolean | undefined;
dvFileUploadEnabled?: boolean | undefined;
merchantSettings?: {
autoCapture?: {
idEnabled?: boolean | undefined;
docVEnabled?: boolean | undefined;
} | undefined;
branding?: {
primaryColor?: string | undefined;
accentColor?: string | undefined;
logoUri?: string | undefined;
} | undefined;
crossDevice?: {
link?: string | undefined;
crossDeviceOption?: CrossDeviceOption_3 | undefined;
enabled: boolean;
} | undefined;
crossDeviceOnly?: boolean | undefined;
datadog?: {
enabled: boolean;
merchantName: string;
} | undefined;
isExplicitUploadEnabled?: boolean | undefined;
isFileUploadEnabled?: boolean | undefined;
jLiveEnabled?: boolean | undefined;
skipLivenessGuidancePage?: boolean | undefined;
jLiveFallbackPolicy: JLiveFallbackPolicy;
} | undefined;
networkThrottlingLimit?: number | undefined;
redirects?: {
error?: string | undefined;
success?: string | undefined;
} | undefined;
returnImages?: boolean | undefined;
skipDocTypeSelection?: boolean | undefined;
iproovTokenData?: {
url: string;
token: string;
productType: "IPROOV_STANDARD" | "IPROOV_PREMIUM";
remainingAttempts: number;
} | undefined;
skipStartScreen?: boolean | undefined;
eidasUrl?: string | undefined;
timestamp: string;
configurations: {
focusScore?: string | undefined;
cvAnalytics?: string | undefined;
networkTimeouts?: {
finalize: number;
upload: number;
usability: number;
extractdata: number;
analytics: number;
reporting: number;
iproovtoken: number;
iproovvalidate: number;
cdn: number;
} | undefined;
cdnEnc?: {
name: string;
file: string;
key: string;
iv: string;
}[] | undefined;
shakeDetection?: string | undefined;
instantFeedback?: string | undefined;
docFinder?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
} | undefined;
consentURL?: string | undefined;
iproovMaxAttempts?: string | undefined;
skipConfirm?: string | undefined;
consentRequired?: string | undefined;
cvMrzThreshold?: string | undefined;
cdnPublicKey?: string | undefined;
maxRetries?: string | undefined;
iproovEnabled?: string | undefined;
maxPollingTime?: string | undefined;
barcodeScannerKey?: string | undefined;
dataPrivacyUrl?: string | undefined;
dataDog?: {
appId: string;
clientId: string;
} | undefined;
shakeScore?: string | undefined;
sardineClientId?: string | undefined;
fileUpload?: {
fallbackTimeInMs: number;
isFallbackUploadEnabled: boolean;
} | undefined;
jumioLiveness?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
retries: number;
minNearFarRatio: number;
maxFaceCenterDifference: number;
tooFarThreshold: number;
tooNearThreshold: number;
initialImages: number;
transitionImages: number;
nearImages: number;
farImages: number;
minTimePerDistanceInMs: number;
maxConsecutiveImageTimespanInMs: number;
imageResolutionWidth: number;
imageResolutionHeight: number;
imageCompression: number;
fallbackTimeInMs: number;
userFallbackAllowed: boolean;
minimumPseudoPitch: number;
maximumPseudoPitch: number;
minimumPseudoYaw: number;
maximumPseudoYaw: number;
} | undefined;
idAutocapture?: {
fallbackTimeInMs?: number | undefined;
excludeDevices?: string[] | undefined;
focusTimeInMs?: number | undefined;
} | undefined;
helpScreen?: {
ID: number;
FACEMAP: number;
DOCUMENT: number;
DATA: number;
} | undefined;
cameraData?: {
cameraTimeoutMs?: number | undefined;
resolutionId?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionFacemap?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionDocument?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
} | undefined;
sensorData?: {
intervalLog: number;
intervalSend: number;
} | undefined;
supplementalImagesV2?: {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
} | {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
}[] | undefined;
};
accountId: string;
acquisitionReference: string;
analyticsEnabled: boolean;
brandingEnabled: boolean;
consents: {
privacyPolicyUrl?: string | undefined;
id: string;
text: string;
displayType: ConsentDisplayType_3;
alternativeTexts: {
ar?: string | undefined;
bg?: string | undefined;
cs?: string | undefined;
da?: string | undefined;
de?: string | undefined;
el?: string | undefined;
en?: string | undefined;
en_GB?: string | undefined;
"en-GB"?: string | undefined;
en_US?: string | undefined;
"en-US"?: string | undefined;
es?: string | undefined;
es_MX?: string | undefined;
"es-MX"?: string | undefined;
et?: string | undefined;
fi?: string | undefined;
fr?: string | undefined;
he?: string | undefined;
hr?: string | undefined;
hu?: string | undefined;
hy?: string | undefined;
id?: string | undefined;
it?: string | undefined;
ja?: string | undefined;
ka_GE?: string | undefined;
"ka-GE"?: string | undefined;
km?: string | undefined;
km_KH?: string | undefined;
"km-KH"?: string | undefined;
ko?: string | undefined;
lt?: string | undefined;
ms?: string | undefined;
nl?: string | undefined;
no?: string | undefined;
pl?: string | undefined;
pt?: string | undefined;
pt_BR?: string | undefined;
"pt-BR"?: string | undefined;
ro?: string | undefined;
ru?: string | undefined;
sk?: string | undefined;
sr_Cyrl?: string | undefined;
"sr-Cyrl"?: string | undefined;
sr?: string | undefined;
sr_Latn?: string | undefined;
"sr-Latn"?: string | undefined;
sv?: string | undefined;
sw?: string | undefined;
th?: string | undefined;
tr?: string | undefined;
uk?: string | undefined;
vi?: string | undefined;
zh?: string | undefined;
zh_CN?: string | undefined;
"zh-CN"?: string | undefined;
zh_HK?: string | undefined;
"zh-HK"?: string | undefined;
};
}[];
countryForIp: string;
credentials: (({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload[];
predefinedType: PredefinedType_3;
} | undefined;
country?: {
values: CountryCode[];
predefinedType: PredefinedType_3;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category.Id;
requiredParts: IdSide_3[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_3[];
predefinedType: PredefinedType_3;
};
category: Category.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType_3;
};
category: Category.Document;
country: {
values: CountryCode[];
predefinedType: PredefinedType_3;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType_3;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[];
deviceRiskTokenData: {
token: string;
sdkType: SdkType_3.Iovation;
}[];
maxFileUploadSize: number;
stateForIp: string;
supportedCountries: {
country: CountryCode;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
idType: IdTypeUpload;
variants: {
format?: IdFormat_3 | undefined;
variant: DocumentVariant;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[];
supportedDocumentTypes: {
translations?: {
[x: string]: string;
} | undefined;
code: string;
name: string;
maxPages: number;
}[];
workflowDefinitionKey: number;
};
export declare const getShownScreenEventReporter: (eventName: string) => [EventCreator_2<"screen", string, {
acquisitionStatus: AcquisitionStatus;
}>, EventDispatcher_2< {
acquisitionStatus: AcquisitionStatus;
}>];
export declare const getStateMachineDataActions: (credentialId: UUID) => {
readonly Finish: `${string}:data-finish`;
};
export declare const getStateMachineDocumentActions: (credentialId: UUID) => {
readonly Finish: `${string}:document-finish`;
readonly UploadScreen: `${string}:document-upload-screen`;
readonly MobileCapture: `${string}:document-mobile-capture`;
};
export declare const getStateMachineFacemapActions: (credentialId: UUID) => {
readonly Start: `${string}:identity-start`;
readonly Iproov: `${string}:identity-liveness`;
readonly IproovFailureSystem: `${string}:identity-liveness-failure-system`;
readonly IproovFailureUser: `${string}:identity-liveness-failure-user`;
readonly IdentityFailureNoAttemptsLeft: `${string}:identity-failure-no-attempts-left`;
readonly IproovFinish: `${string}:identity-liveness-finish`;
readonly JumioStandard: `${string}:identity-jumio-standard`;
readonly JumioStandardGuidance: `${string}:identity-jumio-standard-guidance`;
readonly JumioStandardCaptureScreen: `${string}:identity-jumio-standard-capture-screen`;
readonly JumioStandardCaptureScreenLiveness: `${string}:identity-jumio-standard-capture-screen-liveness`;
readonly JumioStandardCaptureScreenLivenessLoading: `${string}:identity-jumio-standard-capture-screen-liveness-loading`;
readonly JumioStandardCaptureScreenLivenessRetry: `${string}:identity-jumio-standard-capture-screen-liveness-retry`;
readonly JumioStandardCaptureScreenSelfie: `${string}:identity-jumio-standard-capture-screen-selfie`;
readonly JumioStandardCaptureScreenCaptureFinish: `${string}:identity-jumio-standard-capture-screen-capture-finish`;
readonly JumioStandardCaptureScreenUpload: `${string}:identity-jumio-standard-capture-screen-upload`;
readonly JumioStandardCaptureScreenUploadFailed: `${string}:identity-jumio-standard-capture-screen-upload-failed`;
readonly JumioStandardUsabilityCheck: `${string}:identity-jumio-standard-usability-check`;
readonly JumioStandardUsabilityCheckSuccess: `${string}:identity-jumio-standard-usability-check-success`;
readonly JumioStandardUsabilityCheckFailure: `${string}:identity-jumio-standard-usability-check-failure`;
readonly NoVerificationMethodsLeft: `${string}:identity-no-verification-methods-left`;
readonly Finish: `${string}:identity-finish`;
};
export declare const getStateMachineIdActions: (credentialId: UUID) => {
readonly Start: `${string}:id-start`;
readonly DocTypeDecision: `${string}:id-doctype-decision`;
readonly DocTypeSelection: `${string}:id-doctype-selection`;
readonly DocTypeVariantSelection: `${string}:id-doctype-variant-selection`;
readonly CaptureSourceSelection: `${string}:id-capture-source-selection`;
readonly CaptureScreenEntry: `${string}:id-capture-screen-entry`;
readonly CaptureScreen: `${string}:id-capture-screen`;
readonly CaptureScreenDecision: `${string}:id-capture-screen-decision`;
readonly CaptureScreenPrepareForRecapturingBack: `${string}:id-capture-prepare-for-recapturing-back`;
readonly CaptureScreenFrontStart: `${string}:id-capture-screen-front-start`;
readonly CaptureScreenFront: `${string}:id-capture-screen-front`;
readonly CaptureScreenFrontFinish: `${string}:id-capture-screen-front-finish`;
readonly CaptureScreenBackStart: `${string}:id-capture-screen-back-start`;
readonly CaptureScreenBack: `${string}:id-capture-screen-back`;
readonly CaptureScreenBackFinish: `${string}:id-capture-screen-back-finish`;
readonly CaptureScreenComplete: `${string}:id-capture-screen-complete`;
readonly CaptureScreenUpload: `${string}:id-capture-screen-upload`;
readonly CaptureScreenUploadFailed: `${string}:id-capture-screen-upload-failed`;
readonly IdUsabilityCheck: `${string}:id-usability-check`;
readonly IdUsabilityCheckFailure: `${string}:id-usability-check-failure`;
readonly IdUsabilityCheckBackMissing: `${string}:id-usability-check-back-missing`;
readonly IdUsabilityCheckSuccess: `${string}:id-usability-check-success`;
readonly IdEidasCheckSuccess: `${string}:id-eidas-check-success`;
readonly IdUsabilitySupportedList: `${string}:id-usability-supported-list`;
readonly IdUsabilityCheckReset: `${string}:id-usability-check-reset`;
readonly Upload: `${string}:id-upload`;
readonly eIDAS: `${string}:eIDAS`;
readonly Finish: `${string}:id-finish`;
};
export declare const getStateMachineInstance: () => Actor<ReturnType<typeof generateStateMachineFromCredentials>>;
export declare const getStateMachineStartScreenActions: () => {
readonly Start: "start-screen-start";
readonly ConsentScreen: "start-screen-consent-screen";
readonly ProvideConsent: "start-screen-provide-consent";
readonly Finish: "start-screen-finish";
};
export declare const getSupplementalImageConfig$: (classifier: ConfigurationSupplementalImageClassifier) => Observable<{
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
} | undefined>;
export declare const getToken: () => TokenState;
export declare const getTransactionId: () => string;
export declare const getUpdatedDeviceListAsync: () => Promise<JMediaDeviceInfo[]>;
export declare const getUploadEntityById: (id: FileStoreKey) => getEntityType< {
uploadEntities: Record<FileStoreKey, UploadState>;
uploadIds: FileStoreKey[];
} & {
usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
usabilityIds: FileStoreKey[];
}, EntitiesRef<"uploadEntities", "uploadIds", "idKeyUpload">> | undefined;
export declare const getUsabilityCheckState: (id: FileStoreKey) => getEntityType< {
uploadEntities: Record<FileStoreKey, UploadState>;
uploadIds: FileStoreKey[];
} & {
usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
usabilityIds: FileStoreKey[];
}, EntitiesRef<"usabilityEntities", "usabilityIds", "idKeyUsability">> | undefined;
export declare const getUsabilityEntitiesByCategory: (credentialId: UUID) => UsabilityCheckState[];
export declare function getWorkerData(): Promise<DataAcquisitionFetchParameters>;
export declare function getWorkflowInstance(): WorkflowController;
export declare const getWorkflowMetadata: () => {
locale: Locale_2;
accountId: string;
workflowId: string;
workflowExecutionId: string | undefined;
};
export declare const getWorkflowNavigationStep: () => NavigationStepVirtualStepSetup_2 | NavigationStepVirtualStepStart_2 | NavigationStepCategoryId_2 | NavigationStepCategoryFacemap_2 | NavigationStepCategoryDocument_2 | NavigationStepCategoryData_2 | NavigationStepVirtualStepFinish_2;
export declare const getWorkflowState: () => WorkflowState;
export declare const getWorkflowStep: () => VirtualStep | Category_3;
export declare const getWorkflowSubstep: () => StartStep_2 | IdStep_2 | FacemapStep_2 | DocumentStep_2 | DataStep_2 | undefined;
export declare type GetYuvProcessorCallback = (params: GetYuvProcessorCallbackParams) => Promise<undefined>;
export declare interface GetYuvProcessorCallbackParams {
processor: MediaStreamTrackProcessor<VideoFrame> | undefined;
}
export declare class GuidanceFaceAnimationComponent extends BaseComponent {
#private;
static styles: CSSResult[];
isPremium: boolean;
render(): SVGTemplateResult;
}
export declare const hasPendingUploads$: (credentialId: UUID) => Observable<boolean>;
export declare const hasRejectedFiles$: (credentialId: UUID) => Observable<boolean>;
export declare interface HelpStore {
visible: boolean;
timeoutMs: number;
popupOnTimer: boolean;
allowedSubsteps: string[];
}
export declare interface HttpBackendError {
httpStatus: number;
message: string;
requestURI?: string;
}
export declare const iconStyles: CSSResult;
export declare const ID_CAPTURE_TYPES: {
readonly AutoCapture: "AUTO_CAPTURE";
readonly ManualCapture: "MANUAL_CAPTURE";
readonly Upload: "UPLOAD";
};
export declare type IdCaptureTypes = ObjectValues<typeof ID_CAPTURE_TYPES>;
export declare type IdCredentialSelection = Pick<StoreForIdCredential, 'selectedCountry' | 'selectedDigitalIdentity' | 'selectedDocumentVariant' | 'selectedIdFormat' | 'selectedIdType'>;
export declare enum IdFormat {
Id1 = "ID1",
Id2 = "ID2",
Id3 = "ID3",
None = "NONE"
}
export declare type IdFormatType = Static<typeof TbIdFormat>;
declare type IdSequencePartName = `${UUID}_ID_SEQUENCE_${UploadType.BackSide | UploadType.FrontSide}_${number}`;
export declare enum IdSide {
Front = "FRONT",
Back = "BACK",
None = "NONE"
}
export declare class IdSideComponent extends BaseComponent {
static styles: CSSResult[];
side: IdSide;
render(): unknown;
}
export declare type IdSideType = Static<typeof TbIdSideSchema>;
export declare enum IdStep {
CaptureScreenEntry = "id-capture-screen-entry",
CaptureScreen = "id-capture-screen",
CaptureScreenBack = "id-capture-screen-back",
CaptureScreenBackFinish = "id-capture-screen-back-finish",
CaptureScreenBackStart = "id-capture-screen-back-start",
CaptureScreenComplete = "id-capture-screen-complete",
CaptureScreenDecision = "id-capture-screen-decision",
CaptureScreenFront = "id-capture-screen-front",
CaptureScreenFrontFinish = "id-capture-screen-front-finish",
CaptureScreenPrepareForRecapturingBack = "id-capture-screen-prepare-for-recapturing-back",
CaptureScreenFrontStart = "id-capture-screen-front-start",
CaptureScreenUpload = "id-capture-screen-upload",
CaptureScreenUploadFailed = "id-capture-screen-upload-failed",
CaptureSourceSelection = "id-capture-source-selection",
DocTypeDecision = "id-doctype-decision",
DocTypeSelection = "id-doctype-selection",
DocTypeVariantSelection = "id-doctype-variant-selection",
Finish = "id-finish",
IdUsabilityCheck = "id-usability-check",
IdUsabilityCheckFailure = "id-usability-check-failure",
IdUsabilityCheckBackMissing = "id-usability-check-back-missing",
IdUsabilityCheckReset = "id-usability-check-reset",
IdUsabilitySupportedList = "id-usability-supported-list",
Start = "id-start",
Upload = "id-upload",
eIDAS = "eIDAS"
}
export declare type IdStore = ReturnType<typeof createStore<[PropsFactory<StoreForIdCredential, undefined>]>>;
export declare type IdType = Static<typeof TbIdTypeSchema>;
export declare enum IdTypeUpload {
Passport = "PASSPORT",
IdCard = "ID_CARD",
ResidencePermit = "RESIDENCE_PERMIT",
Visa = "VISA",
DrivingLicense = "DRIVING_LICENSE",
DigitalIdentity = "DIGITAL_IDENTITY"
}
export declare type IdTypeUploadType = Static<typeof TbIdTypeUploadSchema>;
export declare type IdTypeVariant = Static<typeof TbIdTypeVariantSchema>;
export declare type IdTypeVariantPart = Static<typeof TbIdTypeVariantPartSchema>;
export declare class ImageCapturedEvent extends CustomEvent<ImageCapturedEventParams> {
constructor(params: ImageCapturedEventParams);
}
export declare interface ImageCapturedEventParams {
blob: Blob;
width: number;
height: number;
}
export declare const ImageCapturedEventType = "imagecaptured";
export declare const imageFormatMapping: Record<string, FileType>;
export declare interface ImageQueueItem {
blob: Blob;
timestamp: Date;
step: WorkflowState['step'];
substep: WorkflowState['substep'];
credentialId: WorkflowState['credentialId'];
frameId: number;
}
export declare class ImageViewerComponent extends BaseComponent {
#private;
static styles: CSSResult[];
index: number;
images: HTMLImageElement[];
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult_2<1>;
}
export declare enum ImageViewerEventNames {
ImageViewerToggle = "imageviewertoggle"
}
export declare class ImageViewerRemoveEvent extends CustomEvent<ImageViewerRemoveEventParams> {
constructor(params: ImageViewerRemoveEventParams);
}
export declare interface ImageViewerRemoveEventParams {
name: string;
}
export declare class ImageViewerToggleEvent extends CustomEvent<unknown> {
constructor();
}
declare interface ImageWithBase64Url {
blob: Blob;
base64: string;
width: number;
height: number;
}
export declare class InputComponent extends BaseComponent {
#private;
static styles: CSSResult[];
size: InputSize;
placeholder: string;
disabled: boolean;
error: boolean;
errorMessage: string;
infoMessage: string;
inputType: string;
inputId: string;
label: string;
preIconElements: HTMLElement[];
postIconElements: HTMLElement[];
readonly inputRef: Ref_2<HTMLInputElement>;
render(): TemplateResult<1>;
}
export declare enum InputSize {
Small = "small",
Medium = "medium"
}
export declare interface IproovTokenData {
token: string;
url: string;
productType: string;
remainingAttempts: number;
}
export declare interface IproovTokenState {
iproovStatus: IproovTokenStatus;
iproovTokenData: IproovTokenData | undefined;
iproovError?: unknown;
iproovLatestOutcome: string;
iproovReady: boolean;
}
export declare enum IproovTokenStatus {
Idle = "idle",
Pending = "pending",
Error = "error",
Success = "success"
}
export declare const isAndroid: () => boolean | undefined;
export declare const isAutocaptureActive: () => boolean;
export declare const isAutocaptureEnabledFor$: (type: keyof MerchantSettingsAutocapture) => Observable<boolean>;
export declare const isBackCamera: CameraFilterFn;
export declare const isBackMissingForUsability: (countryCode?: CountryCode, idType?: IdTypeUpload) => boolean;
export declare const isButtonShape: (value: unknown) => value is ButtonShape;
export declare const isButtonSize: (value: unknown) => value is ButtonSize;
export declare const isButtonType: (value: unknown) => value is ButtonType;
export declare const isCameraAbortError: (e: unknown) => e is VideoError;
export declare const isCameraGenericError: (e: unknown) => e is VideoError;
export declare const isCameraPermissionDenied: (e: unknown) => e is VideoError;
export declare const isCameraPlaying: () => boolean;
export declare const isCameraSelectorOrientation: (value: unknown) => value is CameraSelectorOrientation;
export declare const isColorScheme: (value: unknown) => value is ColorScheme;
export declare const isConsentGivenSent$: () => Observable<boolean>;
export declare const isFrontCamera: CameraFilterFn;
export declare const isIos: (appleOsList?: readonly AppleOsNames[]) => boolean;
export declare const isLocaleValid: (value: unknown) => value is Locale;
export declare const isMockedDeviceId: (deviceId: string) => boolean;
export declare const isMockingAllowed: () => boolean;
export declare const isNotBackCamera: CameraFilterFn;
export declare const isNotFrontCamera: CameraFilterFn;
export declare const isSamsungMainBackCamera: (label: string) => boolean;
export declare const isTokenExpired$: () => Observable<boolean>;
export declare const isTransactionIdValid: (transactionId: string) => boolean | "";
export declare type IsUsabilityBackMissing = Partial<Pick<ExtractedData, 'country' | 'idType'>> & {
isBackMissing: boolean;
};
export declare const isValidContainerType: (value: unknown) => value is DsAppContainerLayoutType;
export declare const isWCAGCompliant: (colors: {
primary: string;
font: string;
}, largeText?: boolean) => {
AA: boolean;
AAA: boolean;
};
export declare type JCredential<T extends Category = Category> = JCredentialMap[T];
export declare type JCredentialMap = Static<typeof TbJCredentialMapSchema>;
export declare interface JLiveFallbackError {
type: ManualCaptureFallbackReason;
message?: string;
}
export declare enum JLiveFallbackPolicy {
Disabled = "disabled",
Soft = "soft",
Strict = "strict"
}
export declare type JLivePartName = `${UUID}_${FacemapVerificationMethod.JumioLiveness}_${number}`;
export declare type JMediaDeviceInfo = Pick<MediaDeviceInfo, 'deviceId' | 'groupId' | 'kind' | 'label'> & {
capabilities: MediaTrackCapabilities;
};
export declare enum JumioEnvironment {
TestEu = "test-eu",
TestUs = "test-us",
StagingEu = "staging-eu",
StagingUs = "staging-us",
ProdEu = "prod-eu",
ProdUs = "prod-us",
ProdSgp = "prod-sgp",
Simulator = "simulator"
}
export declare type JumioLivenessSettings = Static<typeof TbJumioLivenessSettingsSchema>;
export declare class JumioSdkAutocaptureCaptureStateComponent extends JumioSdkStepIdCaptureStateComponent implements CaptureStateMessageRenderer {
#private;
static styles: CSSResult[];
renderContents(step: IdStep | undefined): TemplateResult<1> | nothing_2;
renderCaptureImage(): TemplateResult<1>;
capturePromptText(): string;
renderLoadingIndicator(): TemplateResult<1>;
renderProgress(): Promise<void>;
}
export declare class JumioSdkAutocaptureComponent extends BaseComponent implements CameraRenderingEngine {
#private;
static styles: CSSResult[];
isAutocaptureAvailable: AutocaptureConditionCallback;
getBlob: GetBlobCallback;
getImageData: GetImageDataCallback;
readonly destroy$: Subject<void>;
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
onVideoTick: VideoTickCallback;
onYuvProcessorAvailable: GetYuvProcessorCallback;
render(): TemplateResult<1>;
}
export declare class JumioSdkAutocaptureTrackerComponent extends BaseComponent {
#private;
static styles: CSSResult[];
getBlob: GetBlobCallback;
getImageData: GetImageDataCallback;
isCapturing: boolean;
isDebugging: boolean;
constructor();
firstUpdated(changedProperties: PropertyValues<this>): void;
updated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
renderTick(): void;
}
export declare class JumioSdkBrandingComponent extends BaseComponent {
#private;
static readonly defaultColor = "5acc29";
static styles: CSSResult[];
get componentController(): JumioSdkBrandingController;
constructor();
render(): TemplateResult<1>;
}
declare class JumioSdkBrandingController implements ReactiveController {
#private;
readonly primaryColor$: Observable<string>;
readonly secondaryColor$: Observable<string>;
constructor(host: ReactiveElement);
hostConnected(): void;
}
export declare class JumioSdkCameraErrorComponent extends ErrorMessageComponent {
#private;
static styles: CSSResult[];
title: string;
message: string;
overlay: boolean;
errorCode: string;
date: Date | null;
transactionId: string;
render(): TemplateResult<1>;
retry(): void;
}
export declare class JumioSdkCameraPermissionsScreenComponent extends BaseComponent {
#private;
static styles: CSSResult[];
disconnectedCallback(): void;
connectedCallback(): void;
}
export declare class JumioSdkCaptureHintsComponent extends BaseComponent {
#private;
static styles: CSSResult[];
readonly delayedHelpDisplay$: Observable<boolean>;
readonly visibilityStateLogging$: Observable<boolean>;
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1> | typeof nothing;
setHelpVisibility(visible: boolean): void;
rescheduleHelpPopup(): void;
}
export declare class JumioSdkComponent extends BaseComponent implements JumioSdkControllerProvider<WorkflowController, JumioSdkController> {
#private;
static styles: CSSResult[];
get accountId(): string | undefined;
get workflowExecutionId(): string | undefined;
get workflowId(): string | undefined;
set token(value: string);
get token(): string;
set sessionUrl(value: string);
get sessionUrl(): string;
set baseUrl(value: string);
get baseUrl(): string;
set dc(value: DataCenter | undefined);
get dc(): DataCenter | undefined;
set locale(value: Locale);
get locale(): Locale;
set linked(value: boolean);
get linked(): boolean;
languageDirection: string;
readonly loggerSinkRef: Ref_2<JumioSdkLoggerSinkComponent>;
workflowController: WorkflowController;
isVisible: boolean;
constructor();
get componentController(): JumioSdkController;
willUpdate(changedProperties: PropertyValues<this>): void;
connectedCallback(): void;
disconnectedCallback(): void;
refreshPage(): Promise<void>;
render(): TemplateResult_2<1> | typeof nothing;
}
export declare class JumioSdkConsentComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkConsentController> {
#private;
get componentController(): JumioSdkConsentController;
connectedCallback(): void;
render(): TemplateResult<1>;
consentChange(e: Event): void;
}
declare class JumioSdkConsentController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
getConsentItems(): ConsentItem[];
getConsentGiven(): boolean;
hostConnected(): void;
hostDisconnected(): void;
updateConsentStatus(data: ConsentData): void;
getLocale(): Locale;
}
declare class JumioSdkController implements ReactiveController {
#private;
readonly tokenExpiredMessage$: Observable<void>;
readonly acquisitionStatusPolling$: Observable<AcquisitionStatusResponse>;
readonly locale$: Observable<void>;
constructor(host: JumioSdkComponent, loggerSinkRef: Ref<ReactiveElement>);
getWorkflowController(): WorkflowController;
hostDisconnected(): void;
updateWorkflowParams: (previousState: WorkflowSetupParametersMandatory, currentState: WorkflowSetupParametersMandatory) => Promise<void>;
}
declare type JumioSdkControllerProvider<TWorkflowController, TComponentController> = ComponentControllerProvider<TComponentController> & {
readonly workflowController: TWorkflowController;
};
export declare class JumioSdkCrossDeviceButtonComponent extends BaseComponent {
#private;
static styles: CSSResult[];
fluid: boolean;
type: ButtonType;
size: ButtonSize;
readonly crossDeviceEnabledController: AsyncController<boolean, false>;
get isLinked(): boolean;
get isMobile(): boolean;
render(): TemplateResult<1> | typeof nothing;
}
export declare class JumioSdkFileUploadFailedComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkFileUploadFailedController> {
#private;
static styles: CSSResult[];
retryAction?: () => void;
get componentController(): JumioSdkFileUploadFailedController;
connectedCallback(): void;
render(): TemplateResult<1>;
}
declare class JumioSdkFileUploadFailedController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostConnected(): void;
}
declare class JumioSdkLocaleSelectionController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostDisconnected(): void;
updateLocale(locale: Locale): void;
getSelectedLocale(): Locale;
getLocales(): LocaleLanguageMap[];
}
export declare class JumioSdkLocalSelectionComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkLocaleSelectionController> {
#private;
static styles: CSSResult[];
get componentController(): JumioSdkLocaleSelectionController;
render(): TemplateResult<1>;
}
export declare class JumioSdkLoggerConsoleComponent extends BaseComponent implements LoggerConsoleConfig {
readonly type = "LoggerConsole";
isEnabled: boolean;
}
export declare class JumioSdkLoggerDatadogComponent extends BaseComponent implements LoggerDatadogRumConfig {
readonly type = "LoggerDatadogRum";
isEnabled: boolean;
config: Partial<RumInitConfiguration>;
}
export declare class JumioSdkLoggerPostMessageComponent extends BaseComponent implements LoggerPostMessageConfig {
readonly type = "LoggerPostMessage";
isEnabled: boolean;
}
export declare class JumioSdkLoggerSinkComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkLoggerSinkController> {
#private;
static styles: CSSResult[];
constructor();
get componentController(): JumioSdkLoggerSinkController;
render(): TemplateResult<1>;
}
declare class JumioSdkLoggerSinkController implements ReactiveController {
#private;
workflowController: WorkflowController;
loggerManager: LoggerManager;
readonly reportUnhandledFetchError$: Observable<PromiseRejectionEvent>;
readonly reportUnhandledError$: Observable<ErrorEvent>;
readonly cameraError$: Observable<Error>;
constructor(host: ReactiveElement);
logEvent(event: AnalyticEvent): void;
reportEvent(event: ReportEvent): void;
hostConnected(): void;
hostDisconnected(): void;
getReportUnhandledFetchError$(): Observable<PromiseRejectionEvent>;
getReportUnhandledError$(): Observable<ErrorEvent>;
getCameraErrorMessage$(): Observable<Error>;
}
export declare class JumioSdkLoggingComponent extends BaseComponent {
#private;
loggerConfig: LoggerConfigBase<string>[];
constructor();
connectedCallback(): void;
render(): TemplateResult<1>;
disconnectedCallback(): void;
getScreenLogging$(): Observable<unknown>;
}
export declare class JumioSdkLogotypeComponent extends BaseComponent {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkLogotypeController;
render(): TemplateResult_2<1>;
}
declare class JumioSdkLogotypeController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostConnected(): void;
getLogoFromSettings(): string | undefined;
}
export declare type JumioSdkMessage = JumioSdkMessageError | JumioSdkMessageProgress | JumioSdkMessageSuccess;
export declare interface JumioSdkMessageBase {
id: JumioSdkMessageId;
title: string;
message?: string;
overlay?: boolean;
closable: boolean;
shouldPost?: boolean;
}
export declare class JumioSdkMessageCloseEvent extends CustomEvent<JumioSdkMessageCloseEventDetail | undefined> {
constructor(params?: JumioSdkMessageCloseEventDetail);
}
export declare const jumioSdkMessageCloseEvent = "jmessageclose";
declare interface JumioSdkMessageCloseEventDetail {
id: JumioSdkMessageId;
}
export declare interface JumioSdkMessageError extends JumioSdkMessageBase {
type: JumioSdkMessageType.Error;
date: Date;
transactionId: string;
errorCode?: string;
publicErrorCode?: PublicError;
}
export declare class JumioSdkMessageEvent extends CustomEvent<JumioSdkMessage> {
constructor(message: JumioSdkMessage);
}
export declare const jumioSdkMessageEvent = "jmessage";
export declare enum JumioSdkMessageId {
AcquisitionFailed = "acquisition-failed",
AcquisitionSuccessful = "acquisition-success",
UsabilityCheck = "usability-check",
CameraGenericError = "camera-generic-error",
CameraNotAllowedError = "camera-not-allowed-error",
CameraInitialization = "camera-initialization",
SessionExpired = "session-expired",
Uploading = "uploading",
Finalizing = "finalizing",
EmbargoedCountry = "embargoed-country",
CloseBrowser = "close-browser",
LivenessFailed = "liveness-failed"
}
export declare interface JumioSdkMessageProgress extends JumioSdkMessageBase {
type: JumioSdkMessageType.Progress;
}
export declare class JumioSdkMessageScreenComponent extends BaseComponent {
#private;
static styles: CSSResult[];
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1> | typeof nothing;
}
export declare class JumioSdkMessageService {
#private;
readonly message$: Observable<JumioSdkMessage | undefined>;
constructor();
showMessage(message: JumioSdkMessage): void;
showMessageIfPossible(message: JumioSdkMessage): void;
clearMessage(): void;
closeActiveClosableMessage(): void;
closeActiveClosableMessageById(...ids: JumioSdkMessageId[]): void;
getMessage(): JumioSdkMessage | undefined;
}
export declare const jumioSdkMessageService: JumioSdkMessageService;
export declare interface JumioSdkMessageSuccess extends JumioSdkMessageBase {
type: JumioSdkMessageType.Success;
}
export declare enum JumioSdkMessageType {
Error = "error",
Success = "success",
Progress = "progress"
}
export declare class JumioSdkNavigationBrowserComponent extends BaseComponent implements NavigationService {
#private;
static isTheSameNavigationStep(a: Pick<WorkflowState, 'credentialId' | 'step' | 'substep'>, b: Pick<WorkflowState, 'credentialId' | 'step' | 'substep'>): boolean;
static styles: CSSResult[];
transformUrl: NavigationUrlTransformer;
baseUrl: string;
navigationService: this;
interceptors: JumioSdkNavigationInterceptor[];
navigationConfig: NavigationConfig<NavigationType_2.Browser>[];
private lastPushedState;
private initialWorkflowState;
disconnectedCallback(): void;
firstUpdated(changedProperties: PropertyValues<this>): void;
render(): TemplateResult<1>;
back(): void;
pushState: ({ data, url, unused }: UpdateStateParams) => void;
replaceState: ({ data, url, unused }: UpdateStateParams) => void;
hasHistoryItems(): boolean;
popState(state: unknown): void;
updateWorkflowState(params: Partial<WorkflowState>): void;
recreateStateMachine: (params: CreateStateMachine) => void;
getLastPushedState(): BackupEntryDescriptor | undefined;
}
export declare class JumioSdkNavigationButtonComponent extends BaseComponent {
#private;
static styles: CSSResult[];
type: ButtonType;
shape: ButtonShape;
readonly navigationService: NavigationService | undefined;
render(): TemplateResult<1>;
}
export declare class JumioSdkNavigationComponent extends BaseComponent implements JumioSdkStepNavigationForwardController {
#private;
static styles: CSSResult[];
navigationConfig: NavigationConfig<NavigationType_2>[];
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
get workflowController(): WorkflowController;
render(): TemplateResult<1>;
handleNavigationForward: () => void;
handleNavigationBackward: () => void;
getNavigationType(): NavigationType_2;
}
export declare class JumioSdkNavigationConfigBrowserComponent extends LitElement implements NavigationConfig<NavigationType_2.Browser> {
readonly type = NavigationType.Browser;
transformUrl: ({ originalUrl, suggestedUrlPart }: NavigationUrlTransformerParams_2) => string;
baseUrl: string;
}
export declare class JumioSdkNavigationConfigMemoryComponent extends LitElement implements NavigationConfig<NavigationType_2.Memory> {
readonly type = NavigationType.Memory;
}
export declare interface JumioSdkNavigationInterceptor {
shouldStoreState: (navigationStep: NavigationStep) => boolean | undefined;
}
export declare class JumioSdkNavigationInterceptorComponent extends LitElement implements JumioSdkNavigationInterceptor {
shouldStoreState(navigationStep: NavigationStep): boolean;
}
export declare class JumioSdkNavigationMemoryComponent extends BaseComponent implements NavigationService {
#private;
static styles: CSSResult[];
navigationService: this;
interceptors: JumioSdkNavigationInterceptor[];
navigationConfig: NavigationConfig<NavigationType_2.Memory>[];
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
back(): void;
pushState: (entry: BackupEntry) => void;
hasHistoryItems(): boolean;
reset(): void;
getHistoryItems(): BackupEntry[];
recreateStateMachine: (params: CreateStateMachine) => void;
}
export declare class JumioSdkSendLinkByEmailComponent extends BaseComponent implements ReactiveElement {
#private;
static styles: CSSResult[];
email: string;
inputComponent: Ref_2<InputComponent>;
readonly controller: JumioSdkSendLinkByEmailComponentController;
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
onKeyUpChange(e: FocusEvent): void;
onInputBlur(e: FocusEvent): void;
clickHandler(): void;
isButtonDisabled(): boolean;
}
declare class JumioSdkSendLinkByEmailComponentController implements ReactiveController {
#private;
readonly emailResponse$: Subject<EmailResponse>;
constructor(host: ReactiveElement);
get locale(): Locale_3;
hostConnected(): void;
hostDisconnected(): void;
sendEmail(emailRequest: EmailRequest): void;
}
export declare class JumioSdkStepCrossDeviceComponent extends BaseComponent {
#private;
static styles: CSSResult[];
readonly controller: JumioSdkStepCrossDeviceController;
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult_2;
}
declare class JumioSdkStepCrossDeviceController implements ReactiveController {
#private;
readonly crossDeviceOption$: Observable<CrossDeviceOption | undefined>;
constructor(host: ReactiveElement);
get baseUrl(): string;
get token(): string;
get locale(): Locale_3;
get crossDeviceUrl$(): Observable<URL | undefined>;
hostConnected(): void;
hostDisconnected(): void;
}
export declare class JumioSdkStepDataComponent extends BaseComponent {
#private;
get componentController(): JumioSdkStepDataController;
connectedCallback(): void;
render(): symbol;
importLoaderJs(): Promise<void>;
loadIovation(): Promise<void>;
sendTokenData(token: DeviceRiskToken): Promise<void> | undefined;
goToNextStep(): void;
}
declare class JumioSdkStepDataController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostConnected(): void;
isIovation(): boolean;
sendTokenData(deviceRiskData: DeviceRiskToken): Promise<void>;
goToNextStep(): void;
}
export declare class JumioSdkStepDocumentCaptureComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepDocumentCaptureController> {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkStepDocumentCaptureController;
readonly cameraRef: Ref_2<CameraComponent>;
constructor();
connectedCallback(): void;
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
logImageCapturedEvent: (e: ImageCapturedEvent) => Promise<void>;
uploadImage: (e: ImageCapturedEvent) => Promise<void>;
}
declare class JumioSdkStepDocumentCaptureController implements ReactiveController {
#private;
readonly workflowController: WorkflowController;
readonly stepController: WorkflowStepController<Category.Document>;
constructor(host: JumioSdkStepDocumentCaptureComponent);
hostConnected(): void;
hostDisconnected(): void;
upload(request: UploadRequest): Promise<UploadResponse_2>;
getStepController(): WorkflowStepDocumentController_2;
}
export declare class JumioSdkStepDocumentComponent extends BaseComponent implements WorkflowStepControllerProvider<WorkflowStepController<Category.Document>> {
#private;
static styles: CSSResult[];
constructor();
get workflowStepController(): WorkflowStepDocumentController_2;
render(): TemplateResult<1> | typeof nothing;
}
export declare class JumioSdkStepDocumentUploadComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepDocumentUploadController> {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkStepDocumentUploadController;
readonly documentCodeController: AsyncController<SupportedDocumentType | undefined>;
readonly pageController: AsyncController<FilePartState[] | undefined>;
readonly isUploadingController: AsyncController<boolean>;
readonly maxFileUploadSizeController: AsyncController<number>;
readonly pdfFilesController: AsyncController<RadioListItem[] | undefined>;
constructor();
render(): TemplateResult_2<1>;
}
declare class JumioSdkStepDocumentUploadController implements ReactiveController {
#private;
readonly document$: Observable<SupportedDocumentType | undefined>;
readonly pdfPages$: Observable<FilePartState[] | undefined>;
readonly maxFileUploadSize$: Observable<number>;
readonly pdfFiles$: Subject<RadioListItemWithFile[] | undefined>;
constructor(host: ReactiveElement);
hostConnected(): void;
uploadFile(file: File): Promise<UploadResponse_2>;
softDeletePdfPage(id: string): void;
confirmSelection(): Promise<void>;
isUploadingFiles$(): Observable<boolean>;
selectUploadedPdfFile(): Promise<Blob | undefined>;
getLocale(): Locale;
getSupportedDocumentTranslationsFromSettings(): Record<string, string>;
checkPdfUpload(newFile: File): Promise<boolean>;
cancelPdfSelection(): void;
handlePdfSelection(): Promise<void>;
}
export declare class JumioSdkStepFacemapCaptureStateComponent extends BaseComponent {
#private;
captureStateController: AsyncController<StartStep_3 | IdStep_3 | FacemapStep | DocumentStep_3 | DataStep_3 | undefined, false>;
render(): TemplateResult<1>;
}
export declare class JumioSdkStepFacemapComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<Category.Facemap>, JumioSdkStepFacemapController> {
#private;
static styles: CSSResult[];
stepInformationController: AsyncController<StartStep_3 | IdStep_3 | FacemapStep | DocumentStep_3 | DataStep_3 | undefined, false>;
readonly componentController: JumioSdkStepFacemapController;
get workflowStepController(): WorkflowStepController<Category.Facemap>;
render(): TemplateResult<1> | typeof nothing;
}
declare class JumioSdkStepFacemapController implements ReactiveController {
#private;
constructor(host: JumioSdkStepFacemapComponent);
hostConnected(): void;
hostDisconnected(): void;
selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
selectActiveVerificationMethod$(): Observable<FacemapVerificationMethod | undefined>;
selectFacemapStepInformation$(): Observable<StartStep_3 | IdStep_3 | FacemapStep | DocumentStep_3 | DataStep_3 | undefined>;
getStepChange$(): Observable<[StartStep_3 | IdStep_3 | FacemapStep | DocumentStep_3 | DataStep_3 | undefined, FacemapVerificationMethod[], FacemapVerificationMethod | undefined]>;
handleVerificationMethodFailed(verificationMethods: FacemapVerificationMethod[], activeVerificationMethod: FacemapVerificationMethod | undefined): void;
handleNoVerificationMethodsLeft(): void;
decideOnVerificationMethod(): void;
}
export declare class JumioSdkStepFacemapIproovComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepFacemapIproovController> {
#private;
static styles: CSSResult[];
connectedCallback(): void;
get componentController(): JumioSdkStepFacemapIproovController;
render(): TemplateResult<1>;
}
declare class JumioSdkStepFacemapIproovController implements ReactiveController {
#private;
readonly iProovTokenState$: Observable<IproovTokenState>;
constructor(host: JumioSdkStepFacemapIproovComponent);
hostConnected(): void;
hostDisconnected(): void;
fetchToken(): Promise<IproovTokenState>;
handleSystemError({ event, token: iProovTokenData }: EventWithToken): void;
handleFailedAttempt({ event, token: iProovTokenData }: EventWithToken): Promise<void>;
handleIproovSuccess({ token: iProovTokenData }: EventWithToken): Promise<undefined>;
handleReady(params: EventWithToken): void;
handleProgress({ event }: EventWithToken): void;
}
export declare class JumioSdkStepFacemapJumioStandardCaptureComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepFacemapJumioStandardCaptureController> {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkStepFacemapJumioStandardCaptureController;
readonly cameraRef: Ref_2<CameraComponent>;
constructor();
connectedCallback(): void;
firstUpdated(changedProperties: PropertyValues<this>): void;
disconnectedCallback(): void;
render(): TemplateResult<1> | typeof nothing;
logImageCapturedEvent: (e: ImageCapturedEvent) => Promise<void>;
onImageCapture: (e: ImageCapturedEvent) => Promise<void>;
requestUpload: (request: UploadRequestEvent) => void;
}
declare class JumioSdkStepFacemapJumioStandardCaptureController implements ReactiveController {
#private;
constructor(host: JumioSdkStepFacemapJumioStandardCaptureComponent);
hostConnected(): void;
hostDisconnected(): void;
requestUpload(params: UploadRequestEvent): void;
upload(): Promise<UploadResponse>;
}
export declare class JumioSdkStepFacemapJumioStandardComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepFacemapJumioStandardController> {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkStepFacemapJumioStandardController;
getActiveStep(): string | undefined;
render(): TemplateResult<1> | typeof nothing;
}
declare class JumioSdkStepFacemapJumioStandardController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostConnected(): void;
hostDisconnected(): void;
}
export declare class JumioSdkStepFacemapJumioStandardIntroductionComponent extends BaseComponent {
#private;
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare class JumioSdkStepFacemapUsabilityCheckComponent extends BaseComponent {
#private;
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare class JumioSdkStepFinishComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<VirtualStep.Finish>, JumioSdkStepFinishController> {
#private;
static styles: CSSResult[];
constructor();
get workflowStepController(): WorkflowStepController<VirtualStep.Finish>;
get componentController(): JumioSdkStepFinishController;
render(): TemplateResult<1> | typeof nothing;
}
declare class JumioSdkStepFinishController implements ReactiveController {
#private;
readonly finalize$: Observable<RequestOutcome<FinalizeResponse | undefined, unknown>>;
constructor(host: ReactiveElement);
hostConnected(): void;
getController(): WorkflowStepController<VirtualStep.Finish>;
getFinalize$(): Observable<RequestOutcome<FinalizeResponse | undefined, unknown>>;
}
export declare class JumioSdkStepIdCaptureComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdCaptureController> {
#private;
static styles: CSSResult[];
readonly componentController: JumioSdkStepIdCaptureController;
readonly cameraRef: Ref_2<CameraComponent>;
readonly captureRequest$: Observable<CaptureRequest | undefined>;
readonly captureRequestController: AsyncController<CaptureRequest | undefined>;
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
logImageCapturedEvent: (e: ImageCapturedEvent, captureRequest: CaptureRequest | undefined) => Promise<void>;
uploadImage: (e: ImageCapturedEvent, captureRequest: CaptureRequest | undefined) => Promise<void>;
}
declare class JumioSdkStepIdCaptureController implements ReactiveController {
#private;
readonly workflowController: WorkflowController;
readonly stepController: WorkflowStepController<Category.Id>;
readonly hasFileUpload$: Observable<boolean>;
constructor(host: JumioSdkStepIdCaptureComponent);
hostConnected(): void;
hostDisconnected(): void;
upload(request: UploadRequest): Promise<UploadResponse_2>;
areAllRequiredSidesCaptured(): boolean;
}
export declare class JumioSdkStepIdCaptureSourceComponentComponent extends BaseComponent {
#private;
readonly crossDeviceEnabledController: AsyncController<boolean, false>;
static styles: CSSResult[];
get isLinked(): boolean;
get isMobile(): boolean;
get isCrossDeviceVisible(): boolean;
render(): TemplateResult<1>;
}
export declare class JumioSdkStepIdCaptureStateComponent extends BaseComponent implements CaptureStateMessageRenderer {
#private;
static styles: CSSResult[];
idStepAsyncController: AsyncController<{
substep: StartStep_3 | IdStep | FacemapStep_3 | DocumentStep_3 | DataStep_3 | undefined;
captureRequest: number | undefined;
}, false>;
render(): TemplateResult_2<1>;
renderContents(step: string | undefined): TemplateResult_2<1> | typeof nothing;
renderCaptureImage(): TemplateResult_2<1>;
capturePromptText(step: IdStep | undefined): string;
renderAutocaptureCapturing(): TemplateResult_2<1>;
renderFront(): TemplateResult_2<1>;
renderFlipToBack(): TemplateResult_2<1>;
renderCaptured(): TemplateResult_2<1>;
}
export declare class JumioSdkStepIdComponent extends LitElement implements ControllerProvider<WorkflowStepController<Category.Id>, JumioSdkStepIdController> {
#private;
static styles: CSSResult[];
componentController: JumioSdkStepIdController;
constructor();
get workflowStepController(): WorkflowStepController<Category.Id>;
render(): TemplateResult<1> | typeof nothing;
}
declare class JumioSdkStepIdController implements ReactiveController {
#private;
constructor(host: JumioSdkStepIdComponent, workflowController?: WorkflowController);
hostConnected(): void;
hostDisconnected(): void;
isDocumentTypeSelected(selection: IdCredentialSelection): boolean;
isDocumentVariantSelected(selection: IdCredentialSelection): boolean;
isDigitalIdentityTypeSelected(selection: IdCredentialSelection): boolean;
getStepSelection$(): Observable<StartStep_3 | IdStep | FacemapStep_3 | DocumentStep_3 | DataStep_3 | undefined>;
handleStart(): void;
handleDocTypeDecision(): Promise<void>;
}
export declare class JumioSdkStepIdCountrySelectionComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdCountrySelectionController> {
#private;
static styles: CSSResult[];
get componentController(): JumioSdkStepIdCountrySelectionController;
render(): TemplateResult<1>;
}
declare class JumioSdkStepIdCountrySelectionController implements ReactiveController {
#private;
readonly countryList$: Observable<Country[]>;
constructor(host: ReactiveElement);
hostDisconnected(): void;
selectCountry(country?: unknown): void;
getSelectedCountry$(): Observable<CountryCode | undefined>;
}
export declare class JumioSdkStepIdDocumentCollectionComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdDocumentCollectionController> {
#private;
static styles: CSSResult[];
get componentController(): JumioSdkStepIdDocumentCollectionController;
render(): TemplateResult<1> | typeof nothing;
getSubheaderForDocumentType(type: IdTypeUpload): string;
}
declare class JumioSdkStepIdDocumentCollectionController implements ReactiveController {
#private;
readonly availableIdTypes$: Observable<IdType[]>;
constructor(host: ReactiveElement);
hostConnected(): void;
selectCredentialType(selectedIdType: IdTypeUpload, selectedDigitalIdentity?: DigitalIdentityProps): void;
getPartsForDocumentType(type: IdTypeUpload): IdTypeVariantPart[];
}
export declare class JumioSdkStepIdDocumentTypeComponent extends BaseComponent {
#private;
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare class JumioSdkStepIdDocumentVariantComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdDocumentVariantController> {
#private;
static styles: CSSResult[];
connectedCallback(): void;
get componentController(): JumioSdkStepIdDocumentVariantController;
render(): TemplateResult<1>;
}
declare class JumioSdkStepIdDocumentVariantController implements ReactiveController {
#private;
readonly variants$: Observable<IdTypeVariant[]>;
constructor(host: ReactiveElement);
selectDocumentVariant(variant: DocumentVariant): void;
hostConnected(): void;
}
export declare class JumioSdkStepIdUploadComponent extends BaseComponent implements ComponentControllerProvider<JumioSdkStepIdUploadController> {
#private;
static styles: CSSResult[];
uploadErrorMessage$: BehaviorSubject<(FilePickerError | undefined)[]>;
digitalIdentityController: AsyncController<DigitalIdentityProps | undefined>;
idTypeController: AsyncController<IdTypeUpload | undefined>;
partsController: AsyncController<UploadState[]>;
uploadErrorMessageController: AsyncController<(FilePickerError | undefined)[]>;
readyController: AsyncController<boolean | undefined>;
imageCollectionController: AsyncController<FileWithNameBase64Url[]>;
brazilianIdImageController: AsyncController<url>;
constructor();
get componentController(): JumioSdkStepIdUploadController;
render(): TemplateResult<1>;
}
declare class JumioSdkStepIdUploadController implements ReactiveController {
#private;
readonly digitalIdentity$: Observable<DigitalIdentityProps | undefined>;
readonly idType$: Observable<IdTypeUpload | undefined>;
readonly parts$: Observable<UploadState[]>;
readonly ready$: Observable<boolean | undefined>;
constructor(host: ReactiveElement);
hostConnected(): void;
uploadFile(event: FileUploadEvent, key: FileStoreKey): Promise<UploadResponse>;
removeFile(key: FileStoreKey): void;
}
export declare class JumioSdkStepIdUsabilityCheckButtonComponent extends BaseComponent {
#private;
static styles: CSSResult[];
readonly hasFileUpload$: Observable<boolean>;
readonly rejectedImageCollection$: Observable<UploadStateSuccess<ImageWithBase64Url>[]>;
retry(): void;
render(): TemplateResult<1>;
}
export declare class JumioSdkStepIdUsabilityCheckComponent extends BaseComponent {
#private;
static styles: CSSResult[];
retryMessage: HTMLElement;
carrouselOffset: number;
readonly hasFileUpload$: Observable<boolean>;
readonly rejectedImageCollection$: Observable<UploadStateSuccess<ImageWithBase64Url>[]>;
readonly rejectedUsabilityEntities$: Observable<(UsabilityCheckStateBase_3<UsabilityCheckStatus_2.Success> & {
result: UsabilityRejectResult_2;
})[]>;
connectedCallback(): void;
reportRejectionReasons(): void;
render(): TemplateResult<1>;
retry(): void;
}
export declare class JumioSdkStepIdUsabilityCheckRetryMessageComponent extends BaseComponent {
#private;
static styles: CSSResult[];
rejectedId: FileStoreKey | undefined;
render(): TemplateResult<1> | typeof nothing | undefined;
get componentController(): JumioSdkStepIdUsabilityCheckRetryMessageController;
}
declare class JumioSdkStepIdUsabilityCheckRetryMessageController implements ReactiveController {
#private;
constructor(host: ReactiveElement);
hostConnected(): void;
openSupportedIdsList(): void;
}
declare interface JumioSdkStepNavigationForwardController {
handleNavigationForward(e: Event): void;
}
export declare class JumioSdkStepSetupComponent extends BaseComponent {
#private;
static styles: CSSResult[];
render(): TemplateResult<1>;
}
export declare class JumioSdkStepStartComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<VirtualStep.Start>, JumioSdkStepStartController> {
#private;
static styles: CSSResult[];
stepInformationController: AsyncController<StartStep | IdStep_3 | FacemapStep_3 | DocumentStep_3 | DataStep_3 | undefined, false>;
get workflowStepController(): WorkflowStepController<VirtualStep.Start>;
get componentController(): JumioSdkStepStartController;
render(): TemplateResult<1> | typeof nothing;
}
export declare class JumioSdkStepStartConsentComponent extends BaseComponent implements ControllerProvider<WorkflowStepController<VirtualStep.Start>, JumioSdkStepStartConsentController> {
#private;
static styles: CSSResult[];
colorScheme: ColorScheme;
readonly documentCodeController: AsyncController<SupportedDocumentType | undefined>;
constructor();
get workflowStepController(): WorkflowStepController<VirtualStep.Start>;
get componentController(): JumioSdkStepStartConsentController;
render(): TemplateResult<1>;
renderInstructionsForCategories(params?: RenderInstructionsForCategoriesParams): TemplateResult<1>;
}
declare class JumioSdkStepStartConsentController implements ReactiveController {
#private;
constructor(host: ReactiveElement, workflow?: WorkflowController);
getController(): WorkflowStepController<VirtualStep.Start>;
getAllConsentsGiven(): boolean;
sendConsentData(): Promise<UploadResponse>;
goToNextStep(): void;
hostConnected(): void;
hostDisconnected(): void;
getDocumentType$(): Observable< {
translations?: {
[x: string]: string;
} | undefined;
code: string;
name: string;
maxPages: number;
} | undefined>;
getLocale(): Locale;
getSupportedDocumentTranslationsFromSettings(): Record<string, string>;
getCredentials(): (({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload_3[];
predefinedType: PredefinedType_4;
} | undefined;
country?: {
values: CountryCode_3[];
predefinedType: PredefinedType_4;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category.Id;
requiredParts: IdSide_4[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_4[];
predefinedType: PredefinedType_4;
};
category: Category.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType_4;
};
category: Category.Document;
country: {
values: CountryCode_3[];
predefinedType: PredefinedType_4;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType_4;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[];
}
declare class JumioSdkStepStartController implements ReactiveController {
#private;
readonly dispatchNextScreen$: Observable<unknown>;
constructor(host: ReactiveElement, workflow?: WorkflowController);
hostConnected(): void;
hostDisconnected(): void;
navigateToNextScreen(settings: Settings, stateManager?: Actor<StateMachine<MachineContext, AnyEventObject, {}, never, {
type: "setWorkflowStep";
params: NavigationStep_3;
}, never, never, {
step: VirtualStep.Setup | VirtualStep.Finish | {
start: StartStep_3;
};
activeScreen: ActiveScreen_3;
}, string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
readonly id: "@jumio/websdk workflow state machine";
readonly type: "parallel";
readonly states: {
readonly step: {
readonly id: "step";
readonly initial: string;
readonly states: {
readonly finish: {
readonly on: {
readonly "step-navigation-previous-step": string;
};
};
readonly start: {
readonly initial: StartStep_3.Start;
readonly states: {
readonly "start-screen-start": {
readonly on: {
readonly "start-screen-consent-screen": {
readonly target: StartStep_3.ConsentScreen;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep_3.ConsentScreen;
shouldStoreNavigationState: true;
activeScreen: ActiveScreen_3.Workflow;
};
};
};
readonly "start-screen-finish": {
readonly target: StartStep_3.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep_3.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_3.Workflow;
};
};
};
};
};
readonly "start-screen-consent": {
readonly on: {
readonly "start-screen-provide-consent": {
readonly target: StartStep_3.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: undefined;
step: VirtualStep.Start;
substep: StartStep_3.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_3.Workflow;
};
};
};
};
};
readonly "start-screen-finish": {
readonly type: "final";
};
};
readonly on: {
readonly "step-navigation-next-step": {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep_3.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_3.Workflow;
};
};
};
};
readonly onDone: {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep.Start;
substep: StartStep_3.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_3.Workflow;
};
};
};
};
readonly setup: {
readonly on: {
readonly "step-navigation-next-step": {
readonly target: VirtualStep.Start;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
readonly step: VirtualStep.Start;
readonly substep: StartStep_3.Start;
readonly shouldStoreNavigationState: false;
readonly credentialId: undefined;
readonly activeScreen: ActiveScreen_3.Workflow;
};
};
};
};
};
};
readonly entry: ActionFunction<MachineContext, AnyEventObject, AnyEventObject, undefined, never, {
type: "setWorkflowStep";
params: NavigationStep_3;
}, never, never, EventObject>;
};
readonly activeScreen: {
readonly id: "active screen state machine";
readonly initial: ActiveScreen_3.Workflow;
readonly states: {
readonly workflow: {};
readonly "cross-device": {};
};
readonly on: {
readonly "active-screen-navigate-to-cross-device": {
readonly target: ".cross-device";
readonly actions: any;
};
readonly "active-screen-navigate-to-workflow": {
readonly target: ".workflow";
readonly actions: any;
};
};
};
};
}>>): void;
getNavigateToNextScreen$(): Observable<{
linked?: boolean | undefined;
dvFileUploadEnabled?: boolean | undefined;
merchantSettings?: {
autoCapture?: {
idEnabled?: boolean | undefined;
docVEnabled?: boolean | undefined;
} | undefined;
branding?: {
primaryColor?: string | undefined;
accentColor?: string | undefined;
logoUri?: string | undefined;
} | undefined;
crossDevice?: {
link?: string | undefined;
crossDeviceOption?: CrossDeviceOption_4 | undefined;
enabled: boolean;
} | undefined;
crossDeviceOnly?: boolean | undefined;
datadog?: {
enabled: boolean;
merchantName: string;
} | undefined;
isExplicitUploadEnabled?: boolean | undefined;
isFileUploadEnabled?: boolean | undefined;
jLiveEnabled?: boolean | undefined;
skipLivenessGuidancePage?: boolean | undefined;
jLiveFallbackPolicy: JLiveFallbackPolicy_4;
} | undefined;
networkThrottlingLimit?: number | undefined;
redirects?: {
error?: string | undefined;
success?: string | undefined;
} | undefined;
returnImages?: boolean | undefined;
skipDocTypeSelection?: boolean | undefined;
iproovTokenData?: {
url: string;
token: string;
productType: "IPROOV_STANDARD" | "IPROOV_PREMIUM";
remainingAttempts: number;
} | undefined;
skipStartScreen?: boolean | undefined;
eidasUrl?: string | undefined;
timestamp: string;
configurations: {
focusScore?: string | undefined;
cvAnalytics?: string | undefined;
networkTimeouts?: {
finalize: number;
upload: number;
usability: number;
extractdata: number;
analytics: number;
reporting: number;
iproovtoken: number;
iproovvalidate: number;
cdn: number;
} | undefined;
cdnEnc?: {
name: string;
file: string;
key: string;
iv: string;
}[] | undefined;
shakeDetection?: string | undefined;
instantFeedback?: string | undefined;
docFinder?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
} | undefined;
consentURL?: string | undefined;
iproovMaxAttempts?: string | undefined;
skipConfirm?: string | undefined;
consentRequired?: string | undefined;
cvMrzThreshold?: string | undefined;
cdnPublicKey?: string | undefined;
maxRetries?: string | undefined;
iproovEnabled?: string | undefined;
maxPollingTime?: string | undefined;
barcodeScannerKey?: string | undefined;
dataPrivacyUrl?: string | undefined;
dataDog?: {
appId: string;
clientId: string;
} | undefined;
shakeScore?: string | undefined;
sardineClientId?: string | undefined;
fileUpload?: {
fallbackTimeInMs: number;
isFallbackUploadEnabled: boolean;
} | undefined;
jumioLiveness?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
retries: number;
minNearFarRatio: number;
maxFaceCenterDifference: number;
tooFarThreshold: number;
tooNearThreshold: number;
initialImages: number;
transitionImages: number;
nearImages: number;
farImages: number;
minTimePerDistanceInMs: number;
maxConsecutiveImageTimespanInMs: number;
imageResolutionWidth: number;
imageResolutionHeight: number;
imageCompression: number;
fallbackTimeInMs: number;
userFallbackAllowed: boolean;
minimumPseudoPitch: number;
maximumPseudoPitch: number;
minimumPseudoYaw: number;
maximumPseudoYaw: number;
} | undefined;
idAutocapture?: {
fallbackTimeInMs?: number | undefined;
excludeDevices?: string[] | undefined;
focusTimeInMs?: number | undefined;
} | undefined;
helpScreen?: {
ID: number;
FACEMAP: number;
DOCUMENT: number;
DATA: number;
} | undefined;
cameraData?: {
cameraTimeoutMs?: number | undefined;
resolutionId?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionFacemap?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionDocument?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
} | undefined;
sensorData?: {
intervalLog: number;
intervalSend: number;
} | undefined;
supplementalImagesV2?: {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
} | {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
}[] | undefined;
};
accountId: string;
acquisitionReference: string;
analyticsEnabled: boolean;
brandingEnabled: boolean;
consents: {
privacyPolicyUrl?: string | undefined;
id: string;
text: string;
displayType: ConsentDisplayType_4;
alternativeTexts: {
ar?: string | undefined;
bg?: string | undefined;
cs?: string | undefined;
da?: string | undefined;
de?: string | undefined;
el?: string | undefined;
en?: string | undefined;
en_GB?: string | undefined;
"en-GB"?: string | undefined;
en_US?: string | undefined;
"en-US"?: string | undefined;
es?: string | undefined;
es_MX?: string | undefined;
"es-MX"?: string | undefined;
et?: string | undefined;
fi?: string | undefined;
fr?: string | undefined;
he?: string | undefined;
hr?: string | undefined;
hu?: string | undefined;
hy?: string | undefined;
id?: string | undefined;
it?: string | undefined;
ja?: string | undefined;
ka_GE?: string | undefined;
"ka-GE"?: string | undefined;
km?: string | undefined;
km_KH?: string | undefined;
"km-KH"?: string | undefined;
ko?: string | undefined;
lt?: string | undefined;
ms?: string | undefined;
nl?: string | undefined;
no?: string | undefined;
pl?: string | undefined;
pt?: string | undefined;
pt_BR?: string | undefined;
"pt-BR"?: string | undefined;
ro?: string | undefined;
ru?: string | undefined;
sk?: string | undefined;
sr_Cyrl?: string | undefined;
"sr-Cyrl"?: string | undefined;
sr?: string | undefined;
sr_Latn?: string | undefined;
"sr-Latn"?: string | undefined;
sv?: string | undefined;
sw?: string | undefined;
th?: string | undefined;
tr?: string | undefined;
uk?: string | undefined;
vi?: string | undefined;
zh?: string | undefined;
zh_CN?: string | undefined;
"zh-CN"?: string | undefined;
zh_HK?: string | undefined;
"zh-HK"?: string | undefined;
};
}[];
countryForIp: string;
credentials: (({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload_3[];
predefinedType: PredefinedType_4;
} | undefined;
country?: {
values: CountryCode_3[];
predefinedType: PredefinedType_4;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category_4.Id;
requiredParts: IdSide_4[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_4[];
predefinedType: PredefinedType_4;
};
category: Category_4.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType_4;
};
category: Category_4.Document;
country: {
values: CountryCode_3[];
predefinedType: PredefinedType_4;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType_4;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category_4.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[];
deviceRiskTokenData: {
token: string;
sdkType: SdkType_4.Iovation;
}[];
maxFileUploadSize: number;
stateForIp: string;
supportedCountries: {
country: CountryCode_3;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_4;
title: string;
requestedIdType: IdTypeUpload_3;
} | undefined;
idType: IdTypeUpload_3;
variants: {
format?: IdFormat_4 | undefined;
variant: DocumentVariant_4;
parts: {
side: IdSide_4;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[];
supportedDocumentTypes: {
translations?: {
[x: string]: string;
} | undefined;
code: string;
name: string;
maxPages: number;
}[];
workflowDefinitionKey: number;
}>;
}
export declare class JumioSdkSupplementalImagesComponent extends BaseComponent implements CameraRenderingEngine {
#private;
static styles: CSSResult[];
updateNotifier?: SupplementalImageUpdateNotifier;
set config(value: ConfigurationSupplementalImage | null | undefined);
get config(): ConfigurationSupplementalImage | null | undefined;
set uploadType(value: SupplementalImageUploadTypePrefix | null | undefined);
get uploadType(): SupplementalImageUploadTypePrefix | null | undefined;
constructor();
connectedCallback(): void;
disconnectedCallback(): void;
render(): TemplateResult<1>;
onVideoTick: VideoTickCallback;
getImageData: GetImageDataCallback;
getBlob: GetBlobCallback;
getImages(): MultipartFile[];
getFps(): number;
update(changedProperties: PropertyValues<this>): void;
getBufferAge(): number;
updateActivationTime(): void;
}
export declare class JumioSdkSupportedIdSearchComponent extends BaseComponent {
#private;
static styles: CSSResult[];
supportedCountries: AsyncController<{
country: CountryCode_3;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_4;
title: string;
requestedIdType: IdTypeUpload_3;
} | undefined;
idType: IdTypeUpload_3;
variants: {
format?: IdFormat_4 | undefined;
variant: DocumentVariant_4;
parts: {
side: IdSide_4;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[], false>;
inputComponent: Ref_2<InputComponent>;
onInputChange: () => void;
render(): TemplateResult<1>;
}
export declare class JumioSdkThemeComponent extends BaseComponent {
colorScheme: ColorScheme;
colorSchemeService: ColorSchemeService | undefined;
attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
}
export declare class JumioSdkUploadButtonComponent extends BaseComponent {
#private;
static styles: CSSResult[];
fluid: boolean;
type: ButtonType;
size: ButtonSize;
constructor();
render(): TemplateResult_2 | symbol;
}
export declare const languageDirectionContext: {
__context__: string;
};
export declare enum LegacyErrorCode {
SystemError = 9100,
AuthTokenError = 9200,
AuthSessionError = 9210,
FileUploadError = 9300,
UsabilityError = 9400,
UserOffline = 9800,
UnhandledError = 9801,
BrowserDoesNotSupportCamera = 9822,
AuthFailed = 9836,
CredentialError = 9900
}
export declare type LegacyErrorCodeType = Static<typeof TbLegacyErrorCode>;
export declare const lighten: (hex: string, ratio: number) => string;
export declare enum LinkedModule {
Mrz = "MRZ",
Nfc = "NFC",
Barcode = "BARCODE",
LineFinder = "LINEFINDER",
DocFinder = "DOCFINDER",
Manual = "MANUAL",
FaceManual = "FACE_MANUAL",
FaceIproov = "FACE_IPROOV",
DataDog = "DATADOG",
Sardine = "SARDINE",
Iovation = "IOVATION",
JumioLiveness = "JUMIO_LIVENESS",
DigitalIdentity = "DIGITAL_IDENTITY"
}
export declare type LinkedModuleType = Static<typeof TbLinkedModule>;
export declare class ListComponent extends BaseComponent {
static styles: CSSResult[];
dataFlattenerCallback?: ListFlattenerCallbackFunction;
itemRenderer: ListComponentItemRenderer;
data: Iterable<unknown>;
render(): TemplateResult<1>;
}
export declare type ListComponentItemRenderer<T = unknown> = (params: ListComponentItemRendererParams<T>) => TemplateResult_2<1> | typeof nothing;
export declare interface ListComponentItemRendererParams<T> {
item: ListItemEntity<T>;
isFirst: boolean;
isLast: boolean;
}
export declare type ListFlattenerCallbackFunction<T = unknown, R = T> = (value: Iterable<T>) => ListItemEntity<R>[];
export declare interface ListItemEntity<T = unknown> {
depth?: number;
value: T;
}
export declare const LIVENESS_CAPTURE_TYPES: {
readonly JumioStandard: "JUMIO_STANDARD";
readonly JumioLiveness: "JUMIO_LIVENESS";
readonly JumioPremium: "JUMIO_PREMIUM";
readonly IproovStandard: "IPROOV_STANDARD";
readonly IproovPremium: "IPROOV_PREMIUM";
readonly ManualSelfie: "MANUAL_SELFIE";
};
export declare type LivenessCaptureTypes = ObjectValues<typeof LIVENESS_CAPTURE_TYPES>;
export declare class LivenessFaceAnimationComponent extends BaseComponent {
static styles: CSSResult[];
render(): SVGTemplateResult;
}
export declare interface LivenessFaceFinder {
cxRatio: number;
cyRatio: number;
frameAspectRatio: number;
fillRatio: number;
}
export declare type LivenessFaceFinderDistance = 'far' | 'initial' | 'near';
export declare interface LivenessFaceFinderEllipse extends LivenessFaceFinder {
cx: number;
cy: number;
rx: number;
ry: number;
}
export declare const livenessInitialized: EventDispatcher_2< {
step: string;
}>;
export declare const livenessManualSelfieFallback: EventDispatcher_2< {
step: string;
reason: string;
}>;
export declare const livenessModuleLoadingFailed: EventDispatcher_2< {
step: string;
}>;
export declare const livenessProgressEvent: EventDispatcher_2< {
jliveProgressCurrentStep: number;
jliveProgressStepsTotal: number;
jLiveStepDuration: number;
jLiveDuration: number;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
}>;
export declare type LivenessRefDistance = 'far' | 'initial' | 'near';
export declare enum LivenessResult {
True = "TRUE",
False = "FALSE",
Bo = "BO"
}
export declare type LivenessResultType = Static<typeof TbLivenessResult>;
declare type LivenessSeriesPartName = `${UUID}_${FacemapVerificationMethod.LivenessSeries}_${number}`;
export declare interface LivenessState {
jLiveAttemptNo: number;
jLiveCameraCommand: UXCameraCommand | undefined;
jLiveDisplayMessage: UXDisplayMessage;
jLivePhotinusColor: string | undefined;
jLiveProgressCurrentStep: number;
jLiveProgressStepsTotal: number;
jLiveUiCommand: UXUICommand | undefined;
jLiveVisibleFaceFinder: LivenessRefDistance;
jLiveManualCaptureFallbackReason: ManualCaptureFallbackReason | undefined;
jLiveFallbackError: JLiveFallbackError | undefined;
}
export declare class LoadingIndicatorComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
export declare enum Locale {
Ar = "ar",
Bg = "bg",
Cs = "cs",
Da = "da",
De = "de",
El = "el",
En = "en",
EnGb = "en_GB",
EnGbHyphen = "en-GB",
EnUs = "en_US",
EnUsHyphen = "en-US",
Es = "es",
EsMx = "es_MX",
EsMxHyphen = "es-MX",
Et = "et",
Fi = "fi",
Fr = "fr",
He = "he",
Hr = "hr",
Hu = "hu",
Hy = "hy",
Id = "id",
It = "it",
Ja = "ja",
KaGe = "ka_GE",
KaGeHyphen = "ka-GE",
Km = "km",
KmKh = "km_KH",
KmKhHyphen = "km-KH",
Ko = "ko",
Lt = "lt",
Ms = "ms",
Nl = "nl",
No = "no",
Pl = "pl",
Pt = "pt",
PtBr = "pt_BR",
PtBrHyphen = "pt-BR",
Ro = "ro",
Ru = "ru",
Sk = "sk",
SrCyrl = "sr_Cyrl",
SrCyrlHyphen = "sr-Cyrl",
Sr = "sr",
SrLatn = "sr_Latn",
SrLatnHyphen = "sr-Latn",
Sv = "sv",
Sw = "sw",
Th = "th",
Tr = "tr",
Uk = "uk",
Vi = "vi",
Zh = "zh",
ZhCn = "zh_CN",
ZhCnHyphen = "zh-CN",
ZhHk = "zh_HK",
ZhHkHyphen = "zh-HK"
}
declare interface LocaleLanguageMap {
keys: Locale[];
label: string;
}
export declare type LocaleType = Static<typeof TbLocaleSchema>;
export declare const lockOrientation: (orientation?: OrientationType) => void;
export declare type LogEventBody<ET extends EventType = EventType, EN extends string = string, M extends EventMetadata = EventMetadata> = AnalyticEventBody<ET, EN, M> | ReportEventBody<ET, EN, M>;
export declare interface Logger {
isEnabled: boolean;
getId(): string;
log(message: AnalyticEventBody): Promise<unknown>;
report(message: ReportEventBody): Promise<unknown>;
updateConfig?<T extends LoggerConfigBase<unknown>>(config: T): void;
}
export declare interface LoggerConfigBase<T> {
readonly type: T;
isEnabled: boolean;
}
declare type LoggerConsoleConfig = LoggerConfigBase<typeof LoggerConsoleId>;
declare const LoggerConsoleId = "LoggerConsole";
declare type LoggerDatadogRumConfig = LoggerConfigBase<typeof LoggerDatadogRumId> & {
params?: Partial<RumInitConfiguration>;
};
declare const LoggerDatadogRumId = "LoggerDatadogRum";
export declare interface LoggerManager {
addLogger(logger: Logger): void;
removeLogger(logger: Logger): void;
removeLoggerById(id: string): void;
getLoggerById(id: string): Logger | undefined;
log(body: AnalyticEventBody): void;
report(body: ReportEventBody): void;
}
declare type LoggerPostMessageConfig = LoggerConfigBase<typeof LoggerPostMessageId>;
declare const LoggerPostMessageId = "LoggerPostMessage";
export declare enum LogLevel {
Trace = "trace",
Debug = "debug",
Info = "info",
Warn = "warn",
Error = "error",
None = "none"
}
export declare enum ManualCaptureFallbackReason {
ModuleLoadingError = "module-loading-error",
ModuleInitializationError = "module-initialization-error",
WorkerCrashed = "worker-crashed",
WorkerError = "worker-error",
PostMessageError = "post-message-error",
Struggle = "struggle",
Timeout = "timeout",
UserSelection = "user-selection",
ExcludedDevice = "excluded-device"
}
export declare const maxFileSizeMessage: (maxFileSize: number) => string;
declare type MediaDeviceMetadata = Partial<Pick<MediaDeviceInfo, 'deviceId' | 'groupId' | 'kind' | 'label'>>;
export declare type MerchantSettingsAutocapture = Static<typeof TbMerchantSettingsAutocaptureSchema>;
export declare type MerchantSettingsBranding = Static<typeof TbMerchantSettingsBrandingSchema>;
export declare type MerchantSettingsCrossDevice = Static<typeof TbMerchantSettingsCrossDeviceSchema>;
export declare class MessageDetailsComponent extends BaseComponent {
#private;
static styles: CSSResult[];
title: string;
message: string;
firstUpdated(changedProperties: PropertyValues<this>): void;
render(): TemplateResult_2<1>;
}
export declare class ModalComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
declare type Mode = 'secure+';
export declare enum MrzFormat {
Mrp = "MRP",
Td1 = "TD1",
Td2 = "TD2",
Cnis = "CNIS",
MrvA = "MRV_A",
MrvB = "MRV_B"
}
export declare type MrzFormatType = Static<typeof TbMrzFormat>;
export declare interface MultipartConsent {
id: string;
timestamp: number | undefined;
displayType: ConsentDisplayType;
}
export declare interface MultipartData {
mrzFormat?: MrzFormat;
thirdPartyOcr?: ThirdPartyOcr;
barcodeFormat?: BarcodeFormat;
firstName?: string;
lastName?: string;
personalNumber?: string;
number?: string;
issuingDate?: string;
dob?: string;
expiry?: string;
issuingCountry?: CountryCode;
country?: CountryCode;
address?: Address;
usAddress?: UsAddress;
euAddress?: EuAddress;
optionalData1?: string;
optionalData2?: string;
mrzLine1?: string;
mrzLine2?: string;
mrzLine3?: string;
nfcLine1?: string;
nfcLine2?: string;
nfcLine3?: string;
extractionSide?: ExtractionSide;
ePassport?: EPassport;
eMRTD?: EPassport;
livenessDetected?: boolean;
livenessResult?: LivenessResult;
livenessValue?: number;
eyeTrackingData?: EyeTrackingData;
placeOfBirth?: string;
idType?: IdTypeUpload;
documentVariant?: DocumentVariant;
rawBarcodeData?: string;
additionalDataPoints?: Record<string, string>;
}
export declare interface MultipartFile {
multipartName: FileStoreKey;
fileType: FileType;
country?: CountryCode;
uploadType: UploadType | UploadTypeJumioLiveness | UploadTypeLivenessSeries | UploadTypeSupplementalImageId | UploadTypeSupplementalImageSelfie;
idType?: IdTypeUpload;
captureMethod?: IdCaptureTypes | LivenessCaptureTypes;
docType?: string;
usabilityExpected: boolean;
fileMetaData?: Record<string, unknown>;
file: Blob;
riskSignals?: RiskSignals;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
}
export declare interface MultipartFiles {
files: MultipartFile[];
applyUsabilityFilter?: boolean;
}
export declare type NavigationConfig<T extends NavigationType_2> = NavigationConfigMap[T];
export declare interface NavigationConfigBrowser {
readonly type: NavigationType_2.Browser;
transformUrl: NavigationUrlTransformer;
baseUrl: string;
}
export declare interface NavigationConfigMap {
[NavigationType_2.Memory]: NavigationConfigMemory;
[NavigationType_2.Browser]: NavigationConfigBrowser;
}
export declare interface NavigationConfigMemory {
readonly type: NavigationType_2.Memory;
}
export declare type NavigationService = Pick<History, 'back' | 'pushState'> & {
hasHistoryItems(): boolean;
};
export declare type NavigationStep<T extends CredentialStep = CredentialStep> = NavigationStepMap[T];
export declare interface NavigationStepBase<TStep extends CredentialStep, TSubstep> {
step: TStep;
substep: TSubstep;
credentialId: UUID | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
}
export declare type NavigationStepCategoryData = NavigationStepBase<Category.Data, DataStep>;
export declare type NavigationStepCategoryDocument = NavigationStepBase<Category.Document, DocumentStep>;
export declare type NavigationStepCategoryFacemap = NavigationStepBase<Category.Facemap, FacemapStep>;
export declare type NavigationStepCategoryId = NavigationStepBase<Category.Id, IdStep>;
export declare interface NavigationStepMap {
[VirtualStep.Setup]: NavigationStepVirtualStepSetup;
[VirtualStep.Start]: NavigationStepVirtualStepStart;
[Category.Id]: NavigationStepCategoryId;
[Category.Facemap]: NavigationStepCategoryFacemap;
[Category.Document]: NavigationStepCategoryDocument;
[Category.Data]: NavigationStepCategoryData;
[VirtualStep.Finish]: NavigationStepVirtualStepFinish;
}
export declare type NavigationStepSubstep<T extends CredentialStep = CredentialStep> = NavigationStep<T>['substep'];
export declare type NavigationStepVirtualStepFinish = NavigationStepBase<VirtualStep.Finish, undefined>;
export declare type NavigationStepVirtualStepSetup = NavigationStepBase<VirtualStep.Setup, undefined>;
export declare type NavigationStepVirtualStepStart = NavigationStepBase<VirtualStep.Start, StartStep>;
declare enum NavigationType_2 {
Browser = "browser",
Memory = "memory"
}
export { NavigationType_2 as NavigationType }
export declare type NavigationUrlTransformer = ({ originalUrl, stepData, suggestedUrlPart }: NavigationUrlTransformerParams) => string;
export declare interface NavigationUrlTransformerParams {
originalUrl: string;
stepData: NavigationStep;
suggestedUrlPart: string;
}
export declare const noCameraConnection: ErrorCase;
export declare const noFilterFn: FileListFilter;
declare type ObjectValues<T> = T[keyof T];
export declare const observableFromRef: <T extends HTMLElement = HTMLElement>(ref: Ref<T>, refreshNotifier$: Observable<void>) => Observable<T>;
export declare const observeResize$: ({ el, ResizeObserverClass, requestAnimationFrameFn, cancelAnimationFrameFn }: ObserveResizeParams) => Observable<DsDimensions>;
export declare interface ObserveResizeParams {
el: HTMLElement;
ResizeObserverClass?: typeof ResizeObserver;
requestAnimationFrameFn?: typeof window.requestAnimationFrame;
cancelAnimationFrameFn?: typeof window.cancelAnimationFrame;
}
export declare enum Orientation {
Landscape = "landscape",
Portrait = "portrait"
}
export declare class OrientationLockComponent extends BaseComponent {
#private;
static styles: CSSResult[];
orientationType: OrientationType;
connectedCallback(): void;
disconnectedCallback(): void;
}
declare type OrientationType_2 = Static<typeof TbOrientation>;
export { OrientationType_2 as OrientationType }
export declare class PageContainerComponent extends BaseComponent {
static styles: CSSResult[];
fullscreenModeController: AsyncController<boolean, false>;
render(): TemplateResult<1>;
}
export declare const pageContainerVisible$: BehaviorSubject<boolean>;
export declare const patchAutocaptureStore: (params?: Partial<AutocaptureStore>) => void;
export declare const patchPersistedTags: (dataOrMergeFn: Tags | ((prev: Tags) => Tags)) => void;
export declare class PermissionLifecycleComponent extends BaseComponent {
#private;
static styles: CSSResult[];
connectedCallback(): void;
disconnectedCallback(): void;
render(): symbol;
}
declare type PermissionQuery = typeof navigator.permissions.query;
export declare interface PermissionStore {
camera: PermissionState;
}
export declare interface PointInCircle {
circleX: number;
circleY: number;
circleR: number;
targetPt: AutocaptureDocXY;
}
export declare const poweredByVisible: {
__context__: boolean;
};
export declare enum PredefinedType {
Defined = "DEFINED",
Recommended = "RECOMMENDED",
Optional = "OPTIONAL"
}
export declare type PredefinedTypeType = Static<typeof TbPredefinedType>;
export declare const processCannotBeCompleted: ErrorCase;
export declare class ProgressMessageComponent extends BaseComponent {
static styles: CSSResult[];
title: string;
message: string;
overlay: boolean;
render(): TemplateResult_2<1>;
}
export declare class PromptLoaderComponent extends BaseComponent {
#private;
static styles: CSSResult[];
state: PromptLoaderState;
progress: number;
hidePlusOnInitialState: boolean;
progressTransitionDuration: number;
progressDisableTransition: boolean;
render(): TemplateResult<1>;
}
export declare enum PromptLoaderState {
Initial = "initial",
Progress = "progress",
Pulsing = "pulsing"
}
export declare interface PublicError {
isRetryable: () => boolean;
domain: () => ErrorDomain;
code: () => string;
legacyCode: () => LegacyErrorCode;
}
export declare const publicError: EventDispatcher_2< {
errorCode: string;
}>;
export declare class QrCodeComponent extends BaseComponent {
#private;
static styles: CSSResult[];
uri: string;
darkColor: string;
lightColor: string;
constructor();
updated(): void;
render(): TemplateResult_2;
toCanvas(canvasElement: HTMLCanvasElement, text: QRCodeSegment[] | string, options: QRCodeRenderersOptions, callback: (error: Error | null | undefined) => void): void;
}
export declare class RadioListComponent extends BaseComponent {
#private;
static styles: CSSResult[];
items: RadioListItem[];
render(): TemplateResult_2<1>;
}
export declare interface RadioListItem {
label: string;
value: string;
selected: boolean;
}
declare interface RadioListItemWithFile extends RadioListItem {
file: File;
}
export declare class RadioListSelectionEvent extends CustomEvent<RadioListSelectionEventParams> {
constructor(params: RadioListSelectionEventParams);
}
export declare interface RadioListSelectionEventParams {
name: string;
}
export declare enum ReasonCode {
GENERIC = "0",
DIGITAL_COPY = "104",
BLACK_WHITE_COPY = "102",
COLOR_PHOTOCOPY = "103",
NOT_READABLE = "200",
NO_DOCUMENT = "201",
SAMPLE_DOCUMENT = "202",
MISSING_BACK = "206",
MISSING_FRONT = "214",
UNSUPPORTED_ID = "401",
INVALID_CERTIFICATE = "501",
BLURRY = "2001",
BAD_QUALITY = "2002",
MISSING_PART_DOCUMENT = "2003",
HIDDEN_PART_DOCUMENT = "2004",
DAMAGED_DOCUMENT = "2005",
GLARE = "2006",
LIVENESS_GENERIC = "3001",
LIVENESS_TOO_MUCH_MOVEMENT = "3002",
LIVENESS_TOO_BRIGHT = "3003",
LIVENESS_TOO_DARK = "3004",
LIVENESS_EYES_CLOSED = "3005",
LIVENESS_FACE_OBSCURED = "3006",
LIVENESS_MULTIPLE_FACES = "3007",
LIVENESS_SUNGLASSES = "3008",
LIVENESS_NOT_MAX_BRIGHTNESS = "3009"
}
export declare type ReasonCodeType = Static<typeof TbReasonCode>;
export declare const recreateStateMachine: ({ credentials, setWorkflowStepCallback, initialState, snapshotValue }: CreateStateMachine) => Actor<StateMachine<MachineContext, AnyEventObject, {}, never, {
type: "setWorkflowStep";
params: NavigationStep_2;
}, never, never, {
step: VirtualStep_2.Setup | VirtualStep_2.Finish | {
start: StartStep_2;
};
activeScreen: ActiveScreen_2;
}, string, NonReducibleUnknown, NonReducibleUnknown, EventObject, MetaObject, {
readonly id: "@jumio/websdk workflow state machine";
readonly type: "parallel";
readonly states: {
readonly step: {
readonly id: "step";
readonly initial: string;
readonly states: {
readonly finish: {
readonly on: {
readonly "step-navigation-previous-step": string;
};
};
readonly start: {
readonly initial: StartStep_2.Start;
readonly states: {
readonly "start-screen-start": {
readonly on: {
readonly "start-screen-consent-screen": {
readonly target: StartStep_2.ConsentScreen;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep_2.Start;
substep: StartStep_2.ConsentScreen;
shouldStoreNavigationState: true;
activeScreen: ActiveScreen_2.Workflow;
};
};
};
readonly "start-screen-finish": {
readonly target: StartStep_2.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep_2.Start;
substep: StartStep_2.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_2.Workflow;
};
};
};
};
};
readonly "start-screen-consent": {
readonly on: {
readonly "start-screen-provide-consent": {
readonly target: StartStep_2.Finish;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: undefined;
step: VirtualStep_2.Start;
substep: StartStep_2.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_2.Workflow;
};
};
};
};
};
readonly "start-screen-finish": {
readonly type: "final";
};
};
readonly on: {
readonly "step-navigation-next-step": {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep_2.Start;
substep: StartStep_2.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_2.Workflow;
};
};
};
};
readonly onDone: {
readonly target: string;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
credentialId: string;
step: VirtualStep_2.Start;
substep: StartStep_2.Finish;
shouldStoreNavigationState: false;
activeScreen: ActiveScreen_2.Workflow;
};
};
};
};
readonly setup: {
readonly on: {
readonly "step-navigation-next-step": {
readonly target: VirtualStep_2.Start;
readonly actions: {
readonly type: "setWorkflowStep";
readonly params: {
readonly step: VirtualStep_2.Start;
readonly substep: StartStep_2.Start;
readonly shouldStoreNavigationState: false;
readonly credentialId: undefined;
readonly activeScreen: ActiveScreen_2.Workflow;
};
};
};
};
};
};
readonly entry: ActionFunction<MachineContext, AnyEventObject, AnyEventObject, undefined, never, {
type: "setWorkflowStep";
params: NavigationStep_2;
}, never, never, EventObject>;
};
readonly activeScreen: {
readonly id: "active screen state machine";
readonly initial: ActiveScreen_2.Workflow;
readonly states: {
readonly workflow: {};
readonly "cross-device": {};
};
readonly on: {
readonly "active-screen-navigate-to-cross-device": {
readonly target: ".cross-device";
readonly actions: any;
};
readonly "active-screen-navigate-to-workflow": {
readonly target: ".workflow";
readonly actions: any;
};
};
};
};
}>>;
export declare const recreateWorkflow: () => WorkflowController;
export declare type Redirects = Static<typeof TbRedirectsSchema>;
export declare const redirectToErrorPage: (errorUrl?: string, setTargetLocation?: (url: string) => void) => void;
export declare const redirectToSuccessPage: (successUrl?: string, setTargetLocation?: (url: string) => void) => void;
export declare interface RejectReason extends Record<string, unknown> {
reasonCode: ReasonCode;
}
export declare const removeNonSuccessfulUploadAndUsabilityEntitiesByCredentialId: (credentialId: UUID) => void;
export declare const removeUploadAndUsabilityEntitiesByCredentialId: (credentialId: UUID) => void;
export declare const removeUploadAndUsabilityItemsByIds: (...id: FileStoreKey[]) => void;
export declare type RenderCaptureState = (step: IdStep | undefined) => TemplateResult_2<1> | symbol;
declare interface RenderInstructionsForCategoriesParams {
categories?: Category[];
areSettingsFetched?: boolean;
}
export declare class ReportEvent<T extends ReportEventBody = ReportEventBody> extends CustomEvent<T> {
constructor(detail: T);
}
export declare type ReportEventBody<ET extends EventType = EventType, EN extends string = string, M extends EventMetadata = EventMetadata> = EventBodyBase<ET, EN, M>;
export declare const requestCameraPlayback: (command: SwitchCameraCommand | SwitchStreamCommand | undefined) => void;
export declare const requestCameraPlaybackRetry: () => void;
export declare enum RequestCode {
Unknown = 0,
SettingsCall = 1,
ExtractDataCall = 3,
UploadCall = 4,
ReportingCall = 5,
FinalizeCall = 6,
UsabilityCall = 7,
IproovTokenCall = 8,
IproovValidateCall = 9,
DigitalIdentityWebViewCall = 10,
DigitalIdentityOutcomeCall = 11,
StatusCall = 20,
CrossDeviceEmailCall = 21,
GetFilePartCall = 22,
UpdateMetadata = 23,
EIDASUrl = 24
}
export declare type RequestCodeType = Static<typeof TbRequestCode>;
export declare type RequestOutcome<TSuccess, TError> = RequestOutcomeError<TError> | RequestOutcomeLoading | RequestOutcomeReady | RequestOutcomeSuccess<TSuccess>;
export declare interface RequestOutcomeError<TError = unknown> {
type: RequestStatusType.Error;
errorCode?: string;
error: TError;
}
export declare interface RequestOutcomeLoading {
type: RequestStatusType.Loading;
}
export declare interface RequestOutcomeReady {
type: RequestStatusType.Ready;
}
export declare interface RequestOutcomeSuccess<TSuccess = unknown> {
type: RequestStatusType.Success;
result: TSuccess;
}
export declare enum RequestStatusType {
Ready = "ready",
Success = "success",
Error = "error",
Loading = "loading"
}
export declare const resetActiveDeviceId: () => void;
export declare const resetAutocaptureState: () => void;
export declare const resetDeviceStore: () => void;
export declare const resetPersistedTags: (newTags?: Tags) => void;
export declare const resetStores: () => void;
export declare const resetWorkflowInstance: () => void;
export declare interface Resolution {
width: number;
height: number;
}
export declare const restartAutocaptureStep: () => void;
export declare type RestoreFromBackup = () => void;
export declare interface RiskSignals {
deviceId?: string;
deviceLabel?: string;
groupId?: string;
installationId?: string;
}
export declare const runtime: EventDispatcher_2<EventMetadata_2>;
export declare const saturate: (hex: string, ratio: number) => string;
export declare interface ScanningTransition {
scanningBorderOpacity1: number;
scanningBorderOpacity2: number;
borderLineDashOffset: number;
borderWidth: number;
borderLineDashPart1: number;
borderLineDashPart2: number;
faceFinderCx: number;
faceFinderCy: number;
faceFinderRx: number;
faceFinderRy: number;
circumference: number;
}
export declare class ScanQrCodeComponent extends BaseComponent {
static styles: CSSResult[];
uri: string;
readonly qrCodeRef: Ref_2<QrCodeComponent>;
render(): TemplateResult_2<1>;
}
export declare enum SdkType {
Iovation = "IOVATION"
}
export declare type SdkTypeType = Static<typeof TbSdkType>;
export declare const selectActiveTrackState$: () => Observable<ActiveTrackState_2 | undefined>;
export declare const selectAggregatedFeedback$: (fpsThreshold: number) => Observable<AutocaptureFeedback | AutocaptureFeedbackSmoothed | undefined>;
export declare const selectAutocaptureDocFinder$: () => Observable<AutocaptureStateDocFinderPosition>;
export declare const selectAutocaptureExcludedDevices$: () => Observable<string[]>;
export declare const selectAutocaptureRestart$: () => Observable<undefined>;
export declare const selectAutocaptureSettings$: () => Observable<{
fallbackTimeInMs?: number | undefined;
excludeDevices?: string[] | undefined;
focusTimeInMs?: number | undefined;
}>;
export declare const selectAutocaptureState$: () => Observable<AutocaptureState>;
export declare const selectAutocaptureStore$: () => Observable<AutocaptureStore>;
export declare const selectCameraBusyStatus$: () => Observable<boolean>;
export declare const selectCameraPermissionState$: () => Observable<PermissionState>;
export declare const selectCameraPlaybackRequest$: () => Observable<SwitchCameraCommand | SwitchStreamCommand>;
export declare const selectCameraSelectorDeviceList$: () => Observable< {
devices: JMediaDeviceInfo_2[];
currentDevice: JMediaDeviceInfo_2 | undefined;
isBusy: boolean;
}>;
export declare const selectCameraState$: () => Observable< {
resolution: Resolution;
activeTrackState: ActiveTrackState_2 | undefined;
cameraFacingMode: CameraFacingMode;
isPlaying: boolean;
isBusy: boolean;
}>;
export declare const selectCaptureHintsState$: () => Observable<HelpStore>;
export declare const selectConsents$: () => Observable<ConsentItem[]>;
export declare const selectCredentialsFromSettings$: () => Observable<(({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload[];
predefinedType: PredefinedType_3;
} | undefined;
country?: {
values: CountryCode[];
predefinedType: PredefinedType_3;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category.Id;
requiredParts: IdSide_3[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_3[];
predefinedType: PredefinedType_3;
};
category: Category.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType_3;
};
category: Category.Document;
country: {
values: CountryCode[];
predefinedType: PredefinedType_3;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType_3;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[]>;
export declare const selectCrossDeviceEnabledSettings$: () => Observable<boolean>;
export declare const selectCrossDeviceSettings$: () => Observable<MerchantSettingsCrossDevice | undefined>;
export declare const selectCurrentDevice$: () => Observable<JMediaDeviceInfo | undefined>;
export declare const selectCurrentFps$: () => Observable<number | undefined>;
export declare const selectDeviceStore$: () => Observable<DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
}>;
export declare const selectedCountry: EventDispatcher_2< {
country: string | undefined;
}>;
export declare const selectedDocument: EventDispatcher_2< {
document: string;
}>;
export declare const selectedDocumentVariant: EventDispatcher_2< {
variant: string;
}>;
export declare const selectEidasUrl$: () => Observable<string | undefined>;
export declare const selectEssentialWorkflowParams$: () => Observable<{
step: VirtualStep.Setup;
substep: undefined;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: VirtualStep.Start;
substep: StartStep_2;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: Category_3.Id;
substep: IdStep_2;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: Category_3.Facemap;
substep: FacemapStep_2;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: Category_3.Document;
substep: DocumentStep_2;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: Category_3.Data;
substep: DataStep_2;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
} | {
step: VirtualStep.Finish;
substep: undefined;
credentialId: UUID_2 | undefined;
shouldStoreNavigationState: boolean;
activeScreen: ActiveScreen;
parsedToken?: Token_2<Date> | undefined;
token: string;
transactionId: UUID_2;
tokenExpired: boolean;
sessionUrl: string;
baseUrl: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
}>;
export declare const selectFaceFinderBackgroundColor$: () => Observable<string | undefined>;
export declare const selectFaceFinderCanvasSize$: () => Observable<DsDimensions | undefined>;
export declare const selectFaceFinderEllipse$: (visibleFaceFinder$?: Observable<LivenessFaceFinder_2>, canvasSize$?: Observable<DsDimensions | undefined>) => Observable<LivenessFaceFinderEllipse>;
export declare const selectFaceFinderOval$: () => Observable<LivenessFaceFinder_2>;
export declare const selectFaceFinderScanning$: () => Observable<boolean>;
export declare const selectFaceFinderState$: () => Observable<{
scanning: boolean;
backgroundColor: string | undefined;
faceFinderEllipse: LivenessFaceFinderEllipse;
videoSize: DsDimensions | undefined;
}>;
export declare const selectFilteredRealVideoDeviceList$: () => Observable<JMediaDeviceInfo[]>;
export declare const selectFilteredVideoDeviceList$: () => Observable<JMediaDeviceInfo[]>;
export declare const selectHasFileUpload$: (credentialId: UUID) => Observable<boolean>;
export declare const selectHelpTimeoutForCredential$: (credential: Category) => Observable<number>;
export declare const selectIsCameraPlaying$: () => Observable<boolean>;
export declare const selectIsExplicitUploadEnabled$: () => Observable<boolean | undefined>;
export declare const selectIsFileUploadEnabled$: () => Observable<boolean | undefined>;
export declare const selectIsFlipped$: () => Observable<boolean>;
export declare const selectLivenessRetries$: () => Observable<number>;
export declare const selectPermissionState$: () => Observable<PermissionStore>;
export declare const selectProcessedUsabilityEntities$: (credentialId: UUID) => Observable<(UsabilityCheckStateBase_2<UsabilityCheckStatus.Success> & {
result: UsabilityResult_2<DecisionType>;
})[]>;
export declare const selectRecoveringState$: () => Observable<boolean>;
export declare const selectSettings$: () => Observable<{
linked?: boolean | undefined;
dvFileUploadEnabled?: boolean | undefined;
merchantSettings?: {
autoCapture?: {
idEnabled?: boolean | undefined;
docVEnabled?: boolean | undefined;
} | undefined;
branding?: {
primaryColor?: string | undefined;
accentColor?: string | undefined;
logoUri?: string | undefined;
} | undefined;
crossDevice?: {
link?: string | undefined;
crossDeviceOption?: CrossDeviceOption_3 | undefined;
enabled: boolean;
} | undefined;
crossDeviceOnly?: boolean | undefined;
datadog?: {
enabled: boolean;
merchantName: string;
} | undefined;
isExplicitUploadEnabled?: boolean | undefined;
isFileUploadEnabled?: boolean | undefined;
jLiveEnabled?: boolean | undefined;
skipLivenessGuidancePage?: boolean | undefined;
jLiveFallbackPolicy: JLiveFallbackPolicy;
} | undefined;
networkThrottlingLimit?: number | undefined;
redirects?: {
error?: string | undefined;
success?: string | undefined;
} | undefined;
returnImages?: boolean | undefined;
skipDocTypeSelection?: boolean | undefined;
iproovTokenData?: {
url: string;
token: string;
productType: "IPROOV_STANDARD" | "IPROOV_PREMIUM";
remainingAttempts: number;
} | undefined;
skipStartScreen?: boolean | undefined;
eidasUrl?: string | undefined;
timestamp: string;
configurations: {
focusScore?: string | undefined;
cvAnalytics?: string | undefined;
networkTimeouts?: {
finalize: number;
upload: number;
usability: number;
extractdata: number;
analytics: number;
reporting: number;
iproovtoken: number;
iproovvalidate: number;
cdn: number;
} | undefined;
cdnEnc?: {
name: string;
file: string;
key: string;
iv: string;
}[] | undefined;
shakeDetection?: string | undefined;
instantFeedback?: string | undefined;
docFinder?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
} | undefined;
consentURL?: string | undefined;
iproovMaxAttempts?: string | undefined;
skipConfirm?: string | undefined;
consentRequired?: string | undefined;
cvMrzThreshold?: string | undefined;
cdnPublicKey?: string | undefined;
maxRetries?: string | undefined;
iproovEnabled?: string | undefined;
maxPollingTime?: string | undefined;
barcodeScannerKey?: string | undefined;
dataPrivacyUrl?: string | undefined;
dataDog?: {
appId: string;
clientId: string;
} | undefined;
shakeScore?: string | undefined;
sardineClientId?: string | undefined;
fileUpload?: {
fallbackTimeInMs: number;
isFallbackUploadEnabled: boolean;
} | undefined;
jumioLiveness?: {
frameRateThreshold: number;
samplingTimeInMs: number;
violationLimit: number;
modelInitTimeoutInMs: number;
retries: number;
minNearFarRatio: number;
maxFaceCenterDifference: number;
tooFarThreshold: number;
tooNearThreshold: number;
initialImages: number;
transitionImages: number;
nearImages: number;
farImages: number;
minTimePerDistanceInMs: number;
maxConsecutiveImageTimespanInMs: number;
imageResolutionWidth: number;
imageResolutionHeight: number;
imageCompression: number;
fallbackTimeInMs: number;
userFallbackAllowed: boolean;
minimumPseudoPitch: number;
maximumPseudoPitch: number;
minimumPseudoYaw: number;
maximumPseudoYaw: number;
} | undefined;
idAutocapture?: {
fallbackTimeInMs?: number | undefined;
excludeDevices?: string[] | undefined;
focusTimeInMs?: number | undefined;
} | undefined;
helpScreen?: {
ID: number;
FACEMAP: number;
DOCUMENT: number;
DATA: number;
} | undefined;
cameraData?: {
cameraTimeoutMs?: number | undefined;
resolutionId?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionFacemap?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
resolutionDocument?: {
width: number;
height: number;
aspectRatio: number;
} | undefined;
} | undefined;
sensorData?: {
intervalLog: number;
intervalSend: number;
} | undefined;
supplementalImagesV2?: {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
} | {
images: {
neededByDefault?: boolean | undefined;
captureFrequency: number;
classifier: "ID_SEQUENCE" | "SELFIE_SEQUENCE";
maxBatch: number;
maxQueueSizeBytes: number;
minBufferAge: number;
resolutions: number[];
}[];
}[] | undefined;
};
accountId: string;
acquisitionReference: string;
analyticsEnabled: boolean;
brandingEnabled: boolean;
consents: {
privacyPolicyUrl?: string | undefined;
id: string;
text: string;
displayType: ConsentDisplayType_3;
alternativeTexts: {
ar?: string | undefined;
bg?: string | undefined;
cs?: string | undefined;
da?: string | undefined;
de?: string | undefined;
el?: string | undefined;
en?: string | undefined;
en_GB?: string | undefined;
"en-GB"?: string | undefined;
en_US?: string | undefined;
"en-US"?: string | undefined;
es?: string | undefined;
es_MX?: string | undefined;
"es-MX"?: string | undefined;
et?: string | undefined;
fi?: string | undefined;
fr?: string | undefined;
he?: string | undefined;
hr?: string | undefined;
hu?: string | undefined;
hy?: string | undefined;
id?: string | undefined;
it?: string | undefined;
ja?: string | undefined;
ka_GE?: string | undefined;
"ka-GE"?: string | undefined;
km?: string | undefined;
km_KH?: string | undefined;
"km-KH"?: string | undefined;
ko?: string | undefined;
lt?: string | undefined;
ms?: string | undefined;
nl?: string | undefined;
no?: string | undefined;
pl?: string | undefined;
pt?: string | undefined;
pt_BR?: string | undefined;
"pt-BR"?: string | undefined;
ro?: string | undefined;
ru?: string | undefined;
sk?: string | undefined;
sr_Cyrl?: string | undefined;
"sr-Cyrl"?: string | undefined;
sr?: string | undefined;
sr_Latn?: string | undefined;
"sr-Latn"?: string | undefined;
sv?: string | undefined;
sw?: string | undefined;
th?: string | undefined;
tr?: string | undefined;
uk?: string | undefined;
vi?: string | undefined;
zh?: string | undefined;
zh_CN?: string | undefined;
"zh-CN"?: string | undefined;
zh_HK?: string | undefined;
"zh-HK"?: string | undefined;
};
}[];
countryForIp: string;
credentials: (({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: IdTypeUpload[];
predefinedType: PredefinedType_3;
} | undefined;
country?: {
values: CountryCode[];
predefinedType: PredefinedType_3;
} | undefined;
deviceRiskVendors?: string[] | undefined;
category: Category.Id;
requiredParts: IdSide_3[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
requiredParts?: string[] | undefined;
deviceRiskVendors?: string[] | undefined;
type: {
values: FacemapVerificationMethod_3[];
predefinedType: PredefinedType_3;
};
category: Category.Facemap;
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type: {
values: string[];
predefinedType: PredefinedType_3;
};
category: Category.Document;
country: {
values: CountryCode[];
predefinedType: PredefinedType_3;
};
requiredParts: string[];
deviceRiskVendors: string[];
}) | ({
id: string;
capabilities: {
id: string;
name: string;
}[];
} & {
type?: {
values: string[];
predefinedType: PredefinedType_3;
} | undefined;
capabilities: {
id: string;
name: string;
}[];
category: Category.Data;
requiredParts: string[];
deviceRiskVendors: string[];
}))[];
deviceRiskTokenData: {
token: string;
sdkType: SdkType_3.Iovation;
}[];
maxFileUploadSize: number;
stateForIp: string;
supportedCountries: {
country: CountryCode;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
idType: IdTypeUpload;
variants: {
format?: IdFormat_3 | undefined;
variant: DocumentVariant;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[];
supportedDocumentTypes: {
translations?: {
[x: string]: string;
} | undefined;
code: string;
name: string;
maxPages: number;
}[];
workflowDefinitionKey: number;
}>;
export declare const selectSetupWorkflowParams$: () => Observable<{
token: string;
baseUrl: string;
transactionId: string;
locale: Locale;
}>;
export declare const selectSupportedCountries$: () => Observable<{
country: CountryCode;
idTypes: {
digitalIdentity?: {
file?: string | undefined;
type: DigitalIdentityType_3;
title: string;
requestedIdType: IdTypeUpload;
} | undefined;
idType: IdTypeUpload;
variants: {
format?: IdFormat_3 | undefined;
variant: DocumentVariant;
parts: {
side: IdSide_3;
masking: boolean;
extraction: (string | null)[];
}[];
}[];
}[];
}[]>;
export declare const selectToken$: () => Observable<TokenState<Date>>;
export declare const selectUnfilteredMockVideoDeviceList$: () => Observable<JMediaDeviceInfo[]>;
export declare const selectUnfilteredRealVideoDeviceList$: () => Observable<JMediaDeviceInfo[]>;
export declare const selectUploadedPdfFile$: (credentialId: UUID) => Observable<Blob | undefined>;
export declare const selectUploadEntitiesByCredentialId$: (credentialId: UUID) => Observable<getEntityType< {
uploadEntities: Record<FileStoreKey, UploadState>;
uploadIds: FileStoreKey[];
} & {
usabilityEntities: Record<FileStoreKey, UsabilityCheckState>;
usabilityIds: FileStoreKey[];
}, EntitiesRef<"uploadEntities", "uploadIds", "idKeyUpload">>[]>;
export declare const selectUploadEntitiesWithDecisionType$: <T extends DecisionType>(credentialId: UUID, decisionType?: T | undefined) => Observable<(UploadStateBase_2<UploadStatus.Success> & {
blob: Blob;
usabilityId: string;
filename?: string;
})[]>;
export declare const selectUsabilityEntitiesByCredentialId$: (credentialId: UUID) => Observable<UsabilityCheckState[]>;
export declare const selectUsabilityEntitiesWithDecision$: <T extends DecisionType>(credentialId: UUID, decisionType?: T | undefined) => Observable<(UsabilityCheckStateBase_2<UsabilityCheckStatus.Success> & {
result: UsabilityResult_2<T>;
})[]>;
export declare const selectVideoResolution$: () => Observable<Resolution>;
export declare const selectVideoSize$: () => Observable<DsDimensions | undefined>;
export declare const selectWorkflowState$: () => Observable<WorkflowState>;
export declare const selectWorkflowStep$: () => Observable<VirtualStep | Category_3>;
export declare const selectWorkflowStepInformation$: () => Observable<NavigationStepVirtualStepSetup_2 | NavigationStepVirtualStepStart_2 | NavigationStepCategoryId_2 | NavigationStepCategoryFacemap_2 | NavigationStepCategoryDocument_2 | NavigationStepCategoryData_2 | NavigationStepVirtualStepFinish_2>;
export declare const selectWorkflowSubstep$: () => Observable<StartStep_2 | IdStep_2 | FacemapStep_2 | DocumentStep_2 | DataStep_2 | undefined>;
export declare interface SendEventRequest {
events: EventBody[];
}
export declare type SensorCaptureIntervals = Static<typeof TbSensorCaptureIntervals>;
export declare interface SensorData extends EventMetadata {
screen?: string;
credentialId?: string;
timestamp?: Date;
samplingIntervalMs?: number;
accelerometer: {
x: number;
y: number;
z: number;
}[];
gyroscope: {
alpha: number;
beta: number;
gamma: number;
}[];
message?: string;
}
export declare const sensorData: EventDispatcher_2<SensorData>;
export declare const serializeDeviceList: (devices: MediaDeviceInfo[]) => string;
export declare const serializeUrl: <T extends NavigationStep>(navigationStep: T) => string | undefined;
export declare class SessionUrlBoxComponent extends BaseComponent {
static styles: CSSResult[];
url: string;
render(): TemplateResult<1>;
copyToClipboard(): Promise<void>;
}
export declare const setAcceptableConsents: (consents: AcceptableConsentItem[]) => void;
export declare const setActiveDeviceById: (deviceId: DeviceStore["deviceId"]) => void;
export declare const setAutocaptureState: (state: AutocaptureState, fallbackReason?: ManualCaptureFallbackReason) => void;
export declare const setCameraFilterFn: (filterFn: CameraFilterFn | undefined) => void;
export declare const setCameraPermissionState: (permissionState: PermissionState) => void;
export declare const setCameraState: (newState: Partial<CameraStoreState>) => void;
export declare const setCaptureHintsState: (params?: Partial<HelpStore>) => void;
export declare const setConsentGivenSend: () => void;
export declare const setConsentSettingsFetched: (settingsFetched: boolean) => void;
export declare const setDeviceList: (devices: JMediaDeviceInfo[]) => void;
export declare const setFaceFinderBackgroundColor: (color: string | undefined) => void;
export declare const setFaceFinderCanvasSize: (canvasSize: DsDimensions) => void;
export declare const setFaceFinderDistance: (distance: LivenessFaceFinderDistance) => void;
export declare const setFaceFinderScanning: (scanning: boolean) => void;
export declare const setFaceFinderVideoSize: (videoSize: DsDimensions) => void;
export declare const setLocationHref: (url: string) => void;
export declare const setMockedUrl: (...urls: string[]) => void;
export declare const setPermissionQueryMock: (handler: PermissionQuery) => void;
export declare const setRecoveringState: (value: boolean) => void;
export declare const setSettings: (settings: Settings) => void;
export declare type Settings = Static<typeof TbSettingsSchema>;
export declare const settings: EventDispatcher_2< {
credentials: unknown;
}>;
export declare interface SettingsRequest extends Record<string, unknown> {
linkedModules: LinkedModule[];
deviceDetails: DeviceDetails;
}
export declare type SettingsWithoutConfigurations = Static<typeof TbSettingsWithoutConfigurationsSchema>;
export declare const setupTemplateSettings: () => void;
export declare type SetWorkflowStep = (params: NavigationStep) => void;
export declare const setWorkflowStep: SetWorkflowStep;
export declare class SFSafariViewControllerCameraError extends DOMException {
constructor(message?: string);
}
export declare const SFSafariViewControllerCameraErrorName = "SFSafariViewControllerCameraError";
export declare class SheetComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
export declare class ShieldListComponent extends BaseComponent {
static styles: CSSResult[];
items: ShieldListItemComponent[];
render(): TemplateResult_2<1>;
}
export declare class ShieldListItemComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
export declare class ShimmerLoader extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
export declare const shownCameraAccessRequestScreen: EventDispatcher_2< {
kind: "denied" | "prompt";
devices: MediaDeviceMetadata[];
}>;
export declare const shownCameraCaptureHints: EventDispatcher_2< {
visible: boolean;
}>;
export declare const shownConsentMessage: EventDispatcher_2<EventMetadata_2>;
export declare const shownCrossDeviceFinishScreen: EventDispatcher_2< {
acquisitionStatus: AcquisitionStatus;
error?: PublicError;
}>;
export declare const shownCrossDeviceScreen: EventDispatcher_2<EventMetadata_2>;
export declare const shownError: EventDispatcher_2<EventMetadata_2>;
export declare const shownFinishScreen: EventDispatcher_2< {
outcome: RequestOutcome<FinalizeResponse | undefined, unknown>;
}>;
export declare const showRetryScreen: EventDispatcher_2< {
category?: Category;
rejectionReasons: Partial<Record<FileStoreKey, ReasonCode>>;
rejectionCodeKeys: Partial<Record<ReasonCode, FileStoreKey[]>>;
codes: ReasonCode[];
}>;
export declare const sortAlphabeticallyByKey: <K extends string, T extends Record<K, string>>(items: T[], key: K, ascending?: boolean) => T[];
export declare enum Source {
Camera = "camera",
Upload = "upload",
Preview = "preview"
}
export declare class StartCaptureEvent extends CustomEvent<void> {
constructor();
}
export declare enum StartStep {
Start = "start-screen-start",
ConsentScreen = "start-screen-consent",
Finish = "start-screen-finish"
}
export declare interface StateMachineCredentialIdLike {
credentialId: UUID;
}
export declare interface StateMachineSnapshotValue {
step: Record<UUID, string> | string;
activeScreen: ActiveScreen;
}
export declare interface StepCallback {
target: string;
actions?: ReturnType<typeof generateAction>;
}
export declare type StepChangeCallback = <T extends CredentialStep>(params: StepChangeParams<T>) => void;
export declare interface StepChangeParams<T extends CredentialStep = CredentialStep> {
controller: WorkflowStepControllerMap[T];
}
export declare enum StepNavigationAction {
PreviousStep = "step-navigation-previous-step",
NextStep = "step-navigation-next-step"
}
export declare type StopAnimation = () => void;
export declare interface StopStreamParams {
playbackCancelNotifier$: Subject<void>;
resetBusyState: boolean;
unsetVideoSource: () => void;
videoElement?: HTMLVideoElement;
videoSource?: MediaStream | string;
}
export declare const STORE_TOKENS: {
CredentialIdStoreFactory: symbol;
CredentialFacemapStoreFactory: symbol;
CredentialDocumentStoreFactory: symbol;
};
export declare interface StoreForIdCredential {
selectedCountry?: CountryCode;
selectedIdType?: IdTypeUpload;
selectedDocumentVariant?: DocumentVariant;
selectedIdFormat?: IdFormat;
selectedDigitalIdentity?: DigitalIdentityProps;
}
export declare const storeInversifyContainer: Container;
export declare const stylesGeneric: CSSResult;
export declare const stylesTextStyles: CSSResult;
export declare const stylesVariables: CSSResult;
export declare class SuccessMarkComponent extends BaseComponent {
render(): TemplateResult<2>;
}
export declare class SuccessMessageComponent extends BaseComponent {
static styles: CSSResult[];
title: string;
message: string;
overlay: boolean;
buttonElements: HTMLElement[];
render(): TemplateResult_2<1>;
}
export declare type SupplementalImageUpdateNotifier = () => void;
export declare type SupplementalImageUploadTypePrefix = SupplementalImageUploadTypePrefixId | SupplementalImageUploadTypePrefixSelfie;
export declare type SupplementalImageUploadTypePrefixId = `ID_SEQUENCE_${UploadType.BackSide | UploadType.FrontSide}_`;
export declare type SupplementalImageUploadTypePrefixSelfie = `LIVENESS_SERIES_`;
export declare type SupportedCountry = Static<typeof TbSupportedCountrySchema>;
export declare type SupportedDocumentType = Static<typeof TbSupportedDocumentTypeSchema>;
export declare class SwitchCameraCommand extends CustomEvent<JMediaDeviceInfo> {
constructor(detail: JMediaDeviceInfo);
}
export declare const SwitchCameraCommandType = "switchcamera";
export declare class SwitchStreamCommand extends CustomEvent<SwitchStreamCommandParams> {
constructor(detail: SwitchStreamCommandParams);
}
export declare interface SwitchStreamCommandParams {
constraints: DeviceIdConstraint | FacingModeConstraint;
}
export declare const SwitchStreamCommandType = "switchstream";
export declare type TagName = 'cameraEverPlayed' | 'classifier' | 'country' | 'customerId' | 'customerName' | 'customerReference' | 'device' | 'deviceNames' | 'displayMode' | 'document' | 'error' | 'hostname' | 'hostnameRuntime' | 'hostnameRuntimeOs' | 'hostnameRuntimeOsVersion' | 'hostnameRuntimeWorkflow' | 'hostnameRuntimeWorkflowOs' | 'hostnameWorkflow' | 'hostnameWorkflowOs' | 'idAutocaptureFallbackReason' | 'idAutocaptureFps' | 'idAutocaptureState' | 'iframe' | 'jLiveDuration' | 'jliveFramesCaptured' | 'jliveProgressCurrentStep' | 'jliveProgressStepsTotal' | 'jumioHosted' | 'lastScreen' | 'linked' | 'locale' | 'runtime' | 'runtimeWorkflow' | 'scanReference' | 'screen' | 'supplementalImageFpsFacemap' | 'supplementalImageFpsId' | 'templates' | 'variant' | 'webview' | 'workflow';
export declare type Tags<N extends TagName = TagName> = Partial<Record<N, unknown>>;
export declare const TbAcceptableConsentItemSchema: TObject< {
id: TString;
item: TObject< {
id: TString;
privacyPolicyUrl: TOptional<TString>;
displayType: TEnum<typeof ConsentDisplayType>;
text: TString;
alternativeTexts: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
}>;
given: TBoolean;
timestamp: TOptional<TNumber>;
}>;
export declare const TbAcquisitionStatus: TEnum<typeof AcquisitionStatus>;
export declare const TbActiveScreen: TEnum<typeof ActiveScreen>;
export declare const TbAlternativeTextsSchema: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
export declare const TbBarcodeFormat: TEnum<typeof BarcodeFormat>;
export declare const TbCapabilitySchema: TObject< {
id: TString;
name: TString;
}>;
export declare const TbCategory: TEnum<typeof Category>;
export declare const TbConfigurationAutocaptureSettingsSchema: TObject< {
fallbackTimeInMs: TOptional<TNumber>;
excludeDevices: TOptional<TArray<TString>>;
focusTimeInMs: TOptional<TNumber>;
}>;
export declare const TbConfigurationCameraResolutionSchema: TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>;
export declare const TbConfigurationCameraSchema: TObject< {
cameraTimeoutMs: TOptional<TNumber>;
resolutionId: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionFacemap: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionDocument: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
}>;
export declare const TbConfigurationCdnEncSchema: TObject< {
name: TString;
file: TString;
key: TString;
iv: TString;
}>;
export declare const TbConfigurationDataDogSchema: TObject< {
appId: TString;
clientId: TString;
}>;
export declare const TbConfigurationDocFinderSchema: TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
}>;
export declare const TbConfigurationFileUploadSchema: TObject< {
fallbackTimeInMs: TNumber;
isFallbackUploadEnabled: TBoolean;
}>;
export declare const TbConfigurationHelpScreenSchema: TObject< {
ID: TNumber;
FACEMAP: TNumber;
DOCUMENT: TNumber;
DATA: TNumber;
}>;
export declare const TbConfigurationNetworkTimeoutsSchema: TObject< {
upload: TNumber;
usability: TNumber;
finalize: TNumber;
extractdata: TNumber;
analytics: TNumber;
reporting: TNumber;
iproovtoken: TNumber;
iproovvalidate: TNumber;
cdn: TNumber;
}>;
export declare const TbConfigurationsLikeSchema: TObject< {
configurations: TObject< {
focusScore: TOptional<TString>;
cvAnalytics: TOptional<TString>;
networkTimeouts: TOptional<TObject< {
upload: TNumber;
usability: TNumber;
finalize: TNumber;
extractdata: TNumber;
analytics: TNumber;
reporting: TNumber;
iproovtoken: TNumber;
iproovvalidate: TNumber;
cdn: TNumber;
}>>;
cdnEnc: TOptional<TArray<TObject< {
name: TString;
file: TString;
key: TString;
iv: TString;
}>>>;
shakeDetection: TOptional<TString>;
instantFeedback: TOptional<TString>;
docFinder: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
}>>;
consentURL: TOptional<TString>;
iproovMaxAttempts: TOptional<TString>;
skipConfirm: TOptional<TString>;
consentRequired: TOptional<TString>;
cvMrzThreshold: TOptional<TString>;
cdnPublicKey: TOptional<TString>;
maxRetries: TOptional<TString>;
iproovEnabled: TOptional<TString>;
maxPollingTime: TOptional<TString>;
barcodeScannerKey: TOptional<TString>;
dataPrivacyUrl: TOptional<TString>;
dataDog: TOptional<TObject< {
appId: TString;
clientId: TString;
}>>;
shakeScore: TOptional<TString>;
sardineClientId: TOptional<TString>;
fileUpload: TOptional<TObject< {
fallbackTimeInMs: TNumber;
isFallbackUploadEnabled: TBoolean;
}>>;
jumioLiveness: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
retries: TNumber;
minNearFarRatio: TNumber;
maxFaceCenterDifference: TNumber;
tooFarThreshold: TNumber;
tooNearThreshold: TNumber;
initialImages: TNumber;
transitionImages: TNumber;
nearImages: TNumber;
farImages: TNumber;
minTimePerDistanceInMs: TNumber;
maxConsecutiveImageTimespanInMs: TNumber;
imageResolutionWidth: TNumber;
imageResolutionHeight: TNumber;
imageCompression: TNumber;
fallbackTimeInMs: TNumber;
userFallbackAllowed: TBoolean;
minimumPseudoPitch: TNumber;
maximumPseudoPitch: TNumber;
minimumPseudoYaw: TNumber;
maximumPseudoYaw: TNumber;
}>>;
idAutocapture: TOptional<TObject< {
fallbackTimeInMs: TOptional<TNumber>;
excludeDevices: TOptional<TArray<TString>>;
focusTimeInMs: TOptional<TNumber>;
}>>;
helpScreen: TOptional<TObject< {
ID: TNumber;
FACEMAP: TNumber;
DOCUMENT: TNumber;
DATA: TNumber;
}>>;
cameraData: TOptional<TObject< {
cameraTimeoutMs: TOptional<TNumber>;
resolutionId: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionFacemap: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionDocument: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
}>>;
sensorData: TOptional<TObject< {
intervalLog: TNumber;
intervalSend: TNumber;
}>>;
supplementalImagesV2: TOptional<TUnion<[TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>, TArray<TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>>]>>;
}>;
}>;
export declare const TbConfigurationsSchema: TObject< {
focusScore: TOptional<TString>;
cvAnalytics: TOptional<TString>;
networkTimeouts: TOptional<TObject< {
upload: TNumber;
usability: TNumber;
finalize: TNumber;
extractdata: TNumber;
analytics: TNumber;
reporting: TNumber;
iproovtoken: TNumber;
iproovvalidate: TNumber;
cdn: TNumber;
}>>;
cdnEnc: TOptional<TArray<TObject< {
name: TString;
file: TString;
key: TString;
iv: TString;
}>>>;
shakeDetection: TOptional<TString>;
instantFeedback: TOptional<TString>;
docFinder: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
}>>;
consentURL: TOptional<TString>;
iproovMaxAttempts: TOptional<TString>;
skipConfirm: TOptional<TString>;
consentRequired: TOptional<TString>;
cvMrzThreshold: TOptional<TString>;
cdnPublicKey: TOptional<TString>;
maxRetries: TOptional<TString>;
iproovEnabled: TOptional<TString>;
maxPollingTime: TOptional<TString>;
barcodeScannerKey: TOptional<TString>;
dataPrivacyUrl: TOptional<TString>;
dataDog: TOptional<TObject< {
appId: TString;
clientId: TString;
}>>;
shakeScore: TOptional<TString>;
sardineClientId: TOptional<TString>;
fileUpload: TOptional<TObject< {
fallbackTimeInMs: TNumber;
isFallbackUploadEnabled: TBoolean;
}>>;
jumioLiveness: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
retries: TNumber;
minNearFarRatio: TNumber;
maxFaceCenterDifference: TNumber;
tooFarThreshold: TNumber;
tooNearThreshold: TNumber;
initialImages: TNumber;
transitionImages: TNumber;
nearImages: TNumber;
farImages: TNumber;
minTimePerDistanceInMs: TNumber;
maxConsecutiveImageTimespanInMs: TNumber;
imageResolutionWidth: TNumber;
imageResolutionHeight: TNumber;
imageCompression: TNumber;
fallbackTimeInMs: TNumber;
userFallbackAllowed: TBoolean;
minimumPseudoPitch: TNumber;
maximumPseudoPitch: TNumber;
minimumPseudoYaw: TNumber;
maximumPseudoYaw: TNumber;
}>>;
idAutocapture: TOptional<TObject< {
fallbackTimeInMs: TOptional<TNumber>;
excludeDevices: TOptional<TArray<TString>>;
focusTimeInMs: TOptional<TNumber>;
}>>;
helpScreen: TOptional<TObject< {
ID: TNumber;
FACEMAP: TNumber;
DOCUMENT: TNumber;
DATA: TNumber;
}>>;
cameraData: TOptional<TObject< {
cameraTimeoutMs: TOptional<TNumber>;
resolutionId: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionFacemap: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionDocument: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
}>>;
sensorData: TOptional<TObject< {
intervalLog: TNumber;
intervalSend: TNumber;
}>>;
supplementalImagesV2: TOptional<TUnion<[TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>, TArray<TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>>]>>;
}>;
export declare const TbConfigurationSupplementalImageClassifierSchema: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
export declare const TbConfigurationSupplementalImageSchema: TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>;
export declare const TbConfigurationSupplementalImagesV2Schema: TUnion<[TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>, TArray<TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>>]>;
export declare const TbConsentDisplayType: TEnum<typeof ConsentDisplayType>;
export declare const TbConsentItemCollectionSchema: TArray<TObject< {
id: TString;
privacyPolicyUrl: TOptional<TString>;
displayType: TEnum<typeof ConsentDisplayType>;
text: TString;
alternativeTexts: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
}>>;
export declare const TbConsentItemSchema: TObject< {
id: TString;
privacyPolicyUrl: TOptional<TString>;
displayType: TEnum<typeof ConsentDisplayType>;
text: TString;
alternativeTexts: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
}>;
export declare const TbCountryCodeSchema: TEnum<typeof CountryCode>;
export declare type TbCountryCodeType = Static<typeof TbCountryCodeSchema>;
export declare const TbCredentialBaseSchema: TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>;
export declare const TbCredentialDataSchema: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Data>;
deviceRiskVendors: TArray<TString>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>>;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
requiredParts: TArray<TString>;
}>]>;
export declare const TbCredentialDocumentSchema: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Document>;
country: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>;
deviceRiskVendors: TArray<TString>;
requiredParts: TArray<TString>;
}>]>;
export declare const TbCredentialFacemapSchema: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Facemap>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<FacemapVerificationMethod_2>>;
}>;
requiredParts: TOptional<TArray<TString>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>;
export declare const TbCredentialIdSchema: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Id>;
country: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<IdTypeUpload_2>>;
}>>;
requiredParts: TArray<TEnum<IdSide_2>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>;
export declare const TbCredentialStep: TUnion<[TEnum<typeof Category>, TEnum<typeof VirtualStep>]>;
export declare const TbCrossDeviceOption: TEnum<typeof CrossDeviceOption>;
export declare const TbDataCenter: TEnum<typeof DataCenter>;
export declare const TbDecisionType: TEnum<typeof DecisionType>;
export declare const TbDeviceCategory: TEnum<typeof DeviceCategory>;
export declare const TbDeviceIdConstraintSchema: TObject< {
video: TObject< {
deviceId: TObject< {
exact: TString;
}>;
}>;
audio: TLiteral<false>;
}>;
export declare const TbDeviceRiskTokenSchema: TObject< {
token: TString;
sdkType: TEnum<typeof SdkType>;
}>;
export declare const TbDigitalIdentityPropsSchema: TObject< {
title: TString;
type: TEnum<DigitalIdentityType_2>;
requestedIdType: TEnum<typeof IdTypeUpload>;
file: TOptional<TString>;
}>;
export declare const TbDigitalIdentityTypeSchema: TEnum<typeof DigitalIdentityType>;
export declare const TbDocumentTypeCode: TString;
export declare const TbDocumentVariant: TEnum<typeof DocumentVariant>;
export declare const TbEmailErrorReason: TEnum<typeof EmailErrorReason>;
export declare const TbErrorDomain: TEnum<typeof ErrorDomain>;
export declare const TbExtractionSide: TEnum<typeof ExtractionSide>;
export declare const TbEyeTrackingDataSchema: TObject< {
saccade: TOptional<TNumber>;
fixation: TOptional<TNumber>;
blinks: TOptional<TNumber>;
smooth: TOptional<TNumber>;
micro: TOptional<TNumber>;
nullMovement: TOptional<TNumber>;
score: TOptional<TNumber>;
totalFrames: TOptional<TNumber>;
targetPositions: TOptional<TNumber>;
completed: TOptional<TBoolean>;
}>;
export declare const TbFacemapVerificationMethodSchema: TEnum<typeof FacemapVerificationMethod>;
export declare const TbFacingModeConstraintSchema: TObject< {
video: TIntersect<[TRecord<TString, TUnknown>, TObject< {
facingMode: TObject< {
ideal: TUnion<[TLiteral<"user">, TLiteral<"environment">]>;
}>;
}>]>;
audio: TLiteral<false>;
}>;
export declare const TbFileSource: TEnum<typeof FileSource>;
export declare const TbFileType: TEnum<typeof FileType>;
export declare const TbIdFormat: TEnum<typeof IdFormat>;
export declare const TbIdSideSchema: TEnum<typeof IdSide>;
export declare const TbIdTypeSchema: TObject< {
idType: TEnum<typeof IdTypeUpload>;
variants: TArray<TObject< {
variant: TEnum<typeof DocumentVariant>;
format: TOptional<TEnum<typeof IdFormat>>;
parts: TArray<TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>>;
}>>;
digitalIdentity: TOptional<TObject< {
title: TString;
type: TEnum<DigitalIdentityType_2>;
requestedIdType: TEnum<typeof IdTypeUpload>;
file: TOptional<TString>;
}>>;
}>;
export declare const TbIdTypeUploadSchema: TEnum<typeof IdTypeUpload>;
export declare const TbIdTypeVariantPartSchema: TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>;
export declare const TbIdTypeVariantSchema: TObject< {
variant: TEnum<typeof DocumentVariant>;
format: TOptional<TEnum<typeof IdFormat>>;
parts: TArray<TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>>;
}>;
export declare const TbIproovTokenDataSchema: TObject< {
token: TString;
url: TString;
productType: TUnion<[TLiteral<"IPROOV_PREMIUM">, TLiteral<"IPROOV_STANDARD">]>;
remainingAttempts: TNumber;
}>;
export declare const TbJCredentialMapSchema: TObject< {
ID: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Id>;
country: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<IdTypeUpload_2>>;
}>>;
requiredParts: TArray<TEnum<IdSide_2>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>;
FACEMAP: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Facemap>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<FacemapVerificationMethod_2>>;
}>;
requiredParts: TOptional<TArray<TString>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>;
DOCUMENT: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Document>;
country: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>;
deviceRiskVendors: TArray<TString>;
requiredParts: TArray<TString>;
}>]>;
DATA: TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Data>;
deviceRiskVendors: TArray<TString>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>>;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
requiredParts: TArray<TString>;
}>]>;
}>;
export declare const TbJCredentialSchema: TUnion<[TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Id>;
country: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<IdTypeUpload_2>>;
}>>;
requiredParts: TArray<TEnum<IdSide_2>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Facemap>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<FacemapVerificationMethod_2>>;
}>;
requiredParts: TOptional<TArray<TString>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Document>;
country: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>;
deviceRiskVendors: TArray<TString>;
requiredParts: TArray<TString>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category.Data>;
deviceRiskVendors: TArray<TString>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>>;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
requiredParts: TArray<TString>;
}>]>]>;
export declare const TbJLiveFallbackPolicy: TEnum<typeof JLiveFallbackPolicy>;
export declare const TbJumioLivenessSettingsSchema: TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
retries: TNumber;
minNearFarRatio: TNumber;
maxFaceCenterDifference: TNumber;
tooFarThreshold: TNumber;
tooNearThreshold: TNumber;
initialImages: TNumber;
transitionImages: TNumber;
nearImages: TNumber;
farImages: TNumber;
minTimePerDistanceInMs: TNumber;
maxConsecutiveImageTimespanInMs: TNumber;
imageResolutionWidth: TNumber;
imageResolutionHeight: TNumber;
imageCompression: TNumber;
fallbackTimeInMs: TNumber;
userFallbackAllowed: TBoolean;
minimumPseudoPitch: TNumber;
maximumPseudoPitch: TNumber;
minimumPseudoYaw: TNumber;
maximumPseudoYaw: TNumber;
}>;
export declare const TbLegacyErrorCode: TEnum<typeof LegacyErrorCode>;
export declare const TbLinkedModule: TEnum<typeof LinkedModule>;
export declare const TbLivenessResult: TEnum<typeof LivenessResult>;
export declare const TbLocaleSchema: TEnum<typeof Locale>;
export declare const TbManualCaptureFallbackReason: TEnum<typeof ManualCaptureFallbackReason>;
declare const TbMerchantSettingsAutocaptureSchema: TObject< {
idEnabled: TOptional<TBoolean>;
docVEnabled: TOptional<TBoolean>;
}>;
declare const TbMerchantSettingsBrandingSchema: TObject< {
primaryColor: TOptional<TString>;
accentColor: TOptional<TString>;
logoUri: TOptional<TString>;
}>;
declare const TbMerchantSettingsCrossDeviceSchema: TObject< {
crossDeviceOption: TOptional<TEnum<CrossDeviceOption_2>>;
enabled: TBoolean;
link: TOptional<TString>;
}>;
export declare const TbMerchantSettingsSchema: TObject< {
autoCapture: TOptional<TObject< {
idEnabled: TOptional<TBoolean>;
docVEnabled: TOptional<TBoolean>;
}>>;
branding: TOptional<TObject< {
primaryColor: TOptional<TString>;
accentColor: TOptional<TString>;
logoUri: TOptional<TString>;
}>>;
crossDevice: TOptional<TObject< {
crossDeviceOption: TOptional<TEnum<CrossDeviceOption_2>>;
enabled: TBoolean;
link: TOptional<TString>;
}>>;
crossDeviceOnly: TOptional<TBoolean>;
datadog: TOptional<TObject< {
enabled: TBoolean;
merchantName: TString;
}>>;
isExplicitUploadEnabled: TOptional<TBoolean>;
isFileUploadEnabled: TOptional<TBoolean>;
jLiveEnabled: TOptional<TBoolean>;
jLiveFallbackPolicy: TEnum<JLiveFallbackPolicy_2>;
skipLivenessGuidancePage: TOptional<TBoolean>;
}>;
export declare const TbMrzFormat: TEnum<typeof MrzFormat>;
export declare const TbOrientation: TEnum<typeof Orientation>;
export declare const TbPredefinedType: TEnum<typeof PredefinedType>;
export declare const TbPredefinedTypeAndValuesHolderSchema: <T extends TSchema>(valuesType: T) => TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<T>;
}>;
export declare const TbReasonCode: TEnum<typeof ReasonCode>;
export declare const TbRedirectsSchema: TObject< {
success: TOptional<TString>;
error: TOptional<TString>;
}>;
export declare const TbRequestCode: TEnum<typeof RequestCode>;
export declare const TbSdkType: TEnum<typeof SdkType>;
export declare const TbSensorCaptureIntervals: TObject< {
intervalLog: TNumber;
intervalSend: TNumber;
}>;
export declare const TbSettingsSchema: TObject< {
linked: TOptional<TBoolean>;
accountId: TString;
acquisitionReference: TString;
analyticsEnabled: TBoolean;
brandingEnabled: TBoolean;
consents: TArray<TObject< {
id: TString;
privacyPolicyUrl: TOptional<TString>;
displayType: TEnum<ConsentDisplayType_2>;
text: TString;
alternativeTexts: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
}>>;
countryForIp: TString;
credentials: TArray<TUnion<[TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Id>;
country: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<IdTypeUpload_2>>;
}>>;
requiredParts: TArray<TEnum<IdSide_2>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Facemap>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<FacemapVerificationMethod_2>>;
}>;
requiredParts: TOptional<TArray<TString>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Document>;
country: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>;
deviceRiskVendors: TArray<TString>;
requiredParts: TArray<TString>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Data>;
deviceRiskVendors: TArray<TString>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>>;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
requiredParts: TArray<TString>;
}>]>]>>;
deviceRiskTokenData: TArray<TObject< {
token: TString;
sdkType: TEnum<SdkType_2>;
}>>;
dvFileUploadEnabled: TOptional<TBoolean>;
maxFileUploadSize: TNumber;
merchantSettings: TOptional<TObject< {
autoCapture: TOptional<TObject< {
idEnabled: TOptional<TBoolean>;
docVEnabled: TOptional<TBoolean>;
}>>;
branding: TOptional<TObject< {
primaryColor: TOptional<TString>;
accentColor: TOptional<TString>;
logoUri: TOptional<TString>;
}>>;
crossDevice: TOptional<TObject< {
crossDeviceOption: TOptional<TEnum<CrossDeviceOption_2>>;
enabled: TBoolean;
link: TOptional<TString>;
}>>;
crossDeviceOnly: TOptional<TBoolean>;
datadog: TOptional<TObject< {
enabled: TBoolean;
merchantName: TString;
}>>;
isExplicitUploadEnabled: TOptional<TBoolean>;
isFileUploadEnabled: TOptional<TBoolean>;
jLiveEnabled: TOptional<TBoolean>;
jLiveFallbackPolicy: TEnum<JLiveFallbackPolicy_2>;
skipLivenessGuidancePage: TOptional<TBoolean>;
}>>;
networkThrottlingLimit: TOptional<TNumber>;
redirects: TOptional<TObject< {
success: TOptional<TString>;
error: TOptional<TString>;
}>>;
returnImages: TOptional<TBoolean>;
skipDocTypeSelection: TOptional<TBoolean>;
stateForIp: TString;
supportedCountries: TArray<TObject< {
country: TEnum<CountryCode_2>;
idTypes: TArray<TObject< {
idType: TEnum<IdTypeUpload_2>;
variants: TArray<TObject< {
variant: TEnum<DocumentVariant_2>;
format: TOptional<TEnum<IdFormat_2>>;
parts: TArray<TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>>;
}>>;
digitalIdentity: TOptional<TObject< {
title: TString;
type: TEnum<DigitalIdentityType_2>;
requestedIdType: TEnum<IdTypeUpload_2>;
file: TOptional<TString>;
}>>;
}>>;
}>>;
supportedDocumentTypes: TArray<TObject< {
code: TString;
name: TString;
maxPages: TNumber;
translations: TOptional<TRecord<TString, TString>>;
}>>;
timestamp: TString;
workflowDefinitionKey: TNumber;
iproovTokenData: TOptional<TObject< {
token: TString;
url: TString;
productType: TUnion<[TLiteral<"IPROOV_PREMIUM">, TLiteral<"IPROOV_STANDARD">]>;
remainingAttempts: TNumber;
}>>;
skipStartScreen: TOptional<TBoolean>;
eidasUrl: TOptional<TString>;
configurations: TObject< {
focusScore: TOptional<TString>;
cvAnalytics: TOptional<TString>;
networkTimeouts: TOptional<TObject< {
upload: TNumber;
usability: TNumber;
finalize: TNumber;
extractdata: TNumber;
analytics: TNumber;
reporting: TNumber;
iproovtoken: TNumber;
iproovvalidate: TNumber;
cdn: TNumber;
}>>;
cdnEnc: TOptional<TArray<TObject< {
name: TString;
file: TString;
key: TString;
iv: TString;
}>>>;
shakeDetection: TOptional<TString>;
instantFeedback: TOptional<TString>;
docFinder: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
}>>;
consentURL: TOptional<TString>;
iproovMaxAttempts: TOptional<TString>;
skipConfirm: TOptional<TString>;
consentRequired: TOptional<TString>;
cvMrzThreshold: TOptional<TString>;
cdnPublicKey: TOptional<TString>;
maxRetries: TOptional<TString>;
iproovEnabled: TOptional<TString>;
maxPollingTime: TOptional<TString>;
barcodeScannerKey: TOptional<TString>;
dataPrivacyUrl: TOptional<TString>;
dataDog: TOptional<TObject< {
appId: TString;
clientId: TString;
}>>;
shakeScore: TOptional<TString>;
sardineClientId: TOptional<TString>;
fileUpload: TOptional<TObject< {
fallbackTimeInMs: TNumber;
isFallbackUploadEnabled: TBoolean;
}>>;
jumioLiveness: TOptional<TObject< {
frameRateThreshold: TNumber;
samplingTimeInMs: TNumber;
violationLimit: TNumber;
modelInitTimeoutInMs: TNumber;
retries: TNumber;
minNearFarRatio: TNumber;
maxFaceCenterDifference: TNumber;
tooFarThreshold: TNumber;
tooNearThreshold: TNumber;
initialImages: TNumber;
transitionImages: TNumber;
nearImages: TNumber;
farImages: TNumber;
minTimePerDistanceInMs: TNumber;
maxConsecutiveImageTimespanInMs: TNumber;
imageResolutionWidth: TNumber;
imageResolutionHeight: TNumber;
imageCompression: TNumber;
fallbackTimeInMs: TNumber;
userFallbackAllowed: TBoolean;
minimumPseudoPitch: TNumber;
maximumPseudoPitch: TNumber;
minimumPseudoYaw: TNumber;
maximumPseudoYaw: TNumber;
}>>;
idAutocapture: TOptional<TObject< {
fallbackTimeInMs: TOptional<TNumber>;
excludeDevices: TOptional<TArray<TString>>;
focusTimeInMs: TOptional<TNumber>;
}>>;
helpScreen: TOptional<TObject< {
ID: TNumber;
FACEMAP: TNumber;
DOCUMENT: TNumber;
DATA: TNumber;
}>>;
cameraData: TOptional<TObject< {
cameraTimeoutMs: TOptional<TNumber>;
resolutionId: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionFacemap: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
resolutionDocument: TOptional<TObject< {
width: TNumber;
height: TNumber;
aspectRatio: TNumber;
}>>;
}>>;
sensorData: TOptional<TObject< {
intervalLog: TNumber;
intervalSend: TNumber;
}>>;
supplementalImagesV2: TOptional<TUnion<[TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>, TArray<TObject< {
images: TArray<TObject< {
captureFrequency: TNumber;
classifier: TUnion<[TLiteral<"ID_SEQUENCE">, TLiteral<"SELFIE_SEQUENCE">]>;
maxBatch: TNumber;
maxQueueSizeBytes: TNumber;
minBufferAge: TNumber;
neededByDefault: TOptional<TBoolean>;
resolutions: TArray<TNumber>;
}>>;
}>>]>>;
}>;
}>;
export declare const TbSettingsWithoutConfigurationsSchema: TObject< {
linked: TOptional<TBoolean>;
accountId: TString;
acquisitionReference: TString;
analyticsEnabled: TBoolean;
brandingEnabled: TBoolean;
consents: TArray<TObject< {
id: TString;
privacyPolicyUrl: TOptional<TString>;
displayType: TEnum<ConsentDisplayType_2>;
text: TString;
alternativeTexts: TObject< {
ar: TOptional<TString>;
bg: TOptional<TString>;
cs: TOptional<TString>;
da: TOptional<TString>;
de: TOptional<TString>;
el: TOptional<TString>;
en: TOptional<TString>;
en_GB: TOptional<TString>;
"en-GB": TOptional<TString>;
en_US: TOptional<TString>;
"en-US": TOptional<TString>;
es: TOptional<TString>;
es_MX: TOptional<TString>;
"es-MX": TOptional<TString>;
et: TOptional<TString>;
fi: TOptional<TString>;
fr: TOptional<TString>;
he: TOptional<TString>;
hr: TOptional<TString>;
hu: TOptional<TString>;
hy: TOptional<TString>;
id: TOptional<TString>;
it: TOptional<TString>;
ja: TOptional<TString>;
ka_GE: TOptional<TString>;
"ka-GE": TOptional<TString>;
km: TOptional<TString>;
km_KH: TOptional<TString>;
"km-KH": TOptional<TString>;
ko: TOptional<TString>;
lt: TOptional<TString>;
ms: TOptional<TString>;
nl: TOptional<TString>;
no: TOptional<TString>;
pl: TOptional<TString>;
pt: TOptional<TString>;
pt_BR: TOptional<TString>;
"pt-BR": TOptional<TString>;
ro: TOptional<TString>;
ru: TOptional<TString>;
sk: TOptional<TString>;
sr_Cyrl: TOptional<TString>;
"sr-Cyrl": TOptional<TString>;
sr: TOptional<TString>;
sr_Latn: TOptional<TString>;
"sr-Latn": TOptional<TString>;
sv: TOptional<TString>;
sw: TOptional<TString>;
th: TOptional<TString>;
tr: TOptional<TString>;
uk: TOptional<TString>;
vi: TOptional<TString>;
zh: TOptional<TString>;
zh_CN: TOptional<TString>;
"zh-CN": TOptional<TString>;
zh_HK: TOptional<TString>;
"zh-HK": TOptional<TString>;
}>;
}>>;
countryForIp: TString;
credentials: TArray<TUnion<[TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Id>;
country: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<IdTypeUpload_2>>;
}>>;
requiredParts: TArray<TEnum<IdSide_2>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Facemap>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<FacemapVerificationMethod_2>>;
}>;
requiredParts: TOptional<TArray<TString>>;
deviceRiskVendors: TOptional<TArray<TString>>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Document>;
country: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TEnum<CountryCode_2>>;
}>;
type: TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>;
deviceRiskVendors: TArray<TString>;
requiredParts: TArray<TString>;
}>]>, TIntersect<[TObject< {
id: TString;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
}>, TObject< {
category: TLiteral<Category_2.Data>;
deviceRiskVendors: TArray<TString>;
type: TOptional<TObject< {
predefinedType: TEnum<PredefinedType_2>;
values: TArray<TString>;
}>>;
capabilities: TArray<TObject< {
id: TString;
name: TString;
}>>;
requiredParts: TArray<TString>;
}>]>]>>;
deviceRiskTokenData: TArray<TObject< {
token: TString;
sdkType: TEnum<SdkType_2>;
}>>;
dvFileUploadEnabled: TOptional<TBoolean>;
maxFileUploadSize: TNumber;
merchantSettings: TOptional<TObject< {
autoCapture: TOptional<TObject< {
idEnabled: TOptional<TBoolean>;
docVEnabled: TOptional<TBoolean>;
}>>;
branding: TOptional<TObject< {
primaryColor: TOptional<TString>;
accentColor: TOptional<TString>;
logoUri: TOptional<TString>;
}>>;
crossDevice: TOptional<TObject< {
crossDeviceOption: TOptional<TEnum<CrossDeviceOption_2>>;
enabled: TBoolean;
link: TOptional<TString>;
}>>;
crossDeviceOnly: TOptional<TBoolean>;
datadog: TOptional<TObject< {
enabled: TBoolean;
merchantName: TString;
}>>;
isExplicitUploadEnabled: TOptional<TBoolean>;
isFileUploadEnabled: TOptional<TBoolean>;
jLiveEnabled: TOptional<TBoolean>;
jLiveFallbackPolicy: TEnum<JLiveFallbackPolicy_2>;
skipLivenessGuidancePage: TOptional<TBoolean>;
}>>;
networkThrottlingLimit: TOptional<TNumber>;
redirects: TOptional<TObject< {
success: TOptional<TString>;
error: TOptional<TString>;
}>>;
returnImages: TOptional<TBoolean>;
skipDocTypeSelection: TOptional<TBoolean>;
stateForIp: TString;
supportedCountries: TArray<TObject< {
country: TEnum<CountryCode_2>;
idTypes: TArray<TObject< {
idType: TEnum<IdTypeUpload_2>;
variants: TArray<TObject< {
variant: TEnum<DocumentVariant_2>;
format: TOptional<TEnum<IdFormat_2>>;
parts: TArray<TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>>;
}>>;
digitalIdentity: TOptional<TObject< {
title: TString;
type: TEnum<DigitalIdentityType_2>;
requestedIdType: TEnum<IdTypeUpload_2>;
file: TOptional<TString>;
}>>;
}>>;
}>>;
supportedDocumentTypes: TArray<TObject< {
code: TString;
name: TString;
maxPages: TNumber;
translations: TOptional<TRecord<TString, TString>>;
}>>;
timestamp: TString;
workflowDefinitionKey: TNumber;
iproovTokenData: TOptional<TObject< {
token: TString;
url: TString;
productType: TUnion<[TLiteral<"IPROOV_PREMIUM">, TLiteral<"IPROOV_STANDARD">]>;
remainingAttempts: TNumber;
}>>;
skipStartScreen: TOptional<TBoolean>;
eidasUrl: TOptional<TString>;
}>;
export declare const TbSupportedCountrySchema: TObject< {
country: TEnum<typeof CountryCode>;
idTypes: TArray<TObject< {
idType: TEnum<typeof IdTypeUpload>;
variants: TArray<TObject< {
variant: TEnum<typeof DocumentVariant>;
format: TOptional<TEnum<typeof IdFormat>>;
parts: TArray<TObject< {
side: TEnum<IdSide_2>;
masking: TBoolean;
extraction: TArray<TUnion<[TString, TNull]>>;
}>>;
}>>;
digitalIdentity: TOptional<TObject< {
title: TString;
type: TEnum<DigitalIdentityType_2>;
requestedIdType: TEnum<typeof IdTypeUpload>;
file: TOptional<TString>;
}>>;
}>>;
}>;
export declare const TbSupportedDocumentTypeSchema: TObject< {
code: TString;
name: TString;
maxPages: TNumber;
translations: TOptional<TRecord<TString, TString>>;
}>;
export declare const TbThirdPartyOcr: TEnum<typeof ThirdPartyOcr>;
export declare const TbUploadType: TEnum<typeof UploadType>;
export declare const TbUUIDSchema: TString;
export declare const TbVideoErrorSchema: TObject< {
name: TString;
message: TString;
}>;
export declare const TbVirtualStep: TEnum<typeof VirtualStep>;
export declare type Teardown = () => void;
export declare enum ThirdPartyOcr {
Cssn = "CSSN",
Wintone = "WINTONE"
}
export declare type ThirdPartyOcrType = Static<typeof TbThirdPartyOcr>;
export declare class ThumbnailDeletedEvent extends CustomEvent<number> {
constructor(params: number);
}
export declare class ThumbnailSelectedEvent extends CustomEvent<number> {
constructor(params: number);
}
declare interface TimestampLike {
timestamp: string;
}
export declare const toggleCaptureHintsVisibility: () => void;
export declare interface Token<TExpiration = Date> extends Record<string, unknown> {
exAt: TExpiration;
accId: UUID;
aId: UUID;
wfeId: UUID;
cRef: string;
cId: UUID;
}
export declare interface TokenManager {
readonly token$: Observable<TokenState>;
setToken(token: string): void;
getToken(): TokenState;
}
export declare interface TokenManagerController {
getToken(): Promise<TokenState>;
getToken$(): Observable<TokenState>;
setToken(token: string): void;
}
export declare interface TokenState<TExpiration = Date> {
parsedToken?: Token<TExpiration>;
token: string;
transactionId: UUID;
tokenExpired: boolean;
}
export declare class TopMessageContainerComponent extends BaseComponent {
static styles: CSSResult[];
render(): TemplateResult_2<1>;
}
export declare const transactionFinished: ErrorCase;
export declare const transformMediaDeviceInfo: (device: MediaDeviceInfo) => JMediaDeviceInfo;
export declare interface Transport {
getSettings$(params: SettingsRequest): Observable<unknown>;
sendAnalyticsEvent$(params: SendEventRequest): Observable<object>;
sendReportingEvent$(params: SendEventRequest): Observable<object>;
finalize$(): Observable<FinalizeResponse>;
getIproovToken$(reason: string): Observable<IproovTokenData | undefined>;
validateIproovToken$(params: ValidateIproovTokenRequest): Observable<ValidateIproovTokenResponse>;
checkUsability$(params: CheckUsabilityParams): Observable<UsabilityResult>;
checkEidas$(): Observable<EidasResult>;
extractData$(): Observable<ExtractedDataResponse>;
uploadData$(params: UploadDataParams): Observable<UploadResponse>;
getAcquisitionStatus$(): Observable<AcquisitionStatusResponse>;
sendCrossDeviceEmail$(emailRequest: EmailRequest): Observable<EmailResponse>;
getFilePart$(params: GetFilePartParams): Observable<FilePartResponse>;
updateMetadata$(acquisitionId: UUID, credentialId: UUID, params: UpdateMetadataParams): Observable<object>;
eidasUrl$(locale: Locale): Observable<EIDASUrlResponse>;
}
export declare interface TransportController {
getSettings(params: SettingsRequest): Promise<unknown>;
sendAnalyticsEvent(params: SendEventRequest): Promise<object>;
sendReportingEvent(params: SendEventRequest): Promise<object>;
finalize(): Promise<FinalizeResponse>;
getIproovToken(reason: string): Promise<IproovTokenData | undefined>;
validateIproovToken(params: ValidateIproovTokenRequest): Promise<ValidateIproovTokenResponse>;
checkUsability(params: CheckUsabilityParams): Promise<UsabilityResult>;
extractData(): Promise<ExtractedDataResponse>;
uploadData(params: UploadDataParams): Promise<UploadResponse>;
getAcquisitionStatus(): Promise<AcquisitionStatusResponse>;
}
export declare const uncaughtErrorEvent: EventDispatcher_2< {
name: string;
message: string;
stack?: string;
}>;
export declare const unhandledrejectionEvent: EventDispatcher_2< {
name: string;
message: string;
stack?: string;
}>;
export declare const unlockOrientation: () => void;
declare type UnwrapObservable<T> = T extends Observable<infer R> ? R : never;
export declare const updateConsent: (item: ConsentData) => void;
export declare const updateDeviceList$: () => Observable<JMediaDeviceInfo[]>;
export declare const updateFrontFileStoreIds: (newId: FileStoreKey) => void;
export declare interface UpdateMetadataParams {
countrySelection?: string;
credentialFileGuidSelection?: string[];
typeSelection?: string;
}
export declare const updateSettings: (partialSettings: Partial<Settings>) => void;
export declare interface UpdateStateParams {
data: BackupEntryDescriptor;
unused?: string;
url: URL | string | null;
}
export declare const updateWorkflowState: (params: Partial<WorkflowState>) => void;
export declare interface UploadDataParams {
credentialUUID: UUID;
params: UploadRequest;
}
export declare const uploadedFile: EventDispatcher_2< {
source: FileSource;
}>;
export declare class UploadErrorMessageComponent extends BaseComponent {
static styles: CSSResult[];
message: string;
render(): TemplateResult<1>;
}
declare enum UploadEvents {
FilesUploadedRaw = "filesuploadedraw",
FilesUploaded = "filesuploaded"
}
export declare interface UploadRequest {
consents?: MultipartConsent[];
data?: MultipartData;
deviceRisks?: DeviceRisk[];
uploadFilesMetadata?: MultipartFiles;
}
export declare class UploadRequestEvent extends CustomEvent<UploadRequestWithCaptureType> {
constructor(request: UploadRequestWithCaptureType);
}
export declare interface UploadRequestWithCaptureType extends UploadRequest {
captureType: LivenessCaptureTypes;
}
export declare interface UploadResponse {
usabilityResultKeys: FileStoreRecord;
documentResult?: DocumentResultResponse;
}
export declare type UploadState<TFile = Blob> = UploadStateError<TFile> | UploadStateNotStarted | UploadStateSuccess<TFile> | UploadStateUploading<TFile>;
export declare interface UploadStateBase<T extends UploadStatus> {
id: FileStoreKey;
state: T;
source?: FileSource;
}
export declare type UploadStateError<TFile> = UploadStateBase<UploadStatus.Error> & {
blob: TFile;
error: unknown;
};
export declare type UploadStateNotStarted = UploadStateBase<UploadStatus.NotStarted>;
export declare type UploadStateSuccess<TFile> = UploadStateBase<UploadStatus.Success> & {
blob: TFile;
usabilityId: string;
filename?: string;
};
export declare type UploadStateUploading<TFile> = UploadStateBase<UploadStatus.Progress> & {
blob: TFile;
};
export declare enum UploadStatus {
NotStarted = "not-started",
Progress = "progress",
Error = "error",
Success = "success"
}
export declare enum UploadType {
Document = "DOCUMENT",
FrontSide = "FRONTSIDE",
BackSide = "BACKSIDE",
Face = "FACE",
Iproov = "IPROOV",
Video = "VIDEO",
Screenshot = "SCREENSHOT",
MrzImage = "MRZ_IMAGE"
}
export declare type UploadTypeJumioLiveness = 'JUMIO_LIVENESS_BLOB' | `JUMIO_LIVENESS_${number}`;
export declare type UploadTypeLivenessSeries = `LIVENESS_SERIES_${number}`;
export declare type UploadTypeSupplementalImageId = `ID_SEQUENCE_${UploadType.BackSide | UploadType.FrontSide}_${number}`;
export declare type UploadTypeSupplementalImageSelfie = `SELFIE_SEQUENCE_${number}`;
export declare type UploadTypeType = Static<typeof TbUploadType>;
export declare class UploadUpdateEvent extends CustomEvent<File> {
constructor(params: File);
}
export declare const upsertFileUpload: (data: UploadState) => void;
export declare const upsertUsabilityCheck: (data: UsabilityCheckState) => void;
export declare class UsabilityCheckComponent extends BaseComponent {
static styles: CSSResult[];
itemElements: HTMLElement[];
buttonElements: HTMLElement[];
render(): TemplateResult<1>;
}
export declare type UsabilityCheckState<TUsabilityCheckStatus extends UsabilityCheckStatus = UsabilityCheckStatus, TDecisionType extends DecisionType = DecisionType> = UsabilityCheckStateMap<TDecisionType>[TUsabilityCheckStatus];
export declare interface UsabilityCheckStateBase<T> {
id: FileStoreKey;
state: T;
usabilityId: string;
}
export declare type UsabilityCheckStateError = UsabilityCheckStateBase<UsabilityCheckStatus.Error> & {
error: unknown;
};
declare interface UsabilityCheckStateMap<TDecisionType extends DecisionType = DecisionType> {
[UsabilityCheckStatus.NotStarted]: UsabilityCheckStateNotStarted;
[UsabilityCheckStatus.Progress]: UsabilityCheckStateProgress;
[UsabilityCheckStatus.Error]: UsabilityCheckStateError;
[UsabilityCheckStatus.Success]: UsabilityCheckStateSuccess<TDecisionType>;
}
export declare type UsabilityCheckStateNotStarted = UsabilityCheckStateBase<UsabilityCheckStatus.NotStarted>;
export declare type UsabilityCheckStateProgress = UsabilityCheckStateBase<UsabilityCheckStatus.Progress>;
export declare type UsabilityCheckStateSuccess<TResult extends DecisionType = DecisionType> = UsabilityCheckStateBase<UsabilityCheckStatus.Success> & {
result: UsabilityResult<TResult>;
};
export declare enum UsabilityCheckStatus {
NotStarted = "not-started",
Progress = "progress",
Success = "success",
Error = "error"
}
export declare interface UsabilityNotAvailableResult {
decisionType: DecisionType.NOT_AVAILABLE;
}
export declare interface UsabilityPassResult {
decisionType: DecisionType.PASS;
extractedData?: ExtractedData;
classifier: UploadType;
}
export declare interface UsabilityRejectResult {
decisionType: DecisionType.REJECT;
rejectReason: RejectReason;
}
export declare type UsabilityResult<T extends DecisionType = DecisionType> = UsabilityResultMap[T];
export declare interface UsabilityResultMap {
[DecisionType.PASS]: UsabilityPassResult;
[DecisionType.REJECT]: UsabilityRejectResult;
[DecisionType.NOT_AVAILABLE]: UsabilityNotAvailableResult;
}
export declare interface UsAddress {
streetSuffix?: string;
streetDirection?: string;
unitDesignator?: string;
unitNumber?: string;
city?: string;
state?: string;
zip?: string;
zipExtension?: string;
streetNumber?: string;
streetName?: string;
}
export declare interface UsedCaptureTypes {
livenessCaptureType?: LivenessCaptureTypes;
idCaptureType?: IdCaptureTypes;
usedAllCaptureTypes: (IdCaptureTypes | LivenessCaptureTypes)[];
}
export declare const usedCaptureTypesEvent: EventDispatcher_2< {
livenessCaptureType?: LivenessCaptureTypes;
idCaptureType?: IdCaptureTypes;
xDeviceJourney: boolean;
usedAllCaptureTypes: (IdCaptureTypes | LivenessCaptureTypes)[];
}>;
export declare type UUID = Static<typeof TbUUIDSchema>;
declare enum UXCameraCommand {
LockExposureAndWhiteBalance = "lock_exposure_and_white_balance",
UnlockExposureAndWhiteBalance = "unlock_exposure_and_white_balance"
}
declare enum UXDisplayMessage {
FaceHoldStill = "face_hold_still",
FaceHoldStillInitial = "face_hold_still_initial",
FaceKeepCenterSevere = "face_keep_center_severe",
FaceMoveAway = "face_move_away",
FaceMoveCloser = "face_move_closer",
FaceNoneDetected = "face_none_detected",
FaceNotUpright = "face_not_upright",
FaceStopMovement = "face_stop_movement",
FaceTiltDown = "face_tilt_down",
FaceTiltLeft = "face_tilt_left",
FaceTiltRight = "face_tilt_right",
FaceTiltUp = "face_tilt_up",
Finish = "finish",
KeepFaceCenter = "face_keep_center",
MoreCapturesNeeded = "more_captures_needed",
Start = "start"
}
declare enum UXUICommand {
HintMoveAway = "hint_move_away",
HintMoveCloser = "hint_move_closer"
}
export declare interface ValidateIproovTokenRequest {
token: string;
}
export declare interface ValidateIproovTokenResponse {
passed: boolean;
failureReason?: string;
}
export declare type VideoError = Static<typeof TbVideoErrorSchema>;
export declare interface VideoLoadingParams {
videoElement: HTMLVideoElement;
cancelNotifier$: Observable<void>;
timeoutMs?: number;
}
export declare const videoPlayThrows: EventDispatcher_2< {
name: string;
message: string;
stack?: string;
state: unknown;
}>;
export declare interface VideoSizeInfo {
streamWidth: number;
streamHeight: number;
streamAspectRatio: number;
elementWidth: number;
elementHeight: number;
elementAspectRatio: number;
}
export declare type VideoSource = VideoSourceCamera | VideoSourceFile;
export declare interface VideoSourceCamera {
type: VideoSourceType.Camera;
deviceId: string;
source: MediaStream;
track: MediaStreamVideoTrack;
}
export declare interface VideoSourceFile {
type: VideoSourceType.File;
device: JMediaDeviceInfo;
deviceId: string;
track: ActiveTrackState;
url: string;
}
export declare enum VideoSourceType {
Camera = "camera",
File = "file"
}
export declare type VideoTickCallback = (params: VideoTickCallbackParams) => Promise<void>;
export declare interface VideoTickCallbackParams {
videoElement: HTMLVideoElement;
isFirstFrame: boolean;
performanceNow: DOMHighResTimeStamp;
dateNowHighResolution: number;
dateNow: number;
frameId: number;
fps?: number;
}
export declare enum VirtualStep {
Setup = "setup",
Start = "start",
Finish = "finish"
}
export declare type VirtualStepType = Static<typeof TbVirtualStep>;
export declare class WatermarkComponent extends BaseComponent {
#private;
static styles: CSSResult[];
poweredBy: string;
version: string;
poweredByVisible: boolean;
render(): TemplateResult<1>;
}
export declare const withMetadata: <M extends EventMetadata = EventMetadata>() => M;
declare interface WorkerAvailability {
acceptableEvents: string[];
isReady: boolean;
}
export declare interface Workflow {
extractData$(): Observable<ExtractedDataResponse>;
finalize$(): Observable<FinalizeResponse>;
checkAcquisitionStatus$(): Observable<AcquisitionStatusResponse>;
checkAcquisitionStatusPolling$(interval?: number): Observable<AcquisitionStatusResponse>;
goToPreviousStep(): void;
goToNextStep(): void;
getStepById<T extends Category | VirtualStep>(category: T, credentialId?: UUID): WorkflowStep<T>;
getWorkflowState(): WorkflowState;
setWorkflowState(params: Partial<WorkflowState>): void;
}
export declare interface WorkflowConfiguration {
readonly credentials$: Observable<JCredential[]>;
readonly settings$: Observable<Settings>;
getSettings(): Settings;
fetchSettings$(requestParams: SettingsRequest): Observable<Settings>;
}
export declare interface WorkflowConfigurationController {
getSettings(): Settings;
selectSettings$(): Observable<Settings>;
selectSettings(): Promise<Settings>;
fetchSettings$(requestParams?: SettingsRequest): Observable<Settings>;
fetchSettingsAsync(requestParams?: SettingsRequest): Promise<Settings>;
}
export declare interface WorkflowConsent {
sendConsentData$(): Observable<UploadResponse>;
updateConsentStatus(consentData: ConsentData): void;
areAllActiveConsentsGiven$(): Observable<boolean>;
isConsentGivenSent$(): Observable<boolean>;
selectAllConsents$(): Observable<ConsentItem[]>;
}
export declare interface WorkflowConsentController {
sendConsentData(): Promise<UploadResponse>;
sendConsentData$(): Observable<UploadResponse>;
selectAllConsents$(): Observable<ConsentItem[]>;
selectAllConsents(): Promise<ConsentItem[]>;
updateConsentStatus(consentData: ConsentData): void;
areAllActiveConsentsGiven$(): Observable<boolean>;
isConsentGivenSent$(): Observable<boolean>;
isConsentGivenSent(): Promise<boolean>;
areAllActiveConsentsGiven(): Promise<boolean>;
}
export declare interface WorkflowController {
getConsentController(): WorkflowConsentController;
getEmailController(): WorkflowEmailController;
getEidasController(): WorkflowEidasController;
getConfiguration(): WorkflowConfigurationController;
selectStepChange$(): Observable<StepChangeParams>;
onStepChange(callback: StepChangeCallback): Teardown;
getControllerById<T extends Category | VirtualStep>(category: T, credentialId?: UUID): WorkflowStepController<T>;
extractData$(): Observable<ExtractedDataResponse>;
extractDataAsync(): Promise<ExtractedDataResponse>;
finalize$(): Observable<FinalizeResponse>;
finalizeAsync(): Promise<FinalizeResponse>;
checkAcquisitionStatus$(): Observable<AcquisitionStatusResponse>;
checkAcquisitionStatusAsync(): Promise<AcquisitionStatusResponse>;
checkAcquisitionStatusPolling$(interval?: number): Observable<AcquisitionStatusResponse>;
goToPreviousStep(): void;
goToNextStep(): void;
getWorkflowState(): WorkflowState;
setWorkflowState(params: Partial<WorkflowState>): void;
getLoggerManager(): LoggerManager;
getTokenManager(): TokenManagerController;
getTransport(): TransportController;
}
export declare interface WorkflowEidas {
getUrl$(locale: Locale): Observable<EIDASUrlResponse>;
checkEidas$(): Observable<EidasResult>;
}
export declare interface WorkflowEidasController {
getEidasUrl$(locale: Locale): Observable<EIDASUrlResponse>;
getEidasUrlAsync(locale: Locale): Promise<EIDASUrlResponse>;
checkEidas$(): Observable<EidasResult>;
checkEidasAsync(): Promise<EidasResult>;
}
export declare interface WorkflowEmail {
sendEmail$(emailRequest: EmailRequest): Observable<EmailResponse>;
}
export declare interface WorkflowEmailController {
sendEmail$(emailRequest: EmailRequest): Observable<EmailResponse>;
sendEmailAsync(emailRequest: EmailRequest): Promise<EmailResponse>;
}
export declare type WorkflowEventBody<T extends WorkflowEventType> = WorkflowEventMetadata & {
type: T;
};
export declare interface WorkflowEventMetadata {
locale?: Locale;
accountId?: string;
workflowId?: string;
workflowExecutionId?: string;
}
export declare type WorkflowEventType = 'workflow:failed' | 'workflow:retry' | 'workflow:start' | 'workflow:success';
export declare type WorkflowFailedCustomEvent = ReturnType<typeof createWorkflowFailedEvent>;
export declare class WorkflowInitiateEvent extends CustomEvent<WorkflowInitiateEventParams> {
constructor(detail: WorkflowInitiateEventParams);
}
export declare type WorkflowInitiateEventParams = Pick<WorkflowState, 'baseUrl' | 'linked' | 'locale' | 'sessionUrl' | 'token'>;
export declare const workflowRestarted: EventDispatcher_2<EventMetadata_2>;
export declare type WorkflowRetryCustomEvent = ReturnType<typeof createWorkflowRetryEvent>;
declare interface WorkflowSetupParameters {
sessionUrl: string;
baseUrl: string;
token: string;
locale: Locale;
finalized: boolean;
consentGivenSent: boolean;
linked: boolean;
acquisitionStatus: AcquisitionStatus;
acquisitionPolling: boolean;
visitedScreens: string[];
}
export declare type WorkflowSetupParametersMandatory = Pick<WorkflowState, 'baseUrl' | 'locale' | 'token' | 'transactionId'>;
export declare type WorkflowStartCustomEvent = ReturnType<typeof createWorkflowStartEvent>;
export declare type WorkflowState<TExpiration = Date> = NavigationStep & TokenState<TExpiration> & WorkflowSetupParameters;
export declare type WorkflowStep<T extends CredentialStep = CredentialStep> = WorkflowStepMap[T];
export declare interface WorkflowStepBaseController<TCategoryType extends CredentialStep> {
readonly category: TCategoryType;
}
export declare interface WorkflowStepBaseLogic<TCategoryType extends Category> {
readonly category: TCategoryType;
}
export declare type WorkflowStepController<T extends CredentialStep> = WorkflowStepControllerMap[T];
export declare interface WorkflowStepControllerMap {
[VirtualStep.Setup]: WorkflowStepSetupController;
[VirtualStep.Start]: WorkflowStepStartController;
[Category.Id]: WorkflowStepIdController;
[Category.Facemap]: WorkflowStepFacemapController;
[Category.Document]: WorkflowStepDocumentController;
[Category.Data]: WorkflowStepDataController;
[VirtualStep.Finish]: WorkflowStepFinishController;
}
declare interface WorkflowStepControllerProvider<TWorkflowStepController> {
readonly workflowStepController: TWorkflowStepController;
}
export declare interface WorkflowStepCredentialController<TCategoryType extends Category> extends WorkflowStepBaseController<TCategoryType> {
getCredential(): JCredential<TCategoryType>;
selectCredential$(): Observable<JCredential<TCategoryType>>;
getCredentialAsync(): Promise<JCredential<TCategoryType>>;
checkUsability$(params: CheckUsabilityParamsWithId): Observable<UsabilityResult>;
checkUsabilityAsync(params: CheckUsabilityParamsWithId): Promise<UsabilityResult>;
uploadData$(params: UploadRequest): Observable<UploadResponse>;
uploadDataAsync(params: UploadRequest): Promise<UploadResponse>;
}
export declare interface WorkflowStepCredentialLogic<TCategoryType extends Category> extends WorkflowStepBaseLogic<TCategoryType> {
getCredential(): JCredential<TCategoryType>;
selectCredential$(): Observable<JCredential<TCategoryType>>;
checkUsability$(params: CheckUsabilityParamsWithId): Observable<UsabilityResult>;
uploadData$(params: UploadRequest): Observable<UploadResponse>;
}
export declare interface WorkflowStepData extends WorkflowStepCredentialLogic<Category.Data> {
isIovation(): boolean;
}
export declare interface WorkflowStepDataController extends WorkflowStepCredentialController<Category.Data> {
isIovation(): boolean;
}
export declare interface WorkflowStepDocument extends WorkflowStepCredentialLogic<Category.Document> {
getFilePart(partId: string): Promise<FilePartResponse>;
removeOldPdfPages(): void;
selectMaxFileUploadSize$(): Observable<number>;
selectPdfPages$(): Observable<FilePartState[]>;
softDeletePdfPage(id: string): void;
updateMetadataWithPageSelection$(): Observable<object>;
}
export declare interface WorkflowStepDocumentController extends WorkflowStepCredentialController<Category.Document> {
isUploadingFiles$(): Observable<boolean>;
removeOldPdfPages(): void;
selectDocument$(): Observable<SupportedDocumentType | undefined>;
selectMaxFileUploadSize$(): Observable<number>;
selectPdfPages$(): Observable<FilePartState[]>;
selectUploadedPdfFile$(): Observable<Blob | undefined>;
softDeletePdfPage(id: string): void;
updateMetadataWithPageSelection$(): Observable<object>;
}
export declare interface WorkflowStepFacemap extends WorkflowStepCredentialLogic<Category.Facemap> {
selectIproovTokenState$(): Observable<IproovTokenState>;
fetchIproovToken$(): Observable<IproovTokenState>;
getIproovTokenState(): IproovTokenState;
patchIproovTokenState(tokenData: Partial<IproovTokenState>): void;
validateIproovToken$(params: ValidateIproovTokenRequest): Observable<ValidateIproovTokenResponse>;
selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason | undefined): void;
selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
resetJLiveFallbackError(): void;
setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
selectLivenessState$: () => Observable<CredentialFacemapState & LivenessState>;
setLivenessVisibleFaceFinder: (oval: LivenessRefDistance) => void;
selectLivenessVisibleFaceFinder$: () => Observable<LivenessRefDistance>;
selectLivenessAttempt$: () => Observable<number>;
selectLivenessFeedbackMessage$: () => Observable<UXDisplayMessage>;
selectLivenessScanning$: () => Observable<boolean>;
selectLivenessBackgroundColor$: () => Observable<string | undefined>;
setLivenessStoreToNextAttempt: () => void;
setLivenessStoreProgress: (progress: string) => void;
setLivenessStorePhotinusColor: (photinusColor: string | undefined) => void;
setLivenessStoreDisplayMessage: (displayMessage: UXDisplayMessage) => void;
setLivenessStoreCameraCommand: (cameraCommand: UXCameraCommand | undefined) => void;
setLivenessStoreUiCommand: (uiCommand: UXUICommand | undefined) => void;
selectLivenessProgress$: () => Observable<[number, number]>;
selectIproovTokenState$: () => Observable<IproovTokenState>;
getIproovTokenState: () => IproovTokenState;
patchIproovTokenState: (tokenData: Partial<IproovTokenState>) => void;
reset: () => void;
}
export declare interface WorkflowStepFacemapController extends WorkflowStepCredentialController<Category.Facemap> {
selectIproovTokenState$(): Observable<IproovTokenState>;
getIproovTokenStateAsync(): Promise<IproovTokenState>;
fetchIproovToken$(): Observable<IproovTokenState>;
fetchIproovTokenAsync(): Promise<IproovTokenState>;
getIproovTokenState(): IproovTokenState;
patchIproovTokenState(tokenData: Partial<IproovTokenState>): void;
validateIproovToken$(params: ValidateIproovTokenRequest): Observable<ValidateIproovTokenResponse>;
validateIproovTokenAsync(params: ValidateIproovTokenRequest): Promise<ValidateIproovTokenResponse>;
selectVerificationMethods$(): Observable<FacemapVerificationMethod[]>;
getVerificationMethodsAsync(): Promise<FacemapVerificationMethod[]>;
setJLiveManualCaptureFallbackReason(reason: ManualCaptureFallbackReason): void;
selectJLiveManualCaptureFallbackReason$(): Observable<ManualCaptureFallbackReason | undefined>;
selectJLiveFallbackError$(): Observable<JLiveFallbackError | undefined>;
resetJLiveFallbackError(): void;
setActiveFaceVerificationMethod: (activeVerificationMethod: FacemapVerificationMethod | undefined) => void;
getActiveFaceVerificationMethod: () => FacemapVerificationMethod | undefined;
selectActiveFaceVerificationMethod$: () => Observable<FacemapVerificationMethod | undefined>;
selectLivenessState$: () => Observable<CredentialFacemapState & LivenessState>;
setLivenessVisibleFaceFinder: (oval: LivenessRefDistance) => void;
selectLivenessVisibleFaceFinder$: () => Observable<LivenessRefDistance>;
selectLivenessAttempt$: () => Observable<number>;
selectLivenessFeedbackMessage$: () => Observable<UXDisplayMessage>;
selectLivenessScanning$: () => Observable<boolean>;
selectLivenessBackgroundColor$: () => Observable<string | undefined>;
setLivenessStoreToNextAttempt: () => void;
setLivenessStoreProgress: (progress: string) => void;
setLivenessStorePhotinusColor: (photinusColor: string | undefined) => void;
setLivenessStoreDisplayMessage: (displayMessage: UXDisplayMessage) => void;
setLivenessStoreCameraCommand: (cameraCommand: UXCameraCommand | undefined) => void;
setLivenessStoreUiCommand: (uiCommand: UXUICommand | undefined) => void;
selectLivenessProgress$: () => Observable<[number, number]>;
selectIproovTokenState$: () => Observable<IproovTokenState>;
getIproovTokenState: () => IproovTokenState;
patchIproovTokenState: (tokenData: Partial<IproovTokenState>) => void;
reset: () => void;
}
export declare interface WorkflowStepFinish {
readonly category: VirtualStep.Finish;
finalize$(): Observable<FinalizeResponse>;
}
export declare interface WorkflowStepFinishController extends WorkflowStepBaseController<VirtualStep.Finish> {
finalize$(): Observable<FinalizeResponse>;
finalizeAsync(): Promise<FinalizeResponse>;
}
export declare interface WorkflowStepId extends WorkflowStepCredentialLogic<Category.Id> {
selectIdTypesForCountry$(): Observable<IdTypeUpload[]>;
selectIdTypesForCountryWithVariants$(): Observable<IdType[]>;
selectAvailableInputSources$(): Observable<Source[]>;
selectIdTypeVariant$(): Observable<IdTypeVariant>;
selectIdTypeVariantCollection$(): Observable<IdTypeVariant[]>;
patchUserSelection(params: IdCredentialSelection): void;
getUserSelection(): IdCredentialSelection;
selectUserSelection$(): Observable<IdCredentialSelection>;
isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
are2FilesUploaded(credentialId: UUID): boolean;
selectSidesForSelectedDocument$(): Observable<IdSide[]>;
selectPartsForDocumentType$(params: IdCredentialSelection): Observable<IdTypeVariantPart[]>;
getPartsForDocumentType(params: IdCredentialSelection): IdTypeVariantPart[];
isCountryAndDocTypePredefined(): boolean;
}
export declare interface WorkflowStepIdController extends WorkflowStepCredentialController<Category.Id> {
isCountryAndDocTypePredefined(): boolean;
selectAvailableInputSources$(): Observable<Source[]>;
getAvailableInputSourcesAsync(): Promise<Source[]>;
selectIdTypesForCountryWithVariants$(): Observable<IdType[]>;
selectIdTypesForCountry$(): Observable<IdType[]>;
getIdTypesForCountryAsync(): Promise<IdType[]>;
selectIdTypeVariant$(): Observable<IdTypeVariant>;
getIdTypeVariantAsync(): Promise<IdTypeVariant>;
selectIdTypeVariantCollection$(): Observable<IdTypeVariant[]>;
getIdTypeVariantCollectionAsync(): Promise<IdTypeVariant[]>;
patchUserSelection(params: IdCredentialSelection): void;
getUserSelection(): IdCredentialSelection;
isUsabilityBackMissing(credentialId: UUID): IsUsabilityBackMissing;
are2FilesUploaded(credentialId: UUID): boolean;
selectUserSelection$(): Observable<IdCredentialSelection>;
selectSidesForSelectedDocument$(): Observable<IdSide[]>;
getSidesForSelectedDocumentAsync(): Promise<IdSide[]>;
selectPartsForDocumentType$(params: IdCredentialSelection): Observable<IdTypeVariantPart[]>;
selectPartsForDocumentTypeAsync(params: IdCredentialSelection): Promise<IdTypeVariantPart[]>;
getPartsForDocumentType(params: IdCredentialSelection): IdTypeVariantPart[];
}
export declare interface WorkflowStepMap {
[VirtualStep.Setup]: WorkflowStepSetup;
[VirtualStep.Start]: WorkflowStepStart;
[Category.Id]: WorkflowStepId;
[Category.Facemap]: WorkflowStepFacemap;
[Category.Document]: WorkflowStepDocument;
[Category.Data]: WorkflowStepData;
[VirtualStep.Finish]: WorkflowStepFinish;
}
export declare interface WorkflowStepSetup {
readonly category: VirtualStep.Setup;
}
export declare type WorkflowStepSetupController = WorkflowStepBaseController<VirtualStep.Setup>;
export declare interface WorkflowStepStart {
readonly category: VirtualStep.Start;
}
export declare type WorkflowStepStartController = WorkflowStepBaseController<VirtualStep.Start>;
export declare type WorkflowSuccessCustomEvent = ReturnType<typeof createWorkflowSuccessEvent>;
export { }