@jumio/websdk/index2.d.ts

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

import { Actor } from 'xstate';
import { AnyEventObject } from 'xstate';
import { BehaviorSubject } from 'rxjs';
import { Container } from 'inversify';
import type { createStore } from '@ngneat/elf';
import { CSSResult } from 'lit';
import { EventObject } from 'xstate';
import { Factory } from 'inversify';
import { identity } from 'rxjs';
import { LitElement } from 'lit';
import { MachineContext } from 'xstate';
import { MetaObject } from 'xstate';
import { NonReducibleUnknown } from 'xstate';
import { nothing } from 'lit';
import { Observable } from 'rxjs';
import { PropertyValues } from 'lit';
import type { PropsFactory } from '@ngneat/elf';
import { QRCodeRenderersOptions } from 'qrcode';
import { QRCodeSegment } from 'qrcode';
import { ReactiveController } from 'lit';
import type { ReactiveControllerHost } from 'lit';
import { ReactiveElement } from 'lit';
import { Ref } from 'lit/directives/ref.js';
import { Ref as Ref_2 } from 'lit-html/directives/ref.js';
import { ServiceIdentifier } from 'inversify';
import { StateMachine } from 'xstate';
import { Static } from '@sinclair/typebox';
import { Store } from '@ngneat/elf';
import { Subject } from 'rxjs';
import { Subscription } from 'rxjs';
import { SVGTemplateResult } from 'lit';
import { TArray } from '@sinclair/typebox';
import { TBoolean } from '@sinclair/typebox';
import { TDate } from '@sinclair/typebox';
import { TemplateResult } from 'lit-html';
import { TemplateResult as TemplateResult_2 } from 'lit';
import { TIntersect } from '@sinclair/typebox';
import { TLiteral } from '@sinclair/typebox';
import { TNumber } from '@sinclair/typebox';
import { TObject } from '@sinclair/typebox';
import { TOptional } from '@sinclair/typebox';
import { TRecord } from '@sinclair/typebox';
import { TSchema } from '@sinclair/typebox';
import { TString } from '@sinclair/typebox';
import { TTemplateLiteral } from '@sinclair/typebox';
import { TTransform } from '@sinclair/typebox';
import { TUndefined } from '@sinclair/typebox';
import { TUnion } from '@sinclair/typebox';
import { TUnknown } from '@sinclair/typebox';
import { TUnsafe } from '@sinclair/typebox';
import { UnaryFunction } from 'rxjs';
import type { ValueError } from '@sinclair/typebox/errors';

export declare type AcceptableConsentItem = Static<typeof TbAcceptableConsentItemSchema>;

export declare const acceptedMatchedId: EventDispatcher<    {
timestamp: number;
IDshareConsent: string;
idType?: string;
}>;

export declare type AcquisitionStatus = Static<typeof TbAcquisitionStatusSchema>;

export declare const AcquisitionStatusEnum: {
    readonly Failed: "FAILED";
    readonly NotStarted: "NOT_STARTED";
    readonly Pending: "PENDING";
    readonly Retry: "RETRY";
    readonly Success: "SUCCESS";
};

export declare interface AcquisitionStatusResponse {
    status: AcquisitionStatus;
    error?: FetchError;
}

export declare type ActiveScreen = Static<typeof TbActiveScreenSchema>;

export declare type ActiveScreenActions = Static<typeof TbActiveScreenActionsSchema>;

export declare const ActiveScreenActionsEnum: {
    readonly NavigateToWorkflow: "active-screen-navigate-to-workflow";
    readonly NavigateToCrossDevice: "active-screen-navigate-to-cross-device";
};

export declare const ActiveScreenEnum: {
    readonly Workflow: "workflow";
    readonly CrossDevice: "cross-device";
};

export declare type ActiveTrackState = Pick<MediaStreamTrack, 'contentHint' | 'enabled' | 'id' | 'kind' | 'label' | 'muted' | 'readyState'> & {
    capabilities: MediaTrackCapabilities;
    constraints: MediaTrackConstraints;
    settings: MediaTrackSettings;
};

export declare const aggregatedFeedback$: Observable<AutocaptureFeedback | undefined>;

