IDV Module

const sdk = await OneSdk({
  mode: 'production',
  session: { token: 'your-token' }
});

// Create IDV flow instance
const idvFlow = sdk.flow('idv', options);

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'onfido'
  }
});

documents: [
  {
    type: 'DRIVERS_LICENCE',     // Document type
    countries: ['AUS', 'NZL']    // ISO country codes (optional)
  }
]

checkProcessingPool: {
  enabled: true,      // Enable polling for check results
  wait_time: 5,       // Wait time between polls (seconds)
  max_attempts: 1     // Maximum polling attempts
}

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'onfido',
    sdkVersion: '13.0.0',          // Onfido SDK version
    theme: 'light',                 // 'light' or 'dark'
    language: 'en_GB',              // UI language (optional)
    translations: {                 // Custom translation strings (optional)
      // See Onfido documentation for translation keys
    },
    maxDocumentCount: 3,            // Maximum documents to capture
    product: 'idv',                 // Product type
    biometricsVariant: 'standard',  // 'standard', 'video', or 'motion'
    useOneStep: false,              // Enable one-step capture
    showExitButton: true,           // Show exit button in UI
    fallback: 'standard',           // Fallback method: 'standard' or 'video'
    crossDevicePolicy: 'disable',   // Cross-device flow: 'force' or 'disable'
    customUI: {                     // Custom UI configuration
      // See Onfido documentation for customUI options
    }
  }
});

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'incode',
    product: 'idv',
    lang: 'en'  // Language code
  }
});

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'sumsub',
    product: 'idv',  // or 'poa' for proof of address
    config: {
      theme: 'light',  // 'light' or 'dark'
      lang: 'en',      // Language code (optional)
      email: 'user@example.com',  // Pre-fill email (optional)
      phone: '+1234567890'        // Pre-fill phone (optional)
    },
    options: {
      addViewportTag: true,      // Add viewport meta tag
      adaptIframeHeight: true    // Auto-adjust iframe height
    }
  }
});

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'truuth',
    sdkVersion: '1.0.0'  // Optional SDK version
  }
});

const idvFlow = sdk.flow('idv', {
  provider: {
    name: 'daon',
    products: ['IdentityX', 'VeriFLY'],  // Daon products to use
    processInstanceParameters: [
      {
        name: 'param1',
        mandatory: true,
        default: 'value'
      }
    ]
  }
});

mount(domElementOrSelector: string | HTMLElement): void

// Mount to element by ID
idvFlow.mount('#idv-container');

// Mount to element reference
const container = document.getElementById('idv-container');
idvFlow.mount(container);

unmount(): void

idvFlow.unmount();

isPreloaded(): boolean

const idvFlow = sdk.flow('idv', {
  provider: { name: 'onfido' }
});

if (idvFlow.isPreloaded()) {
  console.log('User has completed IDV verification');
  // Skip verification, proceed to next step
  proceedToNextStep();
} else {
  console.log('User needs to complete IDV verification');
  // Mount and start verification
  idvFlow.mount('#idv-container');
}

access(fieldName: string): Accessor

const idvFlow = sdk.flow('idv', { provider: { name: 'onfido' } });

idvFlow.on('input_required', (info, status) => {
  if (status === idvFlow.statuses.WAITING_DOC_UPLOAD) {
    console.log('Waiting for document upload');
  } else if (status === idvFlow.statuses.WAITING_SELFIE_UPLOAD) {
    console.log('Waiting for selfie upload');
  }
});

idvFlow.on('results', (results) => {
  if (results.checkStatus === idvFlow.statuses.COMPLETE) {
    console.log('Verification completed successfully');
  } else if (results.checkStatus === idvFlow.statuses.FAILED) {
    console.log('Verification failed');
  }
});

{
  session: {
    entityId: string | null;
    vendorParameters: object;
  }
}

idvFlow.on('session_data_generated', ({ session }) => {
  console.log('Session created for entity:', session.entityId);
  console.log('Vendor parameters:', session.vendorParameters);
});

idvFlow.on('detection_complete', () => {
  console.log('Document and biometric capture complete');
  showProcessingMessage();
});

{
  message: string;
  payload?: Record<string, unknown>;
}

idvFlow.on('detection_failed', ({ message, payload }) => {
  console.error('Detection failed:', message);
  console.error('Details:', payload);
  showErrorMessage(message);
});

(
  info: { entityId: string | null },
  status: IDVStatus
)

idvFlow.on('input_required', ({ entityId }, status) => {
  console.log('Input required. Status:', status);
  console.log('User can retry to continue verification');

  if (status === idvFlow.statuses.WAITING_DOC_UPLOAD) {
    showMessage('Please upload your document to continue');
    enableRetry();
  } else if (status === idvFlow.statuses.WAITING_SELFIE_UPLOAD) {
    showMessage('Please capture your selfie to continue');
    enableRetry();
  } else if (status === idvFlow.statuses.AWAITING_CONSENT) {
    showMessage('Please provide consent to continue');
    enableRetry();
  }
});

{
  checkStatus: IDVStatus;
  entityId: string | null;
  [key: string]: any;
}

idvFlow.on('processing', (status) => {
  console.log('Processing verification. Status:', status.checkStatus);
  showLoadingSpinner();
});

{
  checkStatus: IDVStatus;
  entityId: string | null;
  [key: string]: any;
}

idvFlow.on('results', (results) => {
  console.log('Verification results received');
  console.log('Status:', results.checkStatus);
  console.log('Entity ID:', results.entityId);

  if (results.checkStatus === idvFlow.statuses.COMPLETE) {
    navigateToSuccess();
  } else if (results.checkStatus === idvFlow.statuses.FAILED) {
    showFailureScreen(results);
  }
});

// Onfido-specific event
idvFlow.on('session_interrupted', () => {
  console.log('User interrupted the verification (Onfido)');
  saveProgress();
});

idvFlow.on('session_closed', () => {
  console.log('Verification session closed');
  idvFlow.unmount();
});

idvFlow.on('session_data_failed_loading', () => {
  console.error('Failed to load session data');
  showErrorMessage('Unable to start verification. Please try again.');
});

{
  [key: string]: any;  // Provider-specific event data
}

idvFlow.on('vendor_event', (event) => {
  console.log('Provider event:', event);
  // Handle provider-specific events
});

import OneSdk from '@frankieone/one-sdk';

async function performIDV() {
  try {
    // Initialize SDK
    const sdk = await OneSdk({
      mode: 'production',
      session: { token: await getSessionToken() }
    });

    // Create IDV component with Onfido provider
    const idvFlow = sdk.flow('idv', {
      provider: {
        name: 'onfido',
        theme: 'light',
        product: 'idv',
        biometricsVariant: 'standard',
        showExitButton: true
      }
    });

    // Check if user has already completed IDV
    if (idvFlow.isPreloaded()) {
      console.log('User has existing IDV verification data');
      // Skip verification for returning user
      return navigateToNextStep();
    }

    // Set up event listeners
    idvFlow.on('session_data_generated', ({ session }) => {
      console.log('IDV session started for:', session.entityId);
    });

    idvFlow.on('detection_complete', () => {
      console.log('Capture complete, processing...');
      showMessage('Processing your verification...');
    });

    idvFlow.on('detection_failed', ({ message }) => {
      console.error('Capture failed:', message);
      showError(message);
    });

    idvFlow.on('processing', (status) => {
      console.log('Verification processing:', status.checkStatus);
    });

    idvFlow.on('results', (results) => {
      console.log('Verification complete');

      if (results.checkStatus === idvFlow.statuses.COMPLETE) {
        console.log('✓ Verification passed');
        navigateToSuccess();
      } else if (results.checkStatus === idvFlow.statuses.FAILED) {
        console.log('✗ Verification failed');
        showFailureScreen();
      } else {
        console.log('Status:', results.checkStatus);
        handleOtherStatus(results);
      }
    });

    idvFlow.on('session_interrupted', () => {
      console.log('User closed verification');
      saveProgress();
    });

    idvFlow.on('error', (error) => {
      console.error('IDV error:', error);
      showError('Verification error. Please try again.');
    });

    // Mount and start verification
    idvFlow.mount('#idv-container');

  } catch (error) {
    console.error('IDV initialization failed:', error);
    throw error;
  }
}

#idv-container {
  width: 100%;
  min-height: 600px;
}