react-native-scanbot-sdk/src/credit_card/CreditCardTypes.ts

Scanbot Document and Barcode Scanner SDK React Native Plugin for Android and iOS

/// Auto-generated with ScanbotSDKCodegenV3. Modifications will be overwritten.
/// Generated from core/schemas/CreditCardTypes.yaml

import { DocumentDetectionStatus } from '../document_scanner/DocumentScannerTypes';
import { GenericDocument } from '../documents/GenericDocument';
import { ResultAccumulationConfiguration } from '../frame_accumulation/FrameAccumulationTypes';
import { ToJsonConfiguration } from '../utils/json/JsonSerializationTypes';
import { DeepPartial, PartiallyConstructible, Point } from '../utils/utils';

/**
The status of the scanning process.

- `SUCCESS`:
   The credit card was scanned successfully.
- `ERROR_NOTHING_FOUND`:
   No credit card was detected.
- `INCOMPLETE`:
   Not all required fields were found or confirmed.
*/
export type CreditCardScanningStatus = 'SUCCESS' | 'ERROR_NOTHING_FOUND' | 'INCOMPLETE';

export const CreditCardScanningStatusValues: CreditCardScanningStatus[] = [
  'SUCCESS',
  'ERROR_NOTHING_FOUND',
  'INCOMPLETE',
];

/**
Contains the result of running the credit card scanner.
*/
export class CreditCardScanningResult extends PartiallyConstructible {
  /**
    The status of the credit card detection step.
    */
  public readonly detectionStatus: DocumentDetectionStatus;
  /**
    The status of the credit card scanning step.
    */
  public readonly scanningStatus: CreditCardScanningStatus;
  /**
    Generic document containing credit card data. Not present, if status is FAIL.
    */
  public readonly creditCard: GenericDocument | null;
  /**
    Coordinates of the detected credit card in the input image (clockwise from top-left).
    */
  public readonly quad: Point[];
  /**
    Coordinates of the detected credit card in the input image (clockwise from top-left), normalized to the range [0, 1].
    */
  public readonly quadNormalized: Point[];

  /** @param source {@displayType `DeepPartial<CreditCardScanningResult>`} */
  public constructor(source: DeepPartial<CreditCardScanningResult> = {}) {
    super();
    if (source.detectionStatus !== undefined) {
      this.detectionStatus = source.detectionStatus;
    } else {
      throw new Error('detectionStatus must be present in constructor argument');
    }
    if (source.scanningStatus !== undefined) {
      this.scanningStatus = source.scanningStatus;
    } else {
      throw new Error('scanningStatus must be present in constructor argument');
    }
    if (source.creditCard !== undefined) {
      this.creditCard = source.creditCard != null ? new GenericDocument(source.creditCard) : null;
    } else {
      throw new Error('creditCard must be present in constructor argument');
    }
    if (source.quad !== undefined) {
      this.quad = source.quad.map((it: any) => {
        return { x: it.x, y: it.y };
      });
    } else {
      throw new Error('quad must be present in constructor argument');
    }
    if (source.quadNormalized !== undefined) {
      this.quadNormalized = source.quadNormalized.map((it: any) => {
        return { x: it.x, y: it.y };
      });
    } else {
      throw new Error('quadNormalized must be present in constructor argument');
    }
  }

  public async serialize(
    config: ToJsonConfiguration = new ToJsonConfiguration()
  ): Promise<DeepPartial<CreditCardScanningResult>> {
    return {
      detectionStatus: this.detectionStatus,
      scanningStatus: this.scanningStatus,
      creditCard: this.creditCard != null ? await this.creditCard.serialize(config) : null,
      quad: this.quad.map((it: any) => {
        return it;
      }),
      quadNormalized: this.quadNormalized.map((it: any) => {
        return it;
      }),
    };
  }

  private _released: Boolean = false;

  public release() {
    if (this._released) {
      return;
    }
    {
      if (this.creditCard != null) {
        this.creditCard.release();
      }
    }
    this._released = true;
  }

  public async encodeImages(): Promise<void> {
    if (this.creditCard != null) {
      await this.creditCard.encodeImages();
    }
  }
}

/**
The scanning mode.

- `LIVE`:
   The scanner will merge all information from multiple frames to provide the best possible result.
   Use this mode when the input is a video or camera stream.
- `SINGLE_SHOT`:
   The scanner will only use the current frame and will spend additional time to ensure the best possible result. Use this mode when scanning single images, e.g. imported from the gallery.
*/
export type CreditCardScanningMode = 'LIVE' | 'SINGLE_SHOT';

export const CreditCardScanningModeValues: CreditCardScanningMode[] = ['LIVE', 'SINGLE_SHOT'];

/**
Configuration for the credit card scanner.
*/
export class CreditCardScannerConfiguration extends PartiallyConstructible {
  /**
    If true, the document detector will be used to find where the credit card is in the input image.
    If false, the scanner will assume that the credit card has been pre-cropped and takes the entirety of the input image.
    
    Default is true
    */
  public useDocumentDetector: boolean = true;
  /**
    The scanning mode.
    
    Default is LIVE
    */
  public scanningMode: CreditCardScanningMode = 'LIVE';
  /**
    Whether the expiry date is required for a successful scan.
    
    Default is true
    */
  public requireExpiryDate: boolean = true;
  /**
    Whether the cardholder name is required for a successful scan.
    
    Default is true
    */
  public requireCardholderName: boolean = true;
  /**
    Configuration for how to accumulate results.
    */
  public resultAccumulationConfig: ResultAccumulationConfiguration =
    new ResultAccumulationConfiguration({});
  /**
    If true, the credit card image will be returned in creditCard field of CreditCardScanningResult.
    
    Default is false
    */
  public returnCreditCardImage: boolean = false;

  /** @param source {@displayType `DeepPartial<CreditCardScannerConfiguration>`} */
  public constructor(source: DeepPartial<CreditCardScannerConfiguration> = {}) {
    super();
    if (source.useDocumentDetector !== undefined) {
      this.useDocumentDetector = source.useDocumentDetector;
    }
    if (source.scanningMode !== undefined) {
      this.scanningMode = source.scanningMode;
    }
    if (source.requireExpiryDate !== undefined) {
      this.requireExpiryDate = source.requireExpiryDate;
    }
    if (source.requireCardholderName !== undefined) {
      this.requireCardholderName = source.requireCardholderName;
    }
    if (source.resultAccumulationConfig !== undefined) {
      this.resultAccumulationConfig = new ResultAccumulationConfiguration(
        source.resultAccumulationConfig
      );
    }
    if (source.returnCreditCardImage !== undefined) {
      this.returnCreditCardImage = source.returnCreditCardImage;
    }
  }
}