export declare const aleKeyNotValid: ErrorCase;

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: {
    createWorkflowRestarted: EventCreator<"trace", "workflow restarted", EventMetadata>;
    workflowRestarted: EventDispatcher<EventMetadata>;
    generateFileUploadLoggerEvents: <T extends FileUploadEventName>(eventName: T) => [EventCreator<"trace", T, FileUploadEventMap[T]>, EventDispatcher<FileUploadEventMap[T]>];
    createSensorDataEvent: EventCreator<"trace", "sensor data", SensorData>;
    sensorData: EventDispatcher<SensorData>;
    createVideoPlayThrowsEvent: EventCreator<"trace", "video thrown an error", {
    name: string;
    message: string;
    stack?: string;
    state: unknown;
    }>;
    videoPlayThrows: EventDispatcher<    {
    name: string;
    message: string;
    stack?: string;
    state: unknown;
    }>;
    createCameraCaptureHintsShownEvent: EventCreator<"trace", "shown camera capture hints", {
    visible: boolean;
    }>;
    shownCameraCaptureHints: EventDispatcher<    {
    visible: boolean;
    }>;
    createFailedToFetchEvent: EventCreator<"trace", "failed to fetch", {
    error: FetchErrorParams;
    }>;
    failedToFetch: EventDispatcher<    {
    error: FetchErrorParams;
    }>;
    createLivenessManualSelfieFallbackEvent: EventCreator<"trace", "liveness - manual selfie fallback", {
    step: string;
    reason: string;
    }>;
    livenessManualSelfieFallback: EventDispatcher<    {
    step: string;
    reason: string;
    }>;
    createLivenessInitializedEvent: EventCreator<"trace", "liveness - initialized", {
    step: string;
    }>;
    livenessInitialized: EventDispatcher<    {
    step: string;
    }>;
    createLivenessModuleLoadingFailedEvent: EventCreator<"trace", "liveness - module loading failed", {
    step: string;
    }>;
    livenessModuleLoadingFailed: EventDispatcher<    {
    step: string;
    }>;
    createLivenessProgressEvent: EventCreator<"trace", "liveness - progress", {
    jliveProgressCurrentStep: number;
    jliveProgressStepsTotal: number;
    jLiveStepDuration: number;
    jLiveDuration: number;
    isFullscreen: boolean;
    cls?: CameraLivenessStatus;
    clsm?: CameraLivenessStatus;
    }>;
    livenessProgressEvent: EventDispatcher<    {
    jliveProgressCurrentStep: number;
    jliveProgressStepsTotal: number;
    jLiveStepDuration: number;
    jLiveDuration: number;
    isFullscreen: boolean;
    cls?: CameraLivenessStatus;
    clsm?: CameraLivenessStatus;
    }>;
    createAutocaptureStateChangeEvent: EventCreator<"trace", "id autocapture - state change event", {
    step: string;
    autocaptureState: string;
    autocaptureFallbackReason?: string;
    }>;
    autocaptureStateChangeEvent: EventDispatcher<    {
    step: string;
    autocaptureState: string;
    autocaptureFallbackReason?: string;
    }>;
    getEIDASUrlEvent: EventCreator<"trace", "get eIDAS url", EventMetadata>;
    getEidasUrl: EventDispatcher<EventMetadata>;
    EIDASSuccessEvent: EventCreator<"trace", "eIDAS success", EventMetadata>;
    eidasSuccess: EventDispatcher<EventMetadata>;
    EIDASFailedEvent: EventCreator<"trace", "eIDAS failed", EventMetadata>;
    eidasFailed: EventDispatcher<EventMetadata>;
    catchEIDASErrorEvent: EventCreator<"trace", "catch eIDAS error", {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    catchEidasError: EventDispatcher<    {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    createTrustCheckSuccessEvent: EventCreator<"trace", "trust check success", EventMetadata>;
    trustCheckSuccessEvent: EventDispatcher<EventMetadata>;
    createTrustCheckFailedEvent: EventCreator<"trace", "trust check failed", EventMetadata>;
    trustCheckFailedEvent: EventDispatcher<EventMetadata>;
    createTrustCheckUrlFetchEvent: EventCreator<"trace", "trust check url fetch", EventMetadata>;
    trustCheckUrlFetchEvent: EventDispatcher<EventMetadata>;
    createTrustCheckUrlFetchErrorEvent: EventCreator<"trace", "trust check url fetch error", {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    trustCheckUrlFetchErrorEvent: EventDispatcher<    {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    createTrustCheckStatusFetchErrorEvent: EventCreator<"trace", "trust check status fetch error", {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    trustCheckStatusFetchErrorEvent: EventDispatcher<    {
    name?: string;
    message?: string;
    stack?: string;
    }>;
    createUnhandledrejectionEvent: EventCreator<"trace", "unhandled promise rejection", {
    name: string;
    message: string;
    stack?: string;
    }>;
    unhandledrejectionEvent: EventDispatcher<    {
    name: string;
    message: string;
    stack?: string;
    }>;
    createUncaughtErrorEvent: EventCreator<"trace", "uncaught error", {
    name: string;
    message: string;
    stack?: string;
    }>;
    uncaughtErrorEvent: EventDispatcher<    {
    name: string;
    message: string;
    stack?: string;
    }>;
    createRedirectionEvent: EventCreator<"trace", "redirect", {
    url: string;
    type: "ERROR" | "SUCCESS";
    errorCode?: string;
    }>;
    redirectionEvent: EventDispatcher<    {
    url: string;
    type: "ERROR" | "SUCCESS";
    errorCode?: string;
    }>;
    createCustomTranslationEvent: EventCreator<"trace", "custom translation", {
    customTranslation: string;
    }>;
    customTranslationEvent: EventDispatcher<    {
    customTranslation: string;
    }>;
    createCustomTranslationErrorEvent: EventCreator<"trace", "custom translation error", {
    message: string;
    error?: unknown;
    }>;
    customTranslationErrorEvent: EventDispatcher<    {
    message: string;
    error?: unknown;
    }>;
    createShownCameraAccessRequestScreenEvent: EventCreator<"screen", "camera access request", {
    kind: "denied" | "prompt";
    devices: MediaDeviceMetadata[];
    }>;
    shownCameraAccessRequestScreen: EventDispatcher<    {
    kind: "denied" | "prompt";
    devices: MediaDeviceMetadata[];
    }>;
    createShownFinishScreenEvent: EventCreator<"screen", "finish", {
    outcome: RequestOutcome<FinalizeResponse | undefined, unknown>;
    }>;
    shownFinishScreen: EventDispatcher<    {
    outcome: RequestOutcome<FinalizeResponse | undefined, unknown>;
    }>;
    createShownCrossDeviceScreenEvent: EventCreator<"screen", "cross device", EventMetadata>;
    shownCrossDeviceScreen: EventDispatcher<EventMetadata>;
    createShownCrossDeviceFinishScreenEvent: EventCreator<"screen", "cross device finish", {
    acquisitionStatus: AcquisitionStatus;
    error?: PublicError;
    }>;
    shownCrossDeviceFinishScreen: EventDispatcher<    {
    acquisitionStatus: AcquisitionStatus;
    error?: PublicError;
    }>;
    createShownErrorEvent: EventCreator<"screen", "error", EventMetadata>;
    shownError: EventDispatcher<EventMetadata>;
    getShownScreenEventReporter: (eventName: string) => [EventCreator<"screen", string, {
    acquisitionStatus: AcquisitionStatus;
    }>, EventDispatcher<    {
    acquisitionStatus: AcquisitionStatus;
    }>];
    shownIdLookupScreen: EventDispatcher<    {
    outcome: RequestOutcome<LookupResponse | undefined, unknown>;
    matchFound?: boolean;
    lookupDuration?: number;
    }>;
    createPublicErrorEvent: EventCreator<"screen", "public error", {
    errorCode: string;
    }>;
    publicError: EventDispatcher<    {
    errorCode: string;
    }>;
    createSelectedCountryEvent: EventCreator<"action", "selected country", {
    country: string | undefined;
    }>;
    selectedCountry: EventDispatcher<    {
    country: string | undefined;
    }>;
    createSelectedDocumentEvent: EventCreator<"action", "selected document", {
    document: string;
    digitalIdProvider?: string;
    }>;
    selectedDocument: EventDispatcher<    {
    document: string;
    digitalIdProvider?: string;
    }>;
    createClickedStartButtonEvent: EventCreator<"action", "clicked start button", EventMetadata>;
    clickedStartButton: EventDispatcher<EventMetadata>;
    createClickedRetryButtonEvent: EventCreator<"action", "clicked retry button", EventMetadata>;
    clickedRetryButton: EventDispatcher<EventMetadata>;
    createClickedCrossDeviceButtonEvent: EventCreator<"action", "clicked cross device button", EventMetadata>;
    clickedCrossDeviceButton: EventDispatcher<EventMetadata>;
    createClickedSendEmailButtonEvent: EventCreator<"action", "clicked send email button", EventMetadata>;
    clickedSendEmailButton: EventDispatcher<EventMetadata>;
    createEmailSentError: EventCreator<"action", "email sent error", EventMetadata>;
    emailSentError: EventDispatcher<EventMetadata>;
    createClickedContinueUploadButtonEvent: EventCreator<"action", "clicked continue button", {
    documentType?: string;
    pageCount?: number;
    }>;
    clickedContinueUploadButton: EventDispatcher<    {
    documentType?: string;
    pageCount?: number;
    }>;
    acceptedMatchedId: EventDispatcher<    {
    timestamp: number;
    IDshareConsent: string;
    idType?: string;
    }>;
    createChangeLanguage: EventCreator<"action", "change language", EventMetadata>;
    changeLanguage: EventDispatcher<EventMetadata>;
    createClickedUseAnotherIdButton: EventCreator<"action", "clicked use another ID button", EventMetadata>;
    clickedUseAnotherIdButton: EventDispatcher<EventMetadata>;
    createSettingsEvent: EventCreator<"arbitrary", "settings", {
    credentials: unknown;
    }>;
    settings: EventDispatcher<    {
    credentials: unknown;
    }>;
    createWrongSettingsEvent: EventCreator<"arbitrary", "wrong settings", (EventMetadata & WrongSettingsCritical) | (EventMetadata & WrongSettingsNonCritical)>;
    wrongSettings: EventDispatcher<(EventMetadata & WrongSettingsCritical) | (EventMetadata & WrongSettingsNonCritical)>;
    createRuntimeEvent: EventCreator<"arbitrary", "runtime", EventMetadata>;
    runtime: EventDispatcher<EventMetadata>;
    createShownConsentMessageEvent: EventCreator<"arbitrary", "shown consent message", EventMetadata>;
    shownConsentMessage: EventDispatcher<EventMetadata>;
    createUsedCaptureTypesEvent: EventCreator<"arbitrary", "capture types", {
    livenessCaptureType?: LivenessCaptureTypes;
    idCaptureType?: IdCaptureTypes;
    xDeviceJourney: boolean;
    usedAllCaptureTypes: (IdCaptureTypes | LivenessCaptureTypes)[];
    }>;
    usedCaptureTypesEvent: EventDispatcher<    {
    livenessCaptureType?: LivenessCaptureTypes;
    idCaptureType?: IdCaptureTypes;
    xDeviceJourney: boolean;
    usedAllCaptureTypes: (IdCaptureTypes | LivenessCaptureTypes)[];
    }>;
};

export declare class AppContainerComponent extends BaseComponent {
    #private;
    static styles: CSSResult[];
    config: AppContainerConfig;
    activeConfig: AppContainerConfigFull;
    readonly layout$: Observable<AppContainerLayout>;
    readonly layoutController: AsyncController<AppContainerLayout, true>;
    constructor();
    willUpdate(changedProperties: PropertyValues<this>): void;
    render(): TemplateResult<1> | typeof nothing;
}

export declare interface AppContainerConfig {
    headerVisible?: boolean;
    footerVisible?: boolean;
    layoutType?: AppContainerLayoutType;
    cameraFilterFn?: CameraFilterFn | undefined;
}

declare type AppContainerConfigFull = DeepRequired<Omit<AppContainerConfig, 'cameraFilterFn'>> & Pick<AppContainerConfig, 'cameraFilterFn'>;

export declare type AppContainerLayout = AppContainerLayoutCaptureScreen | AppContainerLayoutGeneric;

export declare interface AppContainerLayoutCaptureScreen {
    type: typeof AppContainerLayoutTypeEnum.CaptureScreen;
    variant: AppContainerLayoutCaptureScreenVariant;
}

export declare type AppContainerLayoutCaptureScreenVariant = Static<typeof TbAppContainerLayoutCaptureScreenVariantSchema>;

export declare const AppContainerLayoutCaptureScreenVariantEnum: {
    readonly Small: "small";
    readonly Large: "large";
};

export declare interface AppContainerLayoutGeneric {
    type: typeof AppContainerLayoutTypeEnum.Generic;
}

export declare type AppContainerLayoutType = Static<typeof TbAppContainerLayoutTypeSchema>;

export declare const AppContainerLayoutTypeEnum: {
    readonly Generic: "generic";
    readonly CaptureScreen: "capture-screen";
};

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 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 authFailed: ErrorCase;

export declare type AutocaptureConditionCallback = (params: AutocaptureStore) => boolean;

export declare type AutocaptureDocClassifierData = Static<typeof TbAutocaptureDocClassifierDataSchema>;

export declare interface AutocaptureDocClassifierExtendedData extends AutocaptureDocClassifierData {
    impliedDocumentSide?: PhysicalDocumentSideClassifier | undefined;
}

export declare interface AutocaptureDocCornerData {
    topLeft: AutocaptureDocXY;
    topRight: AutocaptureDocXY;
    bottomLeft: AutocaptureDocXY;
    bottomRight: AutocaptureDocXY;
}

export declare interface AutocaptureDocPose extends AutocaptureDocClassifierData {
    timestamp: number;
    cornerData: AutocaptureDocCornerData;
    middlePoint: AutocaptureDocXY;
    width: number;
    height: number;
    aspectRatio: number;
    shift: number;
}

export declare interface AutocaptureDocXY {
    x: number;
    y: number;
}

export declare interface AutocaptureFallbackToManualCaptureOnUserStrugglingParams {
    smoothedFeedback$: Observable<AutocaptureFeedback | undefined>;
    uniqueMessageCount?: number;
    debounceTimeMs?: number;
}

export declare interface AutocaptureFeedback {
    cornersVisible: boolean;
    closeEnough: boolean;
    farEnough: boolean;
    middlePointAligned: boolean;
}

export declare interface AutocaptureGetPoseFeedbackParameters {
    pose$: Observable<AutocaptureDocPose | undefined>;
    docFinder$: Observable<AutocaptureStateDocFinderPosition>;
    videoResolution$: Observable<Resolution>;
}

export declare type AutocaptureState = Static<typeof TbAutocaptureStateSchema>;

export declare const autocaptureStateChangeEvent: EventDispatcher<    {
step: string;
autocaptureState: string;
autocaptureFallbackReason?: string;
}>;

export declare interface AutocaptureStateDocFinderPosition {
    type: typeof AutocaptureStateTypeEnum.DocFinder;
    edgeMarginRatio: number;
    minFillRatio: number;
    maxFillRatio: number;
    cx: number;
    cy: number;
    radius: number;
}

export declare const AutocaptureStateEnum: {
    readonly NOT_LOADED: "not-loaded";
    readonly LOADING: "loading";
    readonly ACTIVE: "active";
    readonly MANUAL_CAPTURE_FALLBACK: "manual-capture-fallback";
};

export declare type AutocaptureStateType = Static<typeof TbAutocaptureStateTypeSchema>;

export declare const AutocaptureStateTypeEnum: {
    readonly DocFinder: "doc-finder";
};

export declare interface AutocaptureStore {
    activationTime?: number;
    docFinder: AutocaptureStateDocFinderPosition;
    fallbackReason?: ManualCaptureFallbackReason;
    feedback: AutocaptureFeedback | undefined;
    fps?: number;
    smoothedFeedback: AutocaptureFeedback | undefined;
    state: AutocaptureState;
    docClassifierCurrent?: AutocaptureDocClassifierData | undefined;
}

declare interface AutocaptureTrackerBackdrop {
    visible?: boolean;
    color?: string;
}

declare interface AutocaptureTrackerBorderConfig {
    widthRatio?: number;
    color?: string;
    radiusRatio?: number;
}

export declare interface AutocaptureTrackerConfig {
    message?: IdCaptureMessage;
    activeBorder?: AutocaptureTrackerBorderConfig;
    inactiveBorder?: AutocaptureTrackerBorderConfig;
    placeholder?: AutocaptureTrackerPlaceholder;
    backdrop?: AutocaptureTrackerBackdrop;
    capturing?: boolean;
    idCardAspectRatio?: number;
    isDebugging?: boolean;
}

declare interface AutocaptureTrackerPlaceholder {
    visible?: boolean;
    side?: IdSide;
    alpha?: number;
    fillFactor?: number;
    debounceTimeMs?: number;
}

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 interface BackupEntry {
    backupGuid: string;
    workflowState: WorkflowState;
    navigationStep: NavigationStep;
}

export declare interface BackupEntryDescriptor extends BackupEntry {
    descriptor: string;
}

export declare const backupRestoreState: (storesToIgnore?: string[]) => `${string}-${string}-${string}-${string}-${string}`;

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;

declare type Builtin = Date | Error | Function | Primitive | RegExp;

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 type ButtonShape = Static<typeof TbButtonShapeSchema>;

export declare const ButtonShapeEnum: {
    readonly Default: "default";
    readonly Round: "round";
};

export declare type ButtonSize = Static<typeof TbButtonSizeSchema>;

export declare const ButtonSizeEnum: {
    readonly Small: "small";
    readonly Medium: "medium";
    readonly Large: "large";
    readonly ExtraLarge: "extra-large";
};

export declare type ButtonType = Static<typeof TbButtonTypeSchema>;

export declare const ButtonTypeEnum: {
    readonly Primary: "primary";
    readonly Secondary: "secondary";
    readonly Tertiary: "tertiary";
    readonly Quiet: "quiet";
    readonly QuietIcon: "quiet-icon";
    readonly Destructive: "destructive";
};

export declare const cameraCapture: EventDispatcher<    {
cameraState: {
resolution: Resolution;
activeTrackState: ActiveTrackState | undefined;
cameraFacingMode: CameraFacingMode;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
};
permissionState: PermissionStore;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo[];
currentDevice: JMediaDeviceInfo | undefined;
isBusy: boolean;
};
} & {
idSharpness?: unknown;
idAutocapture?: boolean;
idAutocaptureState?: unknown;
idAutocaptureFallbackReason?: string;
timeSpentInStepMs?: number;
cls?: CameraLivenessStatus;
clsm?: CameraLivenessStatus;
docClassifier?: unknown;
classifier?: Classifier;
}>;

export declare type CameraCaptureIdAutocaptureStateLogEvent = 'auto-capture' | 'manual-capture-fallback' | 'manual-capture';

export declare interface CameraCapturingEngine {
    getImageData: GetImageDataCallback;
    getBlob: GetBlobCallback;
}

export declare interface CameraCapturingEngineGetBlobParams {
    imageType?: ToBlobSupportedImageType;
    quality?: number;
    sinceTimestamp?: number;
}

export declare interface CameraCapturingEngineGetBlobResult {
    timestamp: number;
    blob: Blob;
    width: number;
    height: number;
}

export declare interface CameraCapturingEngineGetBlobResultWithClassifier extends CameraCapturingEngineGetBlobResult {
    classifier: Classifier;
    usabilityExpected: boolean;
}

export declare interface CameraCapturingEngineGetImageDataParams {
    sinceTimestamp?: number;
}

export declare interface CameraCapturingEngineGetImageDataResult {
    timestamp: number;
    imageData: ImageData;
}

export declare class CameraComponent extends BaseComponent implements CameraRenderingEngine, CameraCapturingEngine {
    #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>;
    switchStream: (e: SwitchCameraCommand | SwitchStreamCommand) => Promise<VideoSource | undefined>;
    onVideoTick: VideoTickCallback;
    onYuvProcessorAvailable: GetYuvProcessorCallback;
    getImageData: GetImageDataCallback;
    getBlob: GetBlobCallback;
    captureImage: GetBlobCallback;
    getVideoElement: () => HTMLVideoElement;
    hasFlash(): boolean;
    setFlashState(isEnabled: boolean): Promise<void>;
}

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 type CameraFacingMode = Static<typeof TbCameraFacingModeSchema>;

export declare const CameraFacingModeEnum: {
    readonly Front: "front";
    readonly Back: "back";
    readonly 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<EventMetadata>;

export declare class CameraInternalLayoutComponent extends BaseComponent {
    static styles: CSSResult[];
    readonly containerElRef: Ref_2<HTMLDivElement>;
    readonly refresh$: Subject<void>;
    readonly size$: Observable<VideoSizeInfo>;
    readonly sizeController: AsyncController<VideoSizeInfo, 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<    {
cameraState: {
resolution: Resolution;
activeTrackState: ActiveTrackState | undefined;
cameraFacingMode: CameraFacingMode;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
};
permissionState: PermissionStore;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo[];
currentDevice: JMediaDeviceInfo | 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, CameraCapturingEngine {
    #private;
    static styles: CSSResult[];
    originalResolution: Resolution | undefined;
    targetResolution: Resolution | undefined;
    flipped: boolean;
    fitMode: CanvasFitMode;
    allowWebp: boolean;
    render(): TemplateResult<1>;
    onVideoTick: VideoTickCallback;
    getImageData: GetImageDataCallback;
    getBlob: GetBlobCallback;
}

export declare interface CameraRenderingEngine {
    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 type CameraSelectorOrientation = Static<typeof TbCameraSelectorOrientationSchema>;

export declare const CameraSelectorOrientationEnum: {
    readonly Vertical: "vertical";
    readonly Horizontal: "horizontal";
};

export declare const cameraStateChanged: EventDispatcher<    {
cameraState: {
resolution: Resolution;
activeTrackState: ActiveTrackState | undefined;
cameraFacingMode: CameraFacingMode;
isPlaying: boolean;
isBusy: boolean;
};
deviceListState: DeviceStore & {
deviceEntities: Record<string, JMediaDeviceInfo>;
deviceIds: string[];
} & {
mockDeviceEntities: Record<string, JMediaDeviceInfo>;
mockDeviceIds: string[];
};
permissionState: PermissionStore;
cameraSelectorDeviceList: {
devices: JMediaDeviceInfo[];
currentDevice: JMediaDeviceInfo | 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 type CanvasFitMode = Static<typeof TbCanvasFitModeSchema>;

export declare const CanvasFitModeEnum: {
    readonly Contain: "contain";
    readonly Cover: "cover";
};

export declare class CaptureButtonComponent extends BaseComponent {
    static styles: CSSResult[];
    config: CaptureButtonConfig;
    protected activeConfig: {
        disabled: boolean;
        inactive: boolean;
        ariaLabel: string;
        pulsing: boolean;
    };
    willUpdate(changedProperties: PropertyValues<this>): void;
    update(changedProperties: PropertyValues<this>): void;
    render(): TemplateResult<1>;
    handleClickEvent(event: Event): void;
}

export declare interface CaptureButtonConfig {
    disabled?: boolean;
    inactive?: boolean;
    ariaLabel?: string;
    pulsing?: boolean;
}

export declare type CaptureLabelAriaLive = 'assertive' | 'off' | 'polite';

export declare class CaptureLabelComponent extends BaseComponent {
    static styles: CSSResult[];
    config: CaptureLabelConfig;
    protected activeConfig: DeepRequired<CaptureLabelConfig>;
    willUpdate(changedProperties: PropertyValues<this>): void;
    render(): TemplateResult<1>;
}

export declare interface CaptureLabelConfig {
    background?: string;
    progress?: CaptureLabelProgressConfig;
    ariaLive?: CaptureLabelAriaLive;
    ariaAtomic?: boolean;
    ariaRole?: string;
    size?: CaptureLabelSize;
}

export declare interface CaptureLabelProgressConfig {
    progressColor1?: string;
    progressColor2?: string;
    value?: number;
}

export declare type CaptureLabelSize = Static<typeof TbCaptureLabelSizeSchema>;

export declare const CaptureLabelSizeEnum: {
    readonly Medium: "medium";
    readonly Large: "large";
};

export declare class CaptureMessageContainerComponent extends BaseComponent {
    #private;
    static styles: CSSResult[];
    feedbackItems?: HTMLElement[];
    middleItems?: HTMLElement[];
    render(): TemplateResult<1>;
}

declare interface CaptureRequest {
    dateNow: number;
    performanceNow: number;
    autocapture: boolean;
    autocaptureFps?: number;
    docClassifier?: AutocaptureDocClassifierData;
    classifier: Classifier;
}

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 CardGroupComponent extends BaseComponent {
    static styles: CSSResult[];
    label: string;
    firstUpdated(): void;
    render(): TemplateResult<1>;
}

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 type CardSize = Static<typeof TbCardSizeSchema>;

export declare const CardSizeEnum: {
    readonly Small: "small";
    readonly Medium: "medium";
    readonly Large: "large";
};

export declare type CardType = Static<typeof TbCardTypeSchema>;

export declare const CardTypeEnum: {
    readonly Primary: "primary";
    readonly Secondary: "secondary";
    readonly 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;
    firstUpdated(): void;
    disconnectedCallback(): void;
    isScrollingAvailable(): boolean;
    navigateTo(offset: number): void;
    render(): TemplateResult<1>;
}

export declare class CarrouselNavigationEvent extends CustomEvent<number> {
    constructor(detail: number);
}

export declare const catchEidasError: EventDispatcher<    {
name?: string;
message?: string;
stack?: string;
}>;

export declare const catchEIDASErrorEvent: EventCreator<"trace", "catch eIDAS error", {
name?: string;
message?: string;
stack?: string;
}>;

export declare enum Category {
    Id = "ID",
    Facemap = "FACEMAP",
    Document = "DOCUMENT",
    Data = "DATA"
}

export declare const ccrLoadingFailed: ErrorCase;

export declare const certificateError: ErrorCase;

export declare const changeLanguage: EventDispatcher<EventMetadata>;

export declare interface CheckUsabilityParams {
    resultKey: string;
}

export declare interface CheckUsabilityParamsWithId {
    id: UUID;
    usability: CheckUsabilityParams;
}

export declare class CircularProgressIndicatorComponent extends BaseComponent {
    static styles: CSSResult[];
    config: CircularProgressIndicatorConfig;
    activeConfig: {
        size: number;
        fillRadius: number;
        fillWidth: number;
        fillColor: string;
        trackRadius: number;
        trackWidth: number;
        trackColor: string;
        underlayRadius: number;
        underlayColor: string;
        progress: number;
    };
    willUpdate(changedProperties: PropertyValues<this>): void;
    render(): TemplateResult<1>;
}

export declare interface CircularProgressIndicatorConfig {
    size?: number;
    fillRadius?: number;
    fillWidth?: number;
    fillColor?: string;
    trackRadius?: number;
    trackWidth?: number;
    trackColor?: string;
    underlayRadius?: number;
    underlayColor?: string;
    progress?: number;
}

export declare type Classifier = Static<typeof TbClassifierSchema>;

export declare const ClassifierEnum: {
    readonly CnhPdf: "CNH_PDF";
    readonly Document: "DOCUMENT";
    readonly Face: "FACE";
    readonly Data: "DATA";
    readonly IdFrontWithFlash: "FRONT_WITH_FLASH";
    readonly JumioLivenessBlob: "JUMIO_LIVENESS_BLOB";
    readonly FrontSide: "FRONTSIDE";
    readonly BackSide: "BACKSIDE";
};

export declare const classifierFilter: (classifier: Classifier) => FindFileMetadataByParamsCallback;

declare interface ClassifierWithUploadState {
    credentialId: UUID;
    classifier: Classifier;
    acceptedFileTypes: string;
    file: FileStoreEntity;
    multipartFileOverrides?: Partial<MultipartFile>;
    isEnabled: boolean;
    isRequired: boolean;
}

export declare const clickedContinueUploadButton: EventDispatcher<    {
documentType?: string;
pageCount?: number;
}>;

export declare const clickedCrossDeviceButton: EventDispatcher<EventMetadata>;

export declare const clickedRetryButton: EventDispatcher<EventMetadata>;

export declare const clickedSendEmailButton: EventDispatcher<EventMetadata>;

export declare const clickedStartButton: EventDispatcher<EventMetadata>;

export declare const clickedUseAnotherIdButton: EventDispatcher<EventMetadata>;

export declare const clsAppendItem: (item: CameraLivenessStatus) => void;

export declare const clsr: () => void;

export declare type ColorScheme = Static<typeof TbColorSchemeSchema>;

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__: "light" | "dark" | "auto";
};

export declare const ColorSchemeEnum: {
    readonly Light: "light";
    readonly Dark: "dark";
    readonly Auto: "auto";
};

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 {
    IdFinderLiveness = "id_finder_liveness",
    PremiumWeb = "premium_web",
    StandardWeb = "standard_web"
}

export declare type ConfigurationAutocaptureSettings = Static<typeof TbConfigurationAutocaptureSettingsSchema>;

export declare type ConfigurationDatadog = Static<typeof TbConfigurationDatadogSchema>;

export declare type ConfigurationFileUpload = Static<typeof TbConfigurationFileUploadSchema>;

export declare type ConfigurationHelpScreen = Static<typeof TbConfigurationHelpScreenSchema>;

export declare type ConfigurationIdSharpness = Static<typeof TbConfigurationIdSharpnessSchema>;

export declare type Configurations = Static<typeof TbConfigurationsSchema>;

export declare type ConfigurationsLike = Static<typeof TbConfigurationsLikeSchema>;

export declare type ConfigurationSupplementalImage = Static<typeof TbConfigurationSupplementalImageSchema>;

export declare type ConfigurationSupplementalImageSequence = Static<typeof TbConfigurationSupplementalImageSequenceSchema>;

export declare type ConfigurationSupplementalImagesV2 = Static<typeof TbConfigurationSupplementalImagesV2Schema>;

export declare type ConfigurationSupplementalImageWithFlash = Static<typeof TbConfigurationSupplementalImageWithFlashSchema>;

export declare class ConsentChangeEvent extends CustomEvent<ConsentData> {
    constructor(detail: ConsentData);
}

export declare interface ConsentData {
    consentGiven: boolean;
    timestamp: number;
    id: string;
}

export declare type ConsentDisplayType = Static<typeof TbConsentDisplayTypeSchema>;

export declare const ConsentDisplayTypeEnum: {
    readonly Passive: "PASSIVE";
    readonly Active: "ACTIVE";
};

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 class ConsentSubmissionError extends FetchError {
}

export declare const consentSubmissionError: ErrorCase;

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 type CountryCode = Static<typeof TbCountryCodeSchema>;

export declare const CountryCodeEnum: {
    readonly ABW: "ABW";
    readonly AFG: "AFG";
    readonly AGO: "AGO";
    readonly AIA: "AIA";
    readonly ALA: "ALA";
    readonly ALB: "ALB";
    readonly AND: "AND";
    readonly ARE: "ARE";
    readonly ARG: "ARG";
    readonly ARM: "ARM";
    readonly ASM: "ASM";
    readonly ATA: "ATA";
    readonly ATF: "ATF";
    readonly ATG: "ATG";
    readonly AUS: "AUS";
    readonly AUT: "AUT";
    readonly AZE: "AZE";
    readonly BDI: "BDI";
    readonly BEL: "BEL";
    readonly BEN: "BEN";
    readonly BES: "BES";
    readonly BFA: "BFA";
    readonly BGD: "BGD";
    readonly BGR: "BGR";
    readonly BHR: "BHR";
    readonly BHS: "BHS";
    readonly BIH: "BIH";
    readonly BLM: "BLM";
    readonly BLR: "BLR";
    readonly BLZ: "BLZ";
    readonly BMU: "BMU";
    readonly BOL: "BOL";
    readonly BRA: "BRA";
    readonly BRB: "BRB";
    readonly BRN: "BRN";
    readonly BTN: "BTN";
    readonly BVT: "BVT";
    readonly BWA: "BWA";
    readonly CAF: "CAF";
    readonly CAN: "CAN";
    readonly CCK: "CCK";
    readonly CHE: "CHE";
    readonly CHL: "CHL";
    readonly CHN: "CHN";
    readonly CIV: "CIV";
    readonly CMR: "CMR";
    readonly COD: "COD";
    readonly COG: "COG";
    readonly COK: "COK";
    readonly COL: "COL";
    readonly COM: "COM";
    readonly CPV: "CPV";
    readonly CRI: "CRI";
    readonly CUB: "CUB";
    readonly CUW: "CUW";
    readonly CXR: "CXR";
    readonly CYM: "CYM";
    readonly CYP: "CYP";
    readonly CZE: "CZE";
    readonly DEU: "DEU";
    readonly DJI: "DJI";
    readonly DMA: "DMA";
    readonly DNK: "DNK";
    readonly DOM: "DOM";
    readonly DZA: "DZA";
    readonly ECU: "ECU";
    readonly EGY: "EGY";
    readonly ERI: "ERI";
    readonly ESH: "ESH";
    readonly ESP: "ESP";
    readonly EST: "EST";
    readonly ETH: "ETH";
    readonly FIN: "FIN";
    readonly FJI: "FJI";
    readonly FLK: "FLK";
    readonly FRA: "FRA";
    readonly FRO: "FRO";
    readonly FSM: "FSM";
    readonly GAB: "GAB";
    readonly GBR: "GBR";
    readonly GEO: "GEO";
    readonly GGY: "GGY";
    readonly GHA: "GHA";
    readonly GIB: "GIB";
    readonly GIN: "GIN";
    readonly GLP: "GLP";
    readonly GMB: "GMB";
    readonly GNB: "GNB";
    readonly GNQ: "GNQ";
    readonly GRC: "GRC";
    readonly GRD: "GRD";
    readonly GRL: "GRL";
    readonly GTM: "GTM";
    readonly GUF: "GUF";
    readonly GUM: "GUM";
    readonly GUY: "GUY";
    readonly HKG: "HKG";
    readonly HMD: "HMD";
    readonly HND: "HND";
    readonly HRV: "HRV";
    readonly HTI: "HTI";
    readonly HUN: "HUN";
    readonly IDN: "IDN";
    readonly IMN: "IMN";
    readonly IND: "IND";
    readonly IOT: "IOT";
    readonly IRL: "IRL";
    readonly IRN: "IRN";
    readonly IRQ: "IRQ";
    readonly ISL: "ISL";
    readonly ISR: "ISR";
    readonly ITA: "ITA";
    readonly JAM: "JAM";
    readonly JEY: "JEY";
    readonly JOR: "JOR";
    readonly JPN: "JPN";
    readonly KAZ: "KAZ";
    readonly KEN: "KEN";
    readonly KGZ: "KGZ";
    readonly KHM: "KHM";
    readonly KIR: "KIR";
    readonly KNA: "KNA";
    readonly KOR: "KOR";
    readonly KWT: "KWT";
    readonly LAO: "LAO";
    readonly LBN: "LBN";
    readonly LBR: "LBR";
    readonly LBY: "LBY";
    readonly LCA: "LCA";
    readonly LIE: "LIE";
    readonly LKA: "LKA";
    readonly LSO: "LSO";
    readonly LTU: "LTU";
    readonly LUX: "LUX";
    readonly LVA: "LVA";
    readonly MAC: "MAC";
    readonly MAF: "MAF";
    readonly MAR: "MAR";
    readonly MCO: "MCO";
    readonly MDA: "MDA";
    readonly MDG: "MDG";
    readonly MDV: "MDV";
    readonly MEX: "MEX";
    readonly MHL: "MHL";
    readonly MKD: "MKD";
    readonly MLI: "MLI";
    readonly MLT: "MLT";
    readonly MMR: "MMR";
    readonly MNE: "MNE";
    readonly MNG: "MNG";
    readonly MNP: "MNP";
    readonly MOZ: "MOZ";
    readonly MRT: "MRT";
    readonly MSR: "MSR";
    readonly MTQ: "MTQ";
    readonly MUS: "MUS";
    readonly MWI: "MWI";
    readonly MYS: "MYS";
    readonly MYT: "MYT";
    readonly NAM: "NAM";
    readonly NCL: "NCL";
    readonly NER: "NER";
    readonly NFK: "NFK";
    readonly NGA: "NGA";
    readonly NIC: "NIC";
    readonly NIU: "NIU";
    readonly NLD: "NLD";
    readonly NOR: "NOR";
    readonly NPL: "NPL";
    readonly NRU: "NRU";
    readonly NZL: "NZL";
    readonly OMN: "OMN";
    readonly PAK: "PAK";
    readonly PAN: "PAN";
    readonly PCN: "PCN";
    readonly PER: "PER";
    readonly PHL: "PHL";
    readonly PLW: "PLW";
    readonly PNG: "PNG";
    readonly POL: "POL";
    readonly PRI: "PRI";
    readonly PRK: "PRK";
    readonly PRT: "PRT";
    readonly PRY: "PRY";
    readonly PSE: "PSE";
    readonly PYF: "PYF";
    readonly QAT: "QAT";
    readonly REU: "REU";
    readonly ROU: "ROU";
    readonly RUS: "RUS";
    readonly RWA: "RWA";
    readonly SAU: "SAU";
    readonly SDN: "SDN";
    readonly SEN: "SEN";
    readonly SGP: "SGP";
    readonly SGS: "SGS";
    readonly SHN: "SHN";
    readonly SJM: "SJM";
    readonly SLB: "SLB";
    readonly SLE: "SLE";
    readonly SLV: "SLV";
    readonly SMR: "SMR";
    readonly SOM: "SOM";
    readonly SPM: "SPM";
    readonly SRB: "SRB";
    readonly SSD: "SSD";
    readonly STP: "STP";
    readonly SUR: "SUR";
    readonly SVK: "SVK";
    readonly SVN: "SVN";
    readonly SWE: "SWE";
    readonly SWZ: "SWZ";
    readonly SXM: "SXM";
    readonly SYC: "SYC";
    readonly SYR: "SYR";
    readonly TCA: "TCA";
    rea