react-native-scanbot-sdk/src/check/CheckScannerTypes.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/CheckScannerTypes.yaml

import { DocumentDetectionResult } from '../document_scanner/DocumentScannerTypes';
import { GenericDocument } from '../documents/GenericDocument';
import { ImageRef } from '../imageRef/image';
import { ToJsonConfiguration } from '../utils/json/JsonSerializationTypes';
import { DeepPartial, PartiallyConstructible } from '../utils/utils';

/**
Check document detection and extraction mode.

- `DISABLED`:
   Document detection is not performed. Successful check scans will only contain the machine-readable check data without a full crop of the check.
- `DETECT_DOCUMENT`:
   Document scanner will be used to locate the complete check in the input image. The documentDetectionResult result field will contain the result of document detection.
- `DETECT_AND_CROP_DOCUMENT`:
   Document scanner will be used to locate the complete check in the input image. The documentDetectionResult result field will contain the result of document detection. The croppedImage result field will contain a crop of the entire check.
*/
export type CheckDocumentDetectionMode =
  | 'DISABLED'
  | 'DETECT_DOCUMENT'
  | 'DETECT_AND_CROP_DOCUMENT';

export const CheckDocumentDetectionModeValues: CheckDocumentDetectionMode[] = [
  'DISABLED',
  'DETECT_DOCUMENT',
  'DETECT_AND_CROP_DOCUMENT',
];

/**
Check magnetic ink (MICR) strip scanning status.

- `SUCCESS`:
   Scanning successful.
- `INCOMPLETE_VALIDATION`:
   Magnetic ink strip was found, but validation failed, because of a format violation, an unsupported format, or an OCR error.
- `ERROR_NOTHING_FOUND`:
   Magnetic ink strip was not found.
*/
export type CheckMagneticInkStripScanningStatus =
  | 'SUCCESS'
  | 'INCOMPLETE_VALIDATION'
  | 'ERROR_NOTHING_FOUND';

export const CheckMagneticInkStripScanningStatusValues: CheckMagneticInkStripScanningStatus[] = [
  'SUCCESS',
  'INCOMPLETE_VALIDATION',
  'ERROR_NOTHING_FOUND',
];

/**
The result of check scanning.
*/
export class CheckScanningResult extends PartiallyConstructible {
  /**
    Magnetic ink strip scanning status.
    
    Default is ERROR_NOTHING_FOUND
    */
  public readonly status: CheckMagneticInkStripScanningStatus = 'ERROR_NOTHING_FOUND';
  /**
    Generic document containing check data. Not present, if status is FAIL.
    */
  public readonly check: GenericDocument | null;
  /**
    The result of document detection. Will be set only if detectDocument in the configuration is set to true. Check scanning may still succeed even if the whole document is not visible in the input image and the complete document could not be located.
    */
  public readonly documentDetectionResult: DocumentDetectionResult | null;
  /**
    Crop of the check if documentDetectionMode is set to DETECT_AND_CROP_DOCUMENT. Will be non-empty, only if check recognition succeeded.
    */
  public readonly croppedImage: ImageRef | null = null;

  /** @param source {@displayType `DeepPartial<CheckScanningResult>`} */
  public constructor(source: DeepPartial<CheckScanningResult> = {}) {
    super();
    if (source.status !== undefined) {
      this.status = source.status;
    }
    if (source.check !== undefined) {
      this.check = source.check != null ? new GenericDocument(source.check) : null;
    } else {
      throw new Error('check must be present in constructor argument');
    }
    if (source.documentDetectionResult !== undefined) {
      this.documentDetectionResult =
        source.documentDetectionResult != null
          ? new DocumentDetectionResult(source.documentDetectionResult)
          : null;
    } else {
      throw new Error('documentDetectionResult must be present in constructor argument');
    }
    if (source.croppedImage !== undefined) {
      this.croppedImage = source.croppedImage != null ? ImageRef.From(source.croppedImage) : null;
    }
  }

  public async serialize(
    config: ToJsonConfiguration = new ToJsonConfiguration()
  ): Promise<DeepPartial<CheckScanningResult>> {
    return {
      status: this.status,
      check: this.check != null ? await this.check.serialize(config) : null,
      documentDetectionResult:
        this.documentDetectionResult != null
          ? this.documentDetectionResult.serialize(config)
          : null,
      croppedImage: config.serializeImages
        ? this.croppedImage != null
          ? await this.croppedImage.serialize(config.imageSerializationMode)
          : null
        : undefined,
    };
  }

  private _released: Boolean = false;

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

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

/**
Configuration of the check scanner.
*/
export class CheckScannerConfiguration extends PartiallyConstructible {
  /**
    Document detection to be performed in addition to scanning the machine-readable data in the check.
    
    By default only the machine-readable data is extracted during check scanning. Optionally, the coordinates and a crop of the entire check document can be returned, in addition to the check data.
    A check scan result may still be successful even if the whole document is not visible in the input image and the complete document could not be located.
    
    Default is DISABLED
    */
  public documentDetectionMode: CheckDocumentDetectionMode = 'DISABLED';

  /** @param source {@displayType `DeepPartial<CheckScannerConfiguration>`} */
  public constructor(source: DeepPartial<CheckScannerConfiguration> = {}) {
    super();
    if (source.documentDetectionMode !== undefined) {
      this.documentDetectionMode = source.documentDetectionMode;
    }
  }

  public serialize(
    config: ToJsonConfiguration = new ToJsonConfiguration()
  ): DeepPartial<CheckScannerConfiguration> {
    return {
      documentDetectionMode: this.documentDetectionMode,
    };
  }
}