onfido-sdk-ui 14.56.0 → 14.58.0

package/types/capture-api/callbacks/error.js

@@ -0,0 +1,241 @@
+var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["Authentication"] = "Authentication";
+    ErrorCategory["DeviceCapabilities"] = "DeviceCapabilities";
+    ErrorCategory["General"] = "General";
+    ErrorCategory["Initialisation"] = "Initialisation";
+    ErrorCategory["Network"] = "Network";
+    ErrorCategory["Permissions"] = "Permissions";
+    ErrorCategory["Processing"] = "Processing";
+})(ErrorCategory || (ErrorCategory = {}));
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["BiometricTokenRetrievalException"] = "BiometricTokenRetrievalException";
+    ErrorType["CameraException"] = "CameraException";
+    ErrorType["CameraNotDetected"] = "CameraNotDetected";
+    ErrorType["CrossDeviceDesktopError"] = "CrossDeviceDesktopError";
+    ErrorType["CrossDeviceRestartError"] = "CrossDeviceRestartError";
+    ErrorType["CrossDeviceVerificationAbortError"] = "CrossDeviceVerificationAbortError";
+    ErrorType["CrossDeviceVerificationInvalidError"] = "CrossDeviceVerificationInvalidError";
+    ErrorType["DuplicateGenericDocument"] = "DuplicateGenericDocument";
+    ErrorType["DuplicateStep"] = "DuplicateStep";
+    ErrorType["ExpiredToken"] = "ExpiredToken";
+    ErrorType["ExpiredTrial"] = "ExpiredTrial";
+    ErrorType["FeaturesNotAuthorized"] = "FeaturesNotAuthorized";
+    ErrorType["GenericException"] = "GenericException";
+    ErrorType["GeoBlocked"] = "GeoBlocked";
+    ErrorType["InitialisationInvalid"] = "InitialisationInvalid";
+    ErrorType["InvalidCountryCode"] = "InvalidCountryCode";
+    ErrorType["InvalidCustomTranslations"] = "InvalidCustomTranslations";
+    ErrorType["InvalidDocumentFormatAndCountryCombination"] = "InvalidDocumentFormatAndCountryCombination";
+    ErrorType["InvalidDocumentTitle"] = "InvalidDocumentTitle";
+    ErrorType["InvalidDocumentTypeException"] = "InvalidDocumentTypeException";
+    ErrorType["InvalidImageData"] = "InvalidImageData";
+    ErrorType["InvalidSdkParameter"] = "InvalidSdkParameter";
+    ErrorType["InvalidToken"] = "InvalidToken";
+    ErrorType["MissingLogoCobrandingParameter"] = "MissingLogoCobrandingParameter";
+    ErrorType["MissingSteps"] = "MissingSteps";
+    ErrorType["ModuleLoadError"] = "ModuleLoadError";
+    ErrorType["NetworkException"] = "NetworkException";
+    ErrorType["PermissionsUnavailable"] = "PermissionsUnavailable";
+    ErrorType["SdkVersionInsufficient"] = "SdkVersionInsufficient";
+    ErrorType["UnsupportedError"] = "UnsupportedError";
+    ErrorType["UnsupportedFeatureError"] = "UnsupportedFeatureError";
+    ErrorType["UploadError"] = "UploadError";
+    ErrorType["WelcomeMustBeFirstStep"] = "WelcomeMustBeFirstStep";
+    ErrorType["WorkflowBiometricTokenStorageException"] = "WorkflowBiometricTokenStorageException";
+    ErrorType["WorkflowInputError"] = "WorkflowInputError";
+    ErrorType["WorkflowTaskAbandoned"] = "WorkflowTaskAbandoned";
+    ErrorType["WorkflowTaskError"] = "WorkflowTaskError";
+    ErrorType["WorkflowVersionMismatch"] = "WorkflowVersionMismatch";
+})(ErrorType || (ErrorType = {}));
+export const BiometricTokenRetrievalException = {
+    type: ErrorType.BiometricTokenRetrievalException,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to inability to retrieve local face authentication token`,
+};
+export const CameraException = {
+    type: ErrorType.CameraException,
+    category: ErrorCategory.DeviceCapabilities,
+    message: `Flow error due to generic camera-related issue`,
+};
+export const CameraNotDetected = {
+    type: ErrorType.CameraNotDetected,
+    category: ErrorCategory.DeviceCapabilities,
+    message: `Flow error due to camera not found`,
+};
+export const CrossDeviceDesktopError = {
+    type: ErrorType.CrossDeviceDesktopError,
+    category: ErrorCategory.Processing,
+    message: `(Mobile cross-device session) Flow error due to desktop session being disconnected`,
+};
+export const CrossDeviceRestartError = {
+    type: ErrorType.CrossDeviceRestartError,
+    category: ErrorCategory.Processing,
+    message: `Generic flow error due to cross-device session becoming invalid`,
+};
+export const CrossDeviceVerificationAbortError = {
+    type: ErrorType.CrossDeviceVerificationAbortError,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to cross-device session being aborted by the user on mobile session`,
+};
+export const CrossDeviceVerificationInvalidError = {
+    type: ErrorType.CrossDeviceVerificationInvalidError,
+    category: ErrorCategory.Processing,
+    message: `(Mobile cross-device session) Flow error due to user selecting incorrect verification code`,
+};
+export const DuplicateGenericDocument = {
+    type: ErrorType.DuplicateGenericDocument,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to a duplicate generic document definition provided in the document step configuration`,
+};
+export const DuplicateStep = {
+    type: ErrorType.DuplicateStep,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to duplicate declaration in 'steps'`,
+};
+export const ExpiredToken = {
+    type: ErrorType.ExpiredToken,
+    category: ErrorCategory.Authentication,
+    message: `Flow cannot be initiated due to expired authentication token`,
+};
+export const ExpiredTrial = {
+    type: ErrorType.ExpiredTrial,
+    category: ErrorCategory.Authentication,
+    message: `Flow error due to expired account (or exceeded trial attempts)`,
+};
+export const FeaturesNotAuthorized = {
+    type: ErrorType.FeaturesNotAuthorized,
+    category: ErrorCategory.Initialisation,
+    message: `The flow cannot be initialised as selected feature is not authorised for this account. Please talk to Customer Support to get this feature enabled`,
+};
+export const GenericException = {
+    type: ErrorType.GenericException,
+    category: ErrorCategory.General,
+    message: `Generic flow error due to unknown error type`,
+};
+export const GeoBlocked = {
+    type: ErrorType.GeoBlocked,
+    category: ErrorCategory.General,
+    message: `Flow error due to request coming from geo-blocked country`,
+};
+export const InitialisationInvalid = {
+    type: ErrorType.InitialisationInvalid,
+    category: ErrorCategory.Initialisation,
+    message: `Generic flow initialisation error`,
+};
+export const InvalidCountryCode = {
+    type: ErrorType.InvalidCountryCode,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to an invalid country code provided in the document step configuration`,
+};
+export const InvalidCustomTranslations = {
+    type: ErrorType.InvalidCustomTranslations,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to an invalid translation key being provided`,
+};
+export const InvalidDocumentFormatAndCountryCombination = {
+    type: ErrorType.InvalidDocumentFormatAndCountryCombination,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to an invalid country code / document type combination being provided in the document step configuration`,
+};
+export const InvalidDocumentTitle = {
+    type: ErrorType.InvalidDocumentTitle,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to an invalid generic document title provided in the document step configuration`,
+};
+export const InvalidDocumentTypeException = {
+    type: ErrorType.InvalidDocumentTypeException,
+    category: ErrorCategory.Initialisation,
+    message: `DocumentType.UNKNOWN should not be used.`,
+};
+export const InvalidImageData = {
+    type: ErrorType.InvalidImageData,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to error in image compression or on-device processing`,
+};
+export const InvalidSdkParameter = {
+    type: ErrorType.InvalidSdkParameter,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to invalid initialisation parameters`,
+};
+export const InvalidToken = {
+    type: ErrorType.InvalidToken,
+    category: ErrorCategory.Authentication,
+    message: `Flow cannot be initiated due invalid authentication token`,
+};
+export const MissingLogoCobrandingParameter = {
+    type: ErrorType.MissingLogoCobrandingParameter,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised as logo cobranding requires both a light and dark mode logo image`,
+};
+export const MissingSteps = {
+    type: ErrorType.MissingSteps,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to empty 'steps' declaration`,
+};
+export const ModuleLoadError = {
+    type: ErrorType.ModuleLoadError,
+    category: ErrorCategory.Processing,
+    message: `The module encountered an error while loading`,
+};
+export const NetworkException = {
+    type: ErrorType.NetworkException,
+    category: ErrorCategory.Network,
+    message: `Generic flow error due to network issue`,
+};
+export const PermissionsUnavailable = {
+    type: ErrorType.PermissionsUnavailable,
+    category: ErrorCategory.Permissions,
+    message: `Flow error due to SDK not being able to assess permissions (webview context)`,
+};
+export const SdkVersionInsufficient = {
+    type: ErrorType.SdkVersionInsufficient,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to invalid SDK version`,
+};
+export const UnsupportedError = {
+    type: ErrorType.UnsupportedError,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to a selected module not being supported (environment or client)`,
+};
+export const UnsupportedFeatureError = {
+    type: ErrorType.UnsupportedFeatureError,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to a selected feature not being supported (environment or client)`,
+};
+export const UploadError = {
+    type: ErrorType.UploadError,
+    category: ErrorCategory.Network,
+    message: `Flow error due to failed media upload`,
+};
+export const WelcomeMustBeFirstStep = {
+    type: ErrorType.WelcomeMustBeFirstStep,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised if 'Welcome' step is present but not first in the list of steps`,
+};
+export const WorkflowBiometricTokenStorageException = {
+    type: ErrorType.WorkflowBiometricTokenStorageException,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to inability to store local face authentication token`,
+};
+export const WorkflowInputError = {
+    type: ErrorType.WorkflowInputError,
+    category: ErrorCategory.Initialisation,
+    message: `Flow error due to invalid or missing inputs provided as part of the workflow initialisation`,
+};
+export const WorkflowTaskAbandoned = {
+    type: ErrorType.WorkflowTaskAbandoned,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to workflow already been completed or expired`,
+};
+export const WorkflowTaskError = {
+    type: ErrorType.WorkflowTaskError,
+    category: ErrorCategory.Processing,
+    message: `Flow error due to generic workflow error`,
+};
+export const WorkflowVersionMismatch = {
+    type: ErrorType.WorkflowVersionMismatch,
+    category: ErrorCategory.Initialisation,
+    message: `Flow cannot be initialised due to target workflow requiring a higher version of the SDK`,
+};

package/types/capture-api/callbacks/exit.d.ts

@@ -0,0 +1,6 @@
+export declare enum UserAction {
+    UserExit = "UserExit",
+    ConsentDenied = "ConsentDenied",
+    PermissionsDenied = "PermissionsDenied"
+}
+export type UserExitCallback = (userAction: UserAction) => void;

package/types/capture-api/callbacks/exit.js

@@ -0,0 +1,6 @@
+export var UserAction;
+(function (UserAction) {
+    UserAction["UserExit"] = "UserExit";
+    UserAction["ConsentDenied"] = "ConsentDenied";
+    UserAction["PermissionsDenied"] = "PermissionsDenied";
+})(UserAction || (UserAction = {}));

package/types/capture-api/callbacks/media.d.ts

@@ -0,0 +1,20 @@
+export type MediaCallback = (result: MediaResult) => void;
+export type MediaFile = {
+    fileData: Blob;
+    fileType: string;
+    fileName: string;
+};
+export type MediaResult = {
+    key: string;
+    mediaFile: MediaFile;
+};
+export type DocumentMetadata = {
+    side: string;
+    type: string;
+    issuingCountry?: string;
+};
+export type DocumentMediaResults = MediaResult & {
+    documentMetadata: DocumentMetadata;
+};
+export type FacePhotoMediaResult = MediaResult;
+export type FaceVideoMediaResult = MediaResult;

package/types/capture-api/callbacks/media.js

@@ -0,0 +1 @@
+export {};

package/types/capture-api/index.d.ts

@@ -0,0 +1,23 @@
+import { Welcome } from './steps/Welcome';
+import { Document } from './steps/Document';
+import { ProofOfAddress } from './steps/ProofOfAddress';
+import { Complete } from './steps/Complete';
+import { FaceMotion, FacePhoto, FaceVideo } from './steps/Face';
+export { Welcome, Document, ProofOfAddress, Complete, FacePhoto, FaceVideo, FaceMotion, };
+export * from './SdkParameters';
+export * from './Localisation';
+export * from './CrossDevice';
+export * from './Module';
+export * from './theming/Theme';
+export * from './steps/Welcome';
+export * from './steps/Document';
+export * from './steps/ProofOfAddress';
+export * from './steps/Complete';
+export * from './steps/Face';
+export * from './callbacks/analytics';
+export * from './callbacks/biometricsToken';
+export * from './callbacks/callbacks';
+export * from './callbacks/complete';
+export * from './callbacks/error';
+export * from './callbacks/exit';
+export * from './callbacks/media';

package/types/capture-api/index.js

@@ -0,0 +1,24 @@
+import { Welcome } from './steps/Welcome';
+import { Document } from './steps/Document';
+import { ProofOfAddress } from './steps/ProofOfAddress';
+import { Complete } from './steps/Complete';
+import { FaceMotion, FacePhoto, FaceVideo } from './steps/Face';
+export { Welcome, Document, ProofOfAddress, Complete, FacePhoto, FaceVideo, FaceMotion, };
+// Export all types at root (@onfido/capture-api)
+export * from './SdkParameters';
+export * from './Localisation';
+export * from './CrossDevice';
+export * from './Module';
+export * from './theming/Theme';
+export * from './steps/Welcome';
+export * from './steps/Document';
+export * from './steps/ProofOfAddress';
+export * from './steps/Complete';
+export * from './steps/Face';
+export * from './callbacks/analytics';
+export * from './callbacks/biometricsToken';
+export * from './callbacks/callbacks';
+export * from './callbacks/complete';
+export * from './callbacks/error';
+export * from './callbacks/exit';
+export * from './callbacks/media';

package/types/capture-api/steps/Complete.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyOptions, Step } from './Step.js';
+import { StepNames } from './Step.js';
+export type CompleteStep = Step<StepNames.Complete, EmptyOptions>;
+export declare const Complete: () => CompleteStep;

package/types/capture-api/steps/Complete.js

@@ -0,0 +1,6 @@
+import { StepNames } from './Step.js';
+export const Complete = () => ({
+    type: StepNames.Complete,
+    key: StepNames.Complete,
+    options: {},
+});

package/types/capture-api/steps/Document.d.ts

@@ -0,0 +1,36 @@
+import type { Step } from './Step.js';
+import { StepNames } from './Step.js';
+export type GenericDocument = {
+    id: string;
+    country: string;
+    pages: number;
+    title: string;
+    subtitle: string;
+};
+export declare enum DocumentType {
+    DrivingLicence = "driving_licence",
+    GenericDocument = "generic_document",
+    NationalIdentityCard = "national_identity_card",
+    Passport = "passport",
+    PassportCard = "passport_card",
+    ResidencePermit = "residence_permit"
+}
+export type DocumentSelection = {
+    id?: string;
+    documentType: DocumentType;
+    issuingCountry?: string;
+    allCountries?: boolean;
+};
+export type DocumentFiltering = {
+    exclude?: DocumentSelection[];
+    include?: DocumentSelection[];
+    extend?: GenericDocument[];
+};
+export type NfcPolicy = 'Disabled' | 'Optional' | 'Required';
+export type DocumentOptions = {
+    documentFiltering?: DocumentFiltering;
+    nfcPolicy?: NfcPolicy;
+};
+export type DocumentStep = Step<StepNames.Document, DocumentOptions>;
+export declare const defaultDocumentOptions: {};
+export declare const Document: (options?: Partial<DocumentOptions>, key?: string) => DocumentStep;

package/types/capture-api/steps/Document.js

@@ -0,0 +1,21 @@
+import { StepNames } from './Step.js';
+export var DocumentType;
+(function (DocumentType) {
+    DocumentType["DrivingLicence"] = "driving_licence";
+    DocumentType["GenericDocument"] = "generic_document";
+    DocumentType["NationalIdentityCard"] = "national_identity_card";
+    DocumentType["Passport"] = "passport";
+    DocumentType["PassportCard"] = "passport_card";
+    DocumentType["ResidencePermit"] = "residence_permit";
+})(DocumentType || (DocumentType = {}));
+export const defaultDocumentOptions = {};
+export const Document = (options, key = StepNames.Document) => {
+    return {
+        type: StepNames.Document,
+        options: {
+            ...defaultDocumentOptions,
+            ...options,
+        },
+        key,
+    };
+};

package/types/capture-api/steps/Face.d.ts

@@ -0,0 +1,23 @@
+import type { Step } from './Step.js';
+import { StepNames } from './Step.js';
+export type FacePhotoOptions = {
+    showIntro?: boolean;
+};
+export declare const defaultFacePhotoOptions: FacePhotoOptions;
+export type FacePhotoStep = Step<StepNames.FacePhoto, FacePhotoOptions>;
+export type FaceVideoOptions = {
+    showIntro?: boolean;
+    recordAudio?: boolean;
+    showConfirmation?: boolean;
+};
+export declare const defaultFaceVideoOptions: FaceVideoOptions;
+export declare const FacePhoto: (options?: Partial<FacePhotoOptions>, key?: string) => FacePhotoStep;
+export type FaceVideoStep = Step<StepNames.FaceVideo, FaceVideoOptions>;
+export type FaceMotionOptions = {
+    showIntro?: boolean;
+    recordAudio?: boolean;
+};
+export declare const defaultFaceMotionOptions: FaceMotionOptions;
+export declare const FaceVideo: (options?: Partial<FaceVideoOptions>, key?: string) => FaceVideoStep;
+export type FaceMotionStep = Step<StepNames.FaceMotion, FaceMotionOptions>;
+export declare const FaceMotion: (options?: Partial<FaceMotionOptions>, key?: string) => FaceMotionStep;

package/types/capture-api/steps/Face.js

@@ -0,0 +1,37 @@
+import { StepNames } from './Step.js';
+export const defaultFacePhotoOptions = {
+    showIntro: true,
+};
+export const defaultFaceVideoOptions = {
+    showIntro: true,
+    recordAudio: false,
+    showConfirmation: true,
+};
+export const FacePhoto = (options, key = StepNames.FacePhoto) => ({
+    type: StepNames.FacePhoto,
+    key,
+    options: {
+        ...defaultFacePhotoOptions,
+        ...options,
+    },
+});
+export const defaultFaceMotionOptions = {
+    showIntro: true,
+    recordAudio: false,
+};
+export const FaceVideo = (options, key = StepNames.FaceVideo) => ({
+    type: StepNames.FaceVideo,
+    key,
+    options: {
+        ...defaultFaceVideoOptions,
+        ...options,
+    },
+});
+export const FaceMotion = (options, key = StepNames.FaceMotion) => ({
+    type: StepNames.FaceMotion,
+    key: key,
+    options: {
+        ...defaultFaceMotionOptions,
+        ...options,
+    },
+});

package/types/capture-api/steps/ProofOfAddress.d.ts

@@ -0,0 +1,35 @@
+import type { Step } from './Step.js';
+import { StepNames } from './Step.js';
+export type ProofOfAddressStep = Step<StepNames.ProofOfAddress, ProofOfAddressOptions>;
+export declare enum ProofOfAddressType {
+    AccommodationTenancyCertificate = "accommodation_tenancy_certificate",
+    AddressCertificate = "address_certificate",
+    BankBuildingSocietyStatement = "bank_building_society_statement",
+    BankStatement = "bank_statement",
+    BenefitLetters = "benefit_letters",
+    CouncilTax = "council_tax",
+    ElectricityBill = "electricity_bill",
+    ExchangeHouseStatement = "exchange_house_statement",
+    GasBill = "gas_bill",
+    GeneralLetter = "general_letter",
+    IdentityDocumentWithAddress = "identity_document_with_address",
+    InsuranceStatement = "insurance_statement",
+    InternetBill = "internet_bill",
+    MobilePhoneBill = "mobile_phone_bill",
+    MortgageStatement = "mortgage_statement",
+    PensionPropertyStatementLetter = "pension_property_statement_letter",
+    PhoneBill = "phone_bill",
+    UtilityBill = "utility_bill",
+    WaterBill = "water_bill"
+}
+export type ProofOfAddressSelection = {
+    proofOfAddressType: ProofOfAddressType;
+    issuingCountry?: string;
+};
+export type ProofOfAddressFiltering = {
+    include?: ProofOfAddressSelection[];
+};
+export type ProofOfAddressOptions = {
+    proofOfAddressFiltering?: ProofOfAddressFiltering;
+};
+export declare const ProofOfAddress: (key?: string) => ProofOfAddressStep;

package/types/capture-api/steps/ProofOfAddress.js

@@ -0,0 +1,30 @@
+import { StepNames } from './Step.js';
+export var ProofOfAddressType;
+(function (ProofOfAddressType) {
+    ProofOfAddressType["AccommodationTenancyCertificate"] = "accommodation_tenancy_certificate";
+    ProofOfAddressType["AddressCertificate"] = "address_certificate";
+    ProofOfAddressType["BankBuildingSocietyStatement"] = "bank_building_society_statement";
+    ProofOfAddressType["BankStatement"] = "bank_statement";
+    ProofOfAddressType["BenefitLetters"] = "benefit_letters";
+    ProofOfAddressType["CouncilTax"] = "council_tax";
+    ProofOfAddressType["ElectricityBill"] = "electricity_bill";
+    ProofOfAddressType["ExchangeHouseStatement"] = "exchange_house_statement";
+    ProofOfAddressType["GasBill"] = "gas_bill";
+    ProofOfAddressType["GeneralLetter"] = "general_letter";
+    ProofOfAddressType["IdentityDocumentWithAddress"] = "identity_document_with_address";
+    ProofOfAddressType["InsuranceStatement"] = "insurance_statement";
+    ProofOfAddressType["InternetBill"] = "internet_bill";
+    ProofOfAddressType["MobilePhoneBill"] = "mobile_phone_bill";
+    ProofOfAddressType["MortgageStatement"] = "mortgage_statement";
+    ProofOfAddressType["PensionPropertyStatementLetter"] = "pension_property_statement_letter";
+    ProofOfAddressType["PhoneBill"] = "phone_bill";
+    ProofOfAddressType["UtilityBill"] = "utility_bill";
+    ProofOfAddressType["WaterBill"] = "water_bill";
+})(ProofOfAddressType || (ProofOfAddressType = {}));
+export const ProofOfAddress = (key = StepNames.ProofOfAddress) => {
+    return {
+        type: StepNames.ProofOfAddress,
+        key,
+        options: {},
+    };
+};

package/types/capture-api/steps/Step.d.ts

@@ -0,0 +1,15 @@
+export type EmptyOptions = Record<string, never>;
+export type Step<key extends StepNames, options extends Record<string, unknown>> = {
+    key?: string;
+    type: key;
+    options?: options;
+};
+export declare enum StepNames {
+    Welcome = "welcome",
+    FacePhoto = "facePhoto",
+    FaceVideo = "faceVideo",
+    FaceMotion = "faceMotion",
+    Document = "document",
+    ProofOfAddress = "proofOfAddress",
+    Complete = "complete"
+}

package/types/capture-api/steps/Step.js

@@ -0,0 +1,10 @@
+export var StepNames;
+(function (StepNames) {
+    StepNames["Welcome"] = "welcome";
+    StepNames["FacePhoto"] = "facePhoto";
+    StepNames["FaceVideo"] = "faceVideo";
+    StepNames["FaceMotion"] = "faceMotion";
+    StepNames["Document"] = "document";
+    StepNames["ProofOfAddress"] = "proofOfAddress";
+    StepNames["Complete"] = "complete";
+})(StepNames || (StepNames = {}));

package/types/capture-api/steps/Welcome.d.ts

@@ -0,0 +1,4 @@
+import type { EmptyOptions, Step } from './Step.js';
+import { StepNames } from './Step.js';
+export type WelcomeStep = Step<StepNames.Welcome, EmptyOptions>;
+export declare const Welcome: () => WelcomeStep;

package/types/capture-api/steps/Welcome.js

@@ -0,0 +1,6 @@
+import { StepNames } from './Step.js';
+export const Welcome = () => ({
+    type: StepNames.Welcome,
+    key: 'welcome',
+    options: {},
+});

package/types/capture-api/steps/index.d.ts

@@ -0,0 +1,6 @@
+import type { WelcomeStep } from './Welcome.js';
+import type { DocumentStep } from './Document.js';
+import type { FaceMotionStep, FacePhotoStep, FaceVideoStep } from './Face.js';
+import type { ProofOfAddressStep } from './ProofOfAddress.js';
+import type { CompleteStep } from './Complete.js';
+export type KnownStep = WelcomeStep | DocumentStep | FacePhotoStep | FaceVideoStep | FaceMotionStep | ProofOfAddressStep | CompleteStep;

package/types/capture-api/steps/index.js

@@ -0,0 +1 @@
+export {};

package/types/capture-api/theming/Branding.d.ts

@@ -0,0 +1,8 @@
+export type Branding = {
+    text?: string;
+    logo?: string;
+    /**
+     * @deprecated Internal type only
+     */
+    legacy?: boolean;
+};

package/types/capture-api/theming/Branding.js

@@ -0,0 +1 @@
+export {};

package/types/capture-api/theming/ColorTokens.d.ts

@@ -0,0 +1,3 @@
+export type ColorTokensKeys = 'backgroundColorOverlay' | 'backgroundColorBrandActive' | 'backgroundColorBrandDefault' | 'backgroundColorBrandHover' | 'backgroundColorDisabledDefault' | 'backgroundColorInfoSubtleDefault' | 'backgroundColorInputDefault' | 'backgroundColorNegativeBaseDefault' | 'backgroundColorNegativeSubtleDefault' | 'backgroundColorNeutralSubtleDefault' | 'backgroundColorPositiveSubtleDefault' | 'backgroundColorSurfacePrimaryActive' | 'backgroundColorSurfacePrimaryDefault' | 'backgroundColorSurfacePrimaryHover' | 'backgroundColorTintedActive' | 'backgroundColorTintedDefault' | 'backgroundColorTintedHover' | 'backgroundColorWarningSubtleDefault' | 'borderColorDisabledDefault' | 'borderColorInputActive' | 'borderColorInputDefault' | 'borderColorInputHover' | 'borderColorNegativeBaseDefault' | 'borderColorSeparator' | 'contentColorBase' | 'contentColorBrandOnBrand' | 'contentColorDisabledDefault' | 'contentColorInfoBaseDefault' | 'contentColorNegativeBaseDefault' | 'contentColorNegativeOnNegative' | 'contentColorPlaceholder' | 'contentColorPositiveBaseDefault' | 'contentColorSubtle' | 'contentColorWarningBaseDefault';
+export type SdkColor = string;
+export type SdkColors = Record<ColorTokensKeys, SdkColor>;

package/types/capture-api/theming/ColorTokens.js

@@ -0,0 +1 @@
+export {};

package/types/capture-api/theming/MediaResources.d.ts

@@ -0,0 +1,34 @@
+export declare enum ResourceType {
+    Icons = "icons",
+    Images = "images",
+    Animations = "animations",
+    Videos = "videos"
+}
+export declare enum IconTokens {
+    NavigationBack = "Navigation.Back",
+    NavigationExit = "Navigation.Close"
+}
+export declare enum ImageTokens {
+}
+export declare enum VideoTokens {
+}
+export declare enum AnimationTokens {
+}
+export declare enum MediaLocationType {
+    Local = "local",
+    Remote = "remote"
+}
+export type MediaLocation = {
+    type: MediaLocationType;
+    uri: string;
+};
+export type Media = {
+    location: MediaLocation;
+    contentDescription?: string;
+};
+export type MediaResources = {
+    [ResourceType.Icons]?: Record<IconTokens, Media>;
+    [ResourceType.Images]?: Record<ImageTokens, Media>;
+    [ResourceType.Animations]?: Record<AnimationTokens, Media>;
+    [ResourceType.Videos]?: Record<VideoTokens, Media>;
+};