react-native-scanbot-barcode-scanner-sdk 7.1.2-rc.2 → 8.0.0-rc.1

package/src/types/core/barcode/BarcodeDocumentTypes.ts

@@ -0,0 +1,218 @@
+/// Auto-generated with ScanbotSDKCodegenV3. Modifications will be overwritten.
+/// Generated from core/schemas/BarcodeDocumentTypes.yaml
+
+import { ToJsonConfiguration } from '../common/JsonSerializationTypes';
+import { GenericDocument } from '../generic_document/GenericDocument';
+import { DeepPartial } from '../utils/utils';
+import { BarcodeFormat } from './BarcodeTypes';
+
+/**
+Type of barcode document format used.
+
+- `AAMVA`:
+   American Association of Motor Vehicle Administrators barcode document.
+- `BOARDING_PASS`:
+   Boarding pass barcode document.
+- `DE_MEDICAL_PLAN`:
+   German medication plan barcode document.
+- `MEDICAL_CERTIFICATE`:
+   German medical certificate barcode document.
+- `ID_CARD_PDF_417`:
+   ID card barcode document.
+- `SEPA`:
+   SEPA barcode (aka GiroCode) document.
+- `SWISS_QR`:
+   Swiss QR barcode document.
+- `VCARD`:
+   VCard barcode document.
+- `GS1`:
+   GS1 barcode document.
+- `HIBC`:
+   Health industry barcode document.
+- `BRITISH_COLUMBIA_DRIVER_LICENSE`:
+   British Columbia driver license barcode document.
+*/
+export type BarcodeDocumentFormat =
+  /**
+    American Association of Motor Vehicle Administrators barcode document.
+    */
+  | 'AAMVA'
+  /**
+    Boarding pass barcode document.
+    */
+  | 'BOARDING_PASS'
+  /**
+    German medication plan barcode document.
+    */
+  | 'DE_MEDICAL_PLAN'
+  /**
+    German medical certificate barcode document.
+    */
+  | 'MEDICAL_CERTIFICATE'
+  /**
+    ID card barcode document.
+    */
+  | 'ID_CARD_PDF_417'
+  /**
+    SEPA barcode (aka GiroCode) document.
+    */
+  | 'SEPA'
+  /**
+    Swiss QR barcode document.
+    */
+  | 'SWISS_QR'
+  /**
+    VCard barcode document.
+    */
+  | 'VCARD'
+  /**
+    GS1 barcode document.
+    */
+  | 'GS1'
+  /**
+    Health industry barcode document.
+    */
+  | 'HIBC'
+  /**
+    British Columbia driver license barcode document.
+    */
+  | 'BRITISH_COLUMBIA_DRIVER_LICENSE';
+
+/** @hidden */
+export const BarcodeDocumentFormatValues: ReadonlyArray<BarcodeDocumentFormat> = [
+  'AAMVA',
+  'BOARDING_PASS',
+  'DE_MEDICAL_PLAN',
+  'MEDICAL_CERTIFICATE',
+  'ID_CARD_PDF_417',
+  'SEPA',
+  'SWISS_QR',
+  'VCARD',
+  'GS1',
+  'HIBC',
+  'BRITISH_COLUMBIA_DRIVER_LICENSE',
+] as const;
+
+/**
+Barcode document formats.
+*/
+export class BarcodeDocumentFormats {
+  /** @param source {@displayType `DeepPartial<BarcodeDocumentFormats>`} */
+  public constructor(source: DeepPartial<BarcodeDocumentFormats> = {}) {}
+
+  public serialize(
+    config: ToJsonConfiguration = new ToJsonConfiguration()
+  ): DeepPartial<BarcodeDocumentFormats> {
+    return {};
+  }
+}
+
+export namespace BarcodeDocumentFormats {
+  /**
+    All barcode document formats.
+    */
+  export const all: BarcodeDocumentFormat[] = [
+    'AAMVA',
+    'BOARDING_PASS',
+    'DE_MEDICAL_PLAN',
+    'MEDICAL_CERTIFICATE',
+    'ID_CARD_PDF_417',
+    'SEPA',
+    'SWISS_QR',
+    'VCARD',
+    'GS1',
+    'HIBC',
+    'BRITISH_COLUMBIA_DRIVER_LICENSE',
+  ];
+  /**
+    Barcode types that are used to encode documents.
+    */
+  export const documentBarcodeFormats: { [key in BarcodeDocumentFormat]: BarcodeFormat[] } = {
+    AAMVA: ['PDF_417'],
+    ID_CARD_PDF_417: ['PDF_417'],
+    SEPA: ['QR_CODE'],
+    MEDICAL_CERTIFICATE: ['PDF_417'],
+    DE_MEDICAL_PLAN: ['DATA_MATRIX'],
+    BOARDING_PASS: ['PDF_417', 'AZTEC', 'QR_CODE'],
+    VCARD: ['QR_CODE', 'DATA_MATRIX'],
+    SWISS_QR: ['QR_CODE'],
+    GS1: [
+      'CODE_128',
+      'AZTEC',
+      'DATA_MATRIX',
+      'DATABAR',
+      'DATABAR_EXPANDED',
+      'DATABAR_LIMITED',
+      'EAN_13',
+      'EAN_8',
+      'GS1_COMPOSITE',
+      'ITF',
+      'MICRO_PDF_417',
+      'PDF_417',
+      'QR_CODE',
+      'UPC_A',
+      'UPC_E',
+    ],
+    HIBC: ['CODE_39', 'CODE_128', 'AZTEC', 'DATA_MATRIX', 'MICRO_PDF_417', 'PDF_417', 'QR_CODE'],
+    BRITISH_COLUMBIA_DRIVER_LICENSE: ['PDF_417'],
+  };
+}
+
+/**
+The result of barcode document parsing.
+*/
+export class BarcodeDocumentParserResult {
+  /**
+    True if any document was parsed.
+    */
+  public readonly success: boolean;
+  /**
+    In case of success, the parsed document.
+    */
+  public readonly parsedDocument: GenericDocument | null;
+
+  /** @param source {@displayType `DeepPartial<BarcodeDocumentParserResult>`} */
+  public constructor(source: DeepPartial<BarcodeDocumentParserResult> = {}) {
+    if (source.success !== undefined) {
+      this.success = source.success;
+    } else {
+      throw new Error('success must be present in constructor argument');
+    }
+    if (source.parsedDocument !== undefined) {
+      this.parsedDocument =
+        source.parsedDocument != null ? new GenericDocument(source.parsedDocument) : null;
+    } else {
+      throw new Error('parsedDocument must be present in constructor argument');
+    }
+  }
+
+  public async serialize(
+    config: ToJsonConfiguration = new ToJsonConfiguration()
+  ): Promise<DeepPartial<BarcodeDocumentParserResult>> {
+    return {
+      success: this.success,
+      parsedDocument:
+        this.parsedDocument != null ? await this.parsedDocument.serialize(config) : null,
+    };
+  }
+
+  private _released: Boolean = false;
+
+  public release() {
+    if (this._released) {
+      return;
+    }
+    {
+      if (this.parsedDocument != null) {
+        this.parsedDocument.release();
+      }
+    }
+    this._released = true;
+  }
+
+  public async encodeImages(): Promise<void> {
+    if (this.parsedDocument != null) {
+      await this.parsedDocument.encodeImages();
+    }
+  }
+}

package/src/{barcode → types/core/barcode}/BarcodeScannerTypes.ts

@@ -1,21 +1,29 @@
 /// Auto-generated with ScanbotSDKCodegenV3. Modifications will be overwritten.
 /// Generated from core/schemas/BarcodeScannerTypes.yaml
 
+import { ProcessingMode } from '../common/CommonTypes';
+import { ToJsonConfiguration } from '../common/JsonSerializationTypes';
+import { GenericDocument } from '../generic_document/GenericDocument';
+import { ImageRef } from '../image/image';
+import type { Point } from '../utils/utils';
+import { DeepPartial } from '../utils/utils';
 import {
   BarcodeFormatCommonConfiguration,
   BarcodeFormatConfigurationBase,
-} from '../barcode/BarcodeConfigurationTypes';
-import { BarcodeDocumentFormat } from '../barcode/BarcodeDocumentTypes';
-import { BarcodeFormat, RangeEncoding, StructuredAppendInfo } from '../barcode/BarcodeTypes';
-import { GenericDocument } from '../documents/GenericDocument';
-import { ImageRef } from '../imageRef/image';
-import { ToJsonConfiguration } from '../utils/json/JsonSerializationTypes';
-import { DeepPartial, PartiallyConstructible, Point } from '../utils/utils';
+} from './BarcodeConfigurationTypes';
+import { BarcodeDocumentFormat } from './BarcodeDocumentTypes';
+import { BarcodeFormat, RangeEncoding, StructuredAppendInfo } from './BarcodeTypes';
 
 /**
 A single barcode found in the input image. Barcodes with the same content but different locations in the image are considered separate barcodes.
 */
-export class BarcodeItem extends PartiallyConstructible {
+export class BarcodeItem {
+  /**
+    Barcode format.
+    
+    Default is NONE
+    */
+  public readonly format: BarcodeFormat = 'NONE';
   /**
     Text contained in the barcode. Binary data is returned in the rawBytes field only.
     */
@@ -38,12 +46,6 @@ export class BarcodeItem extends PartiallyConstructible {
     If this barcode is part of a structured append sequence, this field contains information about the sequence.
     */
   public readonly structuredAppendInfo: StructuredAppendInfo | null;
-  /**
-    Barcode format.
-    
-    Default is NONE
-    */
-  public readonly format: BarcodeFormat = 'NONE';
   /**
     The four corners of the barcode in the input image, in clockwise order starting from the top left, in image coordinates.
     */
@@ -116,7 +118,9 @@ export class BarcodeItem extends PartiallyConstructible {
 
   /** @param source {@displayType `DeepPartial<BarcodeItem>`} */
   public constructor(source: DeepPartial<BarcodeItem> = {}) {
-    super();
+    if (source.format !== undefined) {
+      this.format = source.format;
+    }
     if (source.text !== undefined) {
       this.text = source.text;
     } else {
@@ -128,7 +132,7 @@ export class BarcodeItem extends PartiallyConstructible {
       throw new Error('rawBytes must be present in constructor argument');
     }
     if (source.rawBytesEncodings !== undefined) {
-      this.rawBytesEncodings = source.rawBytesEncodings.map((it: any) => {
+      this.rawBytesEncodings = source.rawBytesEncodings.map((it: DeepPartial<RangeEncoding>) => {
         return new RangeEncoding(it);
       });
     } else {
@@ -142,32 +146,29 @@ export class BarcodeItem extends PartiallyConstructible {
     } else {
       throw new Error('structuredAppendInfo must be present in constructor argument');
     }
-    if (source.format !== undefined) {
-      this.format = source.format;
-    }
     if (source.quad !== undefined) {
-      this.quad = source.quad.map((it: any) => {
+      this.quad = source.quad.map((it: DeepPartial<Point>) => {
         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) => {
+      this.quadNormalized = source.quadNormalized.map((it: DeepPartial<Point>) => {
         return { x: it.x, y: it.y };
       });
     } else {
       throw new Error('quadNormalized must be present in constructor argument');
     }
     if (source.extendedQuad !== undefined) {
-      this.extendedQuad = source.extendedQuad.map((it: any) => {
+      this.extendedQuad = source.extendedQuad.map((it: DeepPartial<Point>) => {
         return { x: it.x, y: it.y };
       });
     } else {
       throw new Error('extendedQuad must be present in constructor argument');
     }
     if (source.extendedQuadNormalized !== undefined) {
-      this.extendedQuadNormalized = source.extendedQuadNormalized.map((it: any) => {
+      this.extendedQuadNormalized = source.extendedQuadNormalized.map((it: DeepPartial<Point>) => {
         return { x: it.x, y: it.y };
       });
     } else {
@@ -177,7 +178,7 @@ export class BarcodeItem extends PartiallyConstructible {
       this.isUpsideDown = source.isUpsideDown;
     }
     if (source.sourceImage !== undefined) {
-      this.sourceImage = source.sourceImage != null ? ImageRef.From(source.sourceImage) : null;
+      this.sourceImage = source.sourceImage != null ? ImageRef.from(source.sourceImage) : null;
     }
     if (source.upcEanExtension !== undefined) {
       this.upcEanExtension = source.upcEanExtension;
@@ -211,6 +212,7 @@ export class BarcodeItem extends PartiallyConstructible {
     config: ToJsonConfiguration = new ToJsonConfiguration()
   ): Promise<DeepPartial<BarcodeItem>> {
     return {
+      format: this.format,
       text: this.text,
       rawBytes: this.rawBytes,
       rawBytesEncodings: this.rawBytesEncodings.map((it: any) => {
@@ -218,7 +220,6 @@ export class BarcodeItem extends PartiallyConstructible {
       }),
       structuredAppendInfo:
         this.structuredAppendInfo != null ? this.structuredAppendInfo.serialize(config) : null,
-      format: this.format,
       quad: this.quad.map((it: any) => {
         return it;
       }),
@@ -290,21 +291,44 @@ The engine mode for barcode scanning.
    Similar to NEXT_GEN_LOW_POWER, but optimized for scanning from far distances.
 - `NEXT_GEN_FAR_DISTANCE`:
    Similar to NEXT_GEN, but optimized for scanning from far distances.
+- `NEXT_GEN_MAX_DISTANCE`:
+   Similar to NEXT_GEN_FAR_DISTANCE, but optimized for scanning from far distances on very high power devices.
 */
 export type BarcodeScannerEngineMode =
+  /**
+    Legacy mode. Very fast, significantly less accurate. Doesn't support all barcode types.
+    */
   | 'LEGACY'
+  /**
+    A faster version of the main engine mode, for use with low-power devices.
+    */
   | 'NEXT_GEN_LOW_POWER'
+  /**
+    Main engine mode for high-power devices. Supports all barcodes types.
+    */
   | 'NEXT_GEN'
+  /**
+    Similar to NEXT_GEN_LOW_POWER, but optimized for scanning from far distances.
+    */
   | 'NEXT_GEN_LOW_POWER_FAR_DISTANCE'
-  | 'NEXT_GEN_FAR_DISTANCE';
+  /**
+    Similar to NEXT_GEN, but optimized for scanning from far distances.
+    */
+  | 'NEXT_GEN_FAR_DISTANCE'
+  /**
+    Similar to NEXT_GEN_FAR_DISTANCE, but optimized for scanning from far distances on very high power devices.
+    */
+  | 'NEXT_GEN_MAX_DISTANCE';
 
-export const BarcodeScannerEngineModeValues: BarcodeScannerEngineMode[] = [
+/** @hidden */
+export const BarcodeScannerEngineModeValues: ReadonlyArray<BarcodeScannerEngineMode> = [
   'LEGACY',
   'NEXT_GEN_LOW_POWER',
   'NEXT_GEN',
   'NEXT_GEN_LOW_POWER_FAR_DISTANCE',
   'NEXT_GEN_FAR_DISTANCE',
-];
+  'NEXT_GEN_MAX_DISTANCE',
+] as const;
 
 /**
 The method how to display barcodes from previous frames.
@@ -314,17 +338,26 @@ The method how to display barcodes from previous frames.
 - `INTERPOLATE_BY_CAMERA`:
    The quad of barcode is interpolated by the camera movement. This option is recommended when the camera is moving, but the scanned object is not.
 */
-export type BarcodeAccumulationMethod = 'LAST_VISIBLE' | 'INTERPOLATE_BY_CAMERA';
+export type BarcodeAccumulationMethod =
+  /**
+    The quad of a barcode is simply given as the last quad when it was detected.
+    */
+  | 'LAST_VISIBLE'
+  /**
+    The quad of barcode is interpolated by the camera movement. This option is recommended when the camera is moving, but the scanned object is not.
+    */
+  | 'INTERPOLATE_BY_CAMERA';
 
-export const BarcodeAccumulationMethodValues: BarcodeAccumulationMethod[] = [
+/** @hidden */
+export const BarcodeAccumulationMethodValues: ReadonlyArray<BarcodeAccumulationMethod> = [
   'LAST_VISIBLE',
   'INTERPOLATE_BY_CAMERA',
-];
+] as const;
 
 /**
 Configuration for how to accumulate results.
 */
-export class BarcodeAccumulationConfiguration extends PartiallyConstructible {
+export class BarcodeAccumulationConfiguration {
   /**
     The time in milliseconds to accumulate barcodes across multiple frames.
     
@@ -348,7 +381,6 @@ export class BarcodeAccumulationConfiguration extends PartiallyConstructible {
 
   /** @param source {@displayType `DeepPartial<BarcodeAccumulationConfiguration>`} */
   public constructor(source: DeepPartial<BarcodeAccumulationConfiguration> = {}) {
-    super();
     if (source.accumulationTime !== undefined) {
       this.accumulationTime = source.accumulationTime;
     }
@@ -364,7 +396,7 @@ export class BarcodeAccumulationConfiguration extends PartiallyConstructible {
 /**
 Configuration for the barcode scanner.
 */
-export class BarcodeScannerConfiguration extends PartiallyConstructible {
+export class BarcodeScannerConfiguration {
   /**
     Options for barcode decoding.
     */
@@ -389,6 +421,7 @@ export class BarcodeScannerConfiguration extends PartiallyConstructible {
     'VCARD',
     'GS1',
     'HIBC',
+    'BRITISH_COLUMBIA_DRIVER_LICENSE',
   ];
   /**
     If true and extractedDocumentFormats is not empty, then barcodes that don't decode to one of the extracted document formats will be ignored.
@@ -420,19 +453,31 @@ export class BarcodeScannerConfiguration extends PartiallyConstructible {
     Default is false
     */
   public optimizedForOverlays: boolean = false;
+  /**
+    Scanners typically can produce better results from a single image if they are allowed to spend a longer time analyzing it. 
+    
+    On the other hand, scanners can produce even better results if they can analyze multiple images of the same subject and cross-check and combine the results. 
+    The processing mode tells the scanner whether to optimize for single or multiple images of a subject.
+    
+    Default is AUTO
+    */
+  public processingMode: ProcessingMode = 'AUTO';
 
   /** @param source {@displayType `DeepPartial<BarcodeScannerConfiguration>`} */
   public constructor(source: DeepPartial<BarcodeScannerConfiguration> = {}) {
-    super();
     if (source.barcodeFormatConfigurations !== undefined) {
-      this.barcodeFormatConfigurations = source.barcodeFormatConfigurations.map((it: any) => {
-        return BarcodeFormatConfigurationBase.From(it);
-      });
+      this.barcodeFormatConfigurations = source.barcodeFormatConfigurations.map(
+        (it: DeepPartial<BarcodeFormatConfigurationBase>) => {
+          return BarcodeFormatConfigurationBase.from(it);
+        }
+      );
     }
     if (source.extractedDocumentFormats !== undefined) {
-      this.extractedDocumentFormats = source.extractedDocumentFormats.map((it: any) => {
-        return it;
-      });
+      this.extractedDocumentFormats = source.extractedDocumentFormats.map(
+        (it: DeepPartial<BarcodeDocumentFormat>) => {
+          return it;
+        }
+      );
     }
     if (source.onlyAcceptDocuments !== undefined) {
       this.onlyAcceptDocuments = source.onlyAcceptDocuments;
@@ -449,13 +494,16 @@ export class BarcodeScannerConfiguration extends PartiallyConstructible {
     if (source.optimizedForOverlays !== undefined) {
       this.optimizedForOverlays = source.optimizedForOverlays;
     }
+    if (source.processingMode !== undefined) {
+      this.processingMode = source.processingMode;
+    }
   }
 }
 
 /**
 The result of barcode scanning.
 */
-export class BarcodeScannerResult extends PartiallyConstructible {
+export class BarcodeScannerResult {
   /**
     List of found barcodes.
     */
@@ -467,9 +515,8 @@ export class BarcodeScannerResult extends PartiallyConstructible {
 
   /** @param source {@displayType `DeepPartial<BarcodeScannerResult>`} */
   public constructor(source: DeepPartial<BarcodeScannerResult> = {}) {
-    super();
     if (source.barcodes !== undefined) {
-      this.barcodes = source.barcodes.map((it: any) => {
+      this.barcodes = source.barcodes.map((it: DeepPartial<BarcodeItem>) => {
         return new BarcodeItem(it);
       });
     } else {