@jumio/websdk/index.d.ts

Jumio WebSDK is a powerful, flexible software development kit that simplifies the integration of Jumio's services into your web applications.

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 type { ValueError } from '@sinclair/typebox/errors';
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';
import { WrongSettings as WrongSettings_2 } from '../../../types/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;
    }>;
    createWrongSettingsEvent: EventCreator_3<"arbitrary", "wrong settings", EventMetadata_3 & WrongSettings_2>;
    wrongSettings: EventDispatcher_3<EventMetadata_3 & WrongSettings_2>;
    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;
    constructor();
    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;
    allowWebpUpload: boolean;
    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 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 crea