react-native-nitro-zxing 0.1.0-alpha.0

package/cpp/zxing-core/core/src/qrcode/QRVersion.h

@@ -0,0 +1,127 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Point.h"
+#include "QRECB.h"
+#include "QRErrorCorrectionLevel.h"
+#include "ZXAlgorithms.h"
+
+#include <array>
+#include <initializer_list>
+#include <vector>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace QRCode {
+
+// clang-format off
+constexpr std::array<PointI, 32> RMQR_SIZES {
+			PointI{43,  7}, {59,  7}, {77,  7}, {99,  7}, {139,  7},
+				  {43,  9}, {59,  9}, {77,  9}, {99,  9}, {139,  9},
+		{27, 11}, {43, 11}, {59, 11}, {77, 11}, {99, 11}, {139, 11},
+		{27, 13}, {43, 13}, {59, 13}, {77, 13}, {99, 13}, {139, 13},
+				  {43, 15}, {59, 15}, {77, 15}, {99, 15}, {139, 15},
+				  {43, 17}, {59, 17}, {77, 17}, {99, 17}, {139, 17},
+};
+// clang-format on
+
+/**
+* See ISO 18004:2006 Annex D
+*/
+class Version
+{
+public:
+	Type type() const { return _type; }
+	bool isMicro() const { return type() == Type::Micro; }
+	bool isRMQR() const { return type() == Type::rMQR; }
+	bool isModel1() const { return type() == Type::Model1; }
+	bool isModel2() const { return type() == Type::Model2; }
+
+	int versionNumber() const { return _versionNumber; }
+
+	const std::vector<int>& alignmentPatternCenters() const { return _alignmentPatternCenters; }
+
+	int totalCodewords() const { return _totalCodewords; }
+
+	int dimension() const { return SymbolSize(versionNumber(), isMicro() ? Type::Micro : Type::Model2).x; }
+
+	const ECBlocks& ecBlocksForLevel(ErrorCorrectionLevel ecLevel) const { return _ecBlocks[(int)ecLevel]; }
+
+	BitMatrix buildFunctionPattern() const;
+
+	static constexpr PointI SymbolSize(int version, Type type)
+	{
+		auto square = [](int s) { return PointI(s, s); };
+		auto valid = [](int v, int max) { return v >= 1 && v <= max; };
+
+		switch (type) {
+		case Type::Model1: return valid(version, 32) ? square(17 + 4 * version) : PointI{};
+		case Type::Model2: return valid(version, 40) ? square(17 + 4 * version) : PointI{};
+		case Type::Micro: return valid(version, 4) ? square(9 + 2 * version) : PointI{};
+		case Type::rMQR: return valid(version, 32) ? RMQR_SIZES[version - 1] : PointI{};
+		}
+
+		return {}; // silence warning
+	}
+
+	static constexpr bool IsValidSize(PointI size, Type type)
+	{
+		switch (type) {
+		case Type::Model1: return size.x == size.y && size.x >= 21 && size.x <= 145 && (size.x % 4 == 1);
+		case Type::Model2: return size.x == size.y && size.x >= 21 && size.x <= 177 && (size.x % 4 == 1);
+		case Type::Micro: return size.x == size.y && size.x >= 11 && size.x <= 17 && (size.x % 2 == 1);
+		case Type::rMQR:
+			return size.x != size.y && size.x & 1 && size.y & 1 && size.x >= 27 && size.x <= 139 && size.y >= 7 && size.y <= 17
+				   && IndexOf(RMQR_SIZES, size) != -1;
+		}
+		return {}; // silence warning
+	}
+	static bool HasValidSize(const BitMatrix& bitMatrix, Type type);
+
+	static bool HasValidSize(const BitMatrix& matrix)
+	{
+		return HasValidSize(matrix, Type::Model1) || HasValidSize(matrix, Type::Model2) || HasValidSize(matrix, Type::Micro)
+			   || HasValidSize(matrix, Type::rMQR);
+	}
+
+	static constexpr int Number(PointI size)
+	{
+		if (size.x != size.y)
+			return IndexOf(RMQR_SIZES, size) + 1;
+		if (IsValidSize(size, Type::Model2))
+			return (size.x - 17) / 4;
+		if (IsValidSize(size, Type::Micro))
+			return (size.x - 9) / 2;
+		return 0;
+	}
+
+	static int Number(const BitMatrix& bitMatrix);
+
+	static const Version* DecodeVersionInformation(int versionBitsA, int versionBitsB = 0);
+
+	static const Version* Model1(int number);
+	static const Version* Model2(int number);
+	static const Version* Micro(int number);
+	static const Version* rMQR(int number);
+
+private:
+	int _versionNumber;
+	std::vector<int> _alignmentPatternCenters;
+	std::array<ECBlocks, 4> _ecBlocks;
+	int _totalCodewords;
+	Type _type;
+
+	Version(int versionNumber, std::initializer_list<int> alignmentPatternCenters, const std::array<ECBlocks, 4> &ecBlocks);
+	Version(int versionNumber, const std::array<ECBlocks, 4>& ecBlocks);
+};
+
+} // QRCode
+} // ZXing

package/cpp/zxing-core/core/src/qrcode/QRWriter.cpp

@@ -0,0 +1,51 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "QRWriter.h"
+
+#include "BitMatrix.h"
+#include "CharacterSet.h"
+#include "QREncodeResult.h"
+#include "QREncoder.h"
+#include "QRErrorCorrectionLevel.h"
+#include "Utf.h"
+
+#include <stdexcept>
+#include <utility>
+
+namespace ZXing::QRCode {
+
+static const int QUIET_ZONE_SIZE = 4;
+
+Writer::Writer()
+	: _margin(QUIET_ZONE_SIZE),
+	  _ecLevel(ErrorCorrectionLevel::Low),
+	  _encoding(CharacterSet::Unknown),
+	  _version(0),
+	  _useGs1Format(false),
+	  _maskPattern(-1)
+{}
+
+BitMatrix Writer::encode(const std::wstring& contents, int width, int height) const
+{
+	if (contents.empty()) {
+		throw std::invalid_argument("Found empty contents");
+	}
+
+	if (width < 0 || height < 0) {
+		throw std::invalid_argument("Requested dimensions are invalid");
+	}
+
+	EncodeResult code = Encode(contents, _ecLevel, _encoding, _version, _useGs1Format, _maskPattern);
+	return Inflate(std::move(code.matrix), width, height, _margin);
+}
+
+BitMatrix Writer::encode(const std::string& contents, int width, int height) const
+{
+	return encode(FromUtf8(contents), width, height);
+}
+
+} // namespace ZXing::QRCode

package/cpp/zxing-core/core/src/qrcode/QRWriter.h

@@ -0,0 +1,74 @@
+/*
+* Copyright 2016 Huy Cuong Nguyen
+* Copyright 2016 ZXing authors
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "CharacterSet.h"
+
+#include <string>
+
+namespace ZXing {
+
+class BitMatrix;
+
+namespace QRCode {
+
+enum class ErrorCorrectionLevel;
+
+/**
+* This object renders a QR Code as a BitMatrix 2D array of greyscale values.
+*
+* @author dswitkin@google.com (Daniel Switkin)
+*/
+class Writer
+{
+public:
+	Writer();
+
+	Writer& setMargin(int margin) {
+		_margin = margin;
+		return *this;
+	}
+
+	Writer& setErrorCorrectionLevel(ErrorCorrectionLevel ecLevel) {
+		_ecLevel = ecLevel;
+		return *this;
+	}
+
+	Writer& setEncoding(CharacterSet encoding) {
+		_encoding = encoding;
+		return *this;
+	}
+
+	Writer& setVersion(int versionNumber) {
+		_version = versionNumber;
+		return *this;
+	}
+
+	Writer& useGS1Format() {
+		_useGs1Format = true;
+		return *this;
+	}
+
+	Writer& setMaskPattern(int pattern) {
+		_maskPattern = pattern;
+		return *this;
+	}
+
+	BitMatrix encode(const std::wstring& contents, int width, int height) const;
+	BitMatrix encode(const std::string& contents, int width, int height) const;
+
+private:
+	int _margin;
+	ErrorCorrectionLevel _ecLevel;
+	CharacterSet _encoding;
+	int _version;
+	bool _useGs1Format;
+	int _maskPattern;
+};
+
+} // QRCode
+} // ZXing

package/cpp/zxing-core/core/version.rc.in

@@ -0,0 +1,34 @@
+// Windows resource file - Add version information to DLL
+#include <windows.h>
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION @FILE_VERSION_COMMA@
+PRODUCTVERSION @FILE_VERSION_COMMA@
+FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+FILEFLAGS 0x1L
+#else
+FILEFLAGS 0x0L
+#endif
+FILEOS 0x40004L
+FILETYPE 0x2L
+FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0" // en-US, Unicode
+        BEGIN
+            VALUE "CompanyName", "zxing-cpp"
+            VALUE "FileDescription", "ZXing-C++ Barcode Library"
+            VALUE "FileVersion", "@FILE_VERSION_STR@"
+            VALUE "InternalName", "ZXing"
+            VALUE "LegalCopyright", "Copyright (C) zxing-cpp contributors"
+            VALUE "ProductName", "ZXing-C++"
+            VALUE "ProductVersion", "@FILE_VERSION_STR@"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x0409, 1200
+    END
+END

package/cpp/zxing-core/core/zxing.pc.in

@@ -0,0 +1,8 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: ZXing
+Description: ZXing-C++ library
+Version: @PROJECT_VERSION@@ZXING_VERSION_SUFFIX@
+Libs: -L${libdir} -lZXing
+Cflags: -I${includedir} @COMPILE_FLAGS@

package/cpp/zxing-core/wrappers/ios/README.md

@@ -0,0 +1,25 @@
+# ZXingCpp iOS Framework
+
+## Installation
+
+### SwiftPM
+
+As this repository provides a `Package.swift` on the root level, so you can add `zxing-cpp` including wrapper code by adding a Package Dependency in Xcode.
+
+An alternative way is to check this repository out and add it as a local Swift Package by adding it as a dependency to your app.
+
+### CocoaPods
+
+You can also use [CocoaPods](https://cocoapods.org/pods/zxing-cpp). Just add the Pod as a dependency:
+
+```
+pod 'zxing-cpp'
+```
+The module to be imported is named `ZXingCpp`. If you just need the core without the wrapper code, you can use:
+```
+pod 'zxing-cpp/Core'
+```
+
+## Usage
+
+For general usage of the ObjectiveC/Swift wrapper, please have a look at the source code provided in the [demo project](demo).

package/cpp/zxing-core/wrappers/ios/Sources/Wrapper/Version.h

@@ -0,0 +1,29 @@
+/*
+* Copyright 2026 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+// This header a 'manual' rendition of Version.h.in for the iOS (SwiftPM / Cocoapods) build systems that don't use cmake
+
+#pragma once
+
+#define ZXING_READERS
+#define ZXING_WRITERS
+
+#define ZXING_ENABLE_1D 1
+#define ZXING_ENABLE_AZTEC 1
+#define ZXING_ENABLE_DATAMATRIX 1
+#define ZXING_ENABLE_MAXICODE 1
+#define ZXING_ENABLE_PDF417 1
+#define ZXING_ENABLE_QRCODE 1
+
+// #define ZXING_EXPERIMENTAL_API
+// #define ZXING_USE_ZINT
+
+// Version numbering
+#define ZXING_VERSION_MAJOR 3
+#define ZXING_VERSION_MINOR 1
+#define ZXING_VERSION_PATCH 1
+#define ZXING_VERSION_SUFFIX "" // e.g. "-rc1"
+
+#define ZXING_VERSION_STR "3.1.1" ZXING_VERSION_SUFFIX

package/cpp/zxing-core/zxing-cpp.podspec

@@ -0,0 +1,45 @@
+Pod::Spec.new do |s|
+  s.name = 'zxing-cpp'
+  s.version = '3.1.1'
+  s.summary = 'C++ port of ZXing'
+  s.homepage = 'https://github.com/zxing-cpp/zxing-cpp'
+  s.author = 'axxel'
+  s.readme = 'https://raw.githubusercontent.com/zxing-cpp/zxing-cpp/master/wrappers/ios/README.md'
+  s.license = {
+    :type => 'Apache License 2.0',
+    :file => 'LICENSE'
+  }
+  s.source = {
+    :git => 'https://github.com/zxing-cpp/zxing-cpp.git',
+    :tag => "v#{s.version}"
+  }
+  s.module_name = 'ZXingCpp'
+  s.platform = :ios, '12.0'
+  s.library = ['c++']
+  s.compiler_flags = [
+    '-DZXING_INTERNAL',
+    '-Wno-comma'
+  ]
+  s.pod_target_xcconfig = {
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
+    'HEADER_SEARCH_PATHS' => '$(PODS_TARGET_SRCROOT)/wrappers/ios/Sources/Wrapper'
+  }
+
+  s.default_subspec = 'Wrapper'
+
+  s.subspec 'Core' do |ss|
+    ss.source_files = 'core/src/**/*.{h,c,cpp}'
+    ss.exclude_files = [ 'core/src/libzint/**' ]
+    ss.private_header_files = 'core/src/**/*.h'
+  end
+
+  s.subspec 'Wrapper' do |ss|
+    ss.dependency 'zxing-cpp/Core'
+    ss.frameworks = 'CoreGraphics', 'CoreImage', 'CoreVideo'
+    ss.source_files = 'wrappers/ios/Sources/Wrapper/**/*.{h,m,mm}'
+    ss.public_header_files = 'wrappers/ios/Sources/Wrapper/Reader/{ZXIBarcodeReader,ZXIResult,ZXIPosition,ZXIPoint,ZXIGTIN,ZXIReaderOptions}.h',
+                             'wrappers/ios/Sources/Wrapper/Writer/{ZXIBarcodeWriter,ZXIWriterOptions}.h',
+                             'wrappers/ios/Sources/Wrapper/{ZXIErrors,ZXIFormat}.h'
+    ss.exclude_files = 'wrappers/ios/Sources/Wrapper/UmbrellaHeader.h'
+  end
+end

package/lib/factory.d.ts

@@ -0,0 +1,10 @@
+import type { BarcodeScanner } from './specs/BarcodeScanner.nitro';
+import type { BarcodeScannerOptions } from './specs/BarcodeScannerFactory.nitro';
+/**
+ * Create a new {@linkcode BarcodeScanner}.
+ *
+ * The {@linkcode BarcodeScanner} can be used to
+ * scan {@linkcode Barcode}s in a {@linkcode Frame} or
+ * an existing {@linkcode Image}.
+ */
+export declare function createBarcodeScanner(options: BarcodeScannerOptions): BarcodeScanner;

package/lib/factory.js

@@ -0,0 +1,12 @@
+import { NitroModules } from 'react-native-nitro-modules';
+const factory = NitroModules.createHybridObject('ZXingBarcodeScannerFactory');
+/**
+ * Create a new {@linkcode BarcodeScanner}.
+ *
+ * The {@linkcode BarcodeScanner} can be used to
+ * scan {@linkcode Barcode}s in a {@linkcode Frame} or
+ * an existing {@linkcode Image}.
+ */
+export function createBarcodeScanner(options) {
+    return factory.createBarcodeScanner(options);
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './factory';
+export * from './specs/Barcode.nitro';
+export * from './specs/BarcodeFormat';
+export * from './specs/BarcodeScanner.nitro';
+export * from './specs/BarcodeScannerFactory.nitro';
+export * from './specs/BarcodeValueType';
+export * from './specs/Point';
+export * from './specs/Rect';
+export * from './useBarcodeScanner';

package/lib/index.js

@@ -0,0 +1,9 @@
+export * from './factory';
+export * from './specs/Barcode.nitro';
+export * from './specs/BarcodeFormat';
+export * from './specs/BarcodeScanner.nitro';
+export * from './specs/BarcodeScannerFactory.nitro';
+export * from './specs/BarcodeValueType';
+export * from './specs/Point';
+export * from './specs/Rect';
+export * from './useBarcodeScanner';

package/lib/specs/Barcode.nitro.d.ts

@@ -0,0 +1,63 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { BarcodeFormat } from './BarcodeFormat';
+import type { BarcodeValueType } from './BarcodeValueType';
+import type { Point } from './Point';
+import type { Rect } from './Rect';
+/**
+ * Represents a single detected Barcode.
+ *
+ * A {@linkcode Barcode} is produced via the
+ * {@linkcode BarcodeScanner} (see
+ * {@linkcode createBarcodeScanner | createBarcodeScanner(...)}).
+ *
+ * See {@linkcode BarcodeScanner.scanCodes | BarcodeScanner.scanCodes(...)}
+ * and {@linkcode BarcodeScanner.scanCodesInImageAsync | BarcodeScanner.scanCodesInImageAsync(...)}
+ * for information about Barcode coordinate systems.
+ *
+ * @example
+ * ```ts
+ * const barcode = ...
+ * console.log(`Barcode value: ${barcode.rawValue}`)
+ * ```
+ */
+export interface Barcode extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Get the format of this {@linkcode Barcode}.
+     * @see {@linkcode BarcodeFormat}
+     */
+    readonly format: BarcodeFormat;
+    /**
+     * Get the {@linkcode Barcode}'s bounding box.
+     *
+     * The coordinates are relative to the input {@linkcode Frame}
+     * or {@linkcode Image}.
+     */
+    readonly boundingBox: Rect;
+    /**
+     * Get the {@linkcode Barcode}'s corner points.
+     *
+     * The coordinates are relative to the input {@linkcode Frame}
+     * or {@linkcode Image}.
+     */
+    readonly cornerPoints: Point[];
+    /**
+     * Get the {@linkcode Barcode}'s value in a user-friendly format.
+     */
+    readonly displayValue: string | undefined;
+    /**
+     * Get the {@linkcode Barcode}'s value in raw bytes.
+     */
+    readonly rawBytes: ArrayBuffer | undefined;
+    /**
+     * Get the {@linkcode Barcode}'s raw value as a string.
+     */
+    readonly rawValue: string | undefined;
+    /**
+     * Get the {@linkcode Barcode}'s value's type.
+     * @see {@linkcode BarcodeValueType}
+     */
+    readonly valueType: BarcodeValueType;
+}

package/lib/specs/Barcode.nitro.js

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

package/lib/specs/BarcodeFormat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents a detected {@linkcode Barcode}'s format, or
+ * `'unknown'` if the format of a scanned Barcode could not be
+ * determined.
+ */
+export type BarcodeFormat = 'unknown' | 'code-128' | 'code-39' | 'code-93' | 'codabar' | 'data-matrix' | 'ean-13' | 'ean-8' | 'itf' | 'qr-code' | 'upc-a' | 'upc-e' | 'pdf-417' | 'aztec';
+/**
+ * Represents a target {@linkcode BarcodeFormat} that the {@linkcode BarcodeScanner}
+ * can be configured to scan for, or `'all-formats'` to scan for every supported format.
+ */
+export type TargetBarcodeFormat = Exclude<BarcodeFormat, 'unknown'> | 'all-formats';

package/lib/specs/BarcodeFormat.js

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

package/lib/specs/BarcodeScanner.nitro.d.ts

@@ -0,0 +1,89 @@
+import type { Image } from 'react-native-nitro-image';
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { Frame } from 'react-native-vision-camera';
+import type { Barcode } from './Barcode.nitro';
+/**
+ * Represents a Barcode Scanner that uses ZXing (zxing-cpp).
+ *
+ * The {@linkcode BarcodeScanner} can be used in a
+ * Frame Processor by calling {@linkcode BarcodeScanner.scanCodes | scanCodes(...)},
+ * or for static images by calling
+ * {@linkcode BarcodeScanner.scanCodesInImageAsync | scanCodesInImageAsync(...)}.
+ *
+ * @see {@linkcode useBarcodeScanner | useBarcodeScanner(...)}
+ * @see {@linkcode createBarcodeScanner | createBarcodeScanner(...)}
+ */
+export interface BarcodeScanner extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Synchronously detects {@linkcode Barcode}s in the
+     * given {@linkcode Frame}.
+     *
+     * All coordinates in the {@linkcode Barcode} are
+     * relative to the {@linkcode Frame}'s coordinate system.
+     *
+     * You can convert {@linkcode Barcode} coordinates to Camera coordinates using
+     * {@linkcode Frame.convertFramePointToCameraPoint | Frame.convertFramePointToCameraPoint(...)},
+     * and then convert the Camera coordinates to Preview View coordinates using
+     * {@linkcode PreviewViewMethods.convertCameraPointToViewPoint | PreviewViewMethods.convertCameraPointToViewPoint(...)}.
+     *
+     * @example
+     * ```ts
+     * const scanner = // ...
+     * const frame = // ...
+     * const previewView = // ...
+     *
+     * const barcodes = scanner.scanCodes(frame)
+     * for (const barcode of barcodes) {
+     *   console.log('Barcode value:', barcode.rawValue)
+     *   for (const point of barcode.cornerPoints) {
+     *     const cameraPoint = frame.convertFramePointToCameraPoint(point)
+     *     const previewPoint = previewView.convertCameraPointToViewPoint(cameraPoint)
+     *     console.log('Corner Point:', previewPoint)
+     *   }
+     * }
+     * ```
+     */
+    scanCodes(frame: Frame): Barcode[];
+    /**
+     * Asynchronously detects {@linkcode Barcode}s in the
+     * given {@linkcode Frame}.
+     *
+     * The Frame must remain valid until the returned Promise settles. Do not
+     * call {@linkcode Frame.dispose | Frame.dispose()} before awaiting it.
+     *
+     * @see {@linkcode scanCodes}
+     */
+    scanCodesAsync(frame: Frame): Promise<Barcode[]>;
+    /**
+     * Asynchronously detects {@linkcode Barcode}s in the
+     * given {@linkcode Image}.
+     *
+     * This can be used to scan codes in an existing still image, such as
+     * an image loaded from disk, bundled resources or a URL via
+     * `react-native-nitro-image`.
+     *
+     * All coordinates in the returned {@linkcode Barcode}s are relative
+     * to the given {@linkcode Image}'s coordinate system.
+     *
+     * @example
+     * ```ts
+     * import { loadImage } from 'react-native-nitro-image'
+     * import { createBarcodeScanner } from 'react-native-nitro-zxing'
+     *
+     * const image = await loadImage({ url: 'https://example.com/barcode.png' })
+     * const scanner = createBarcodeScanner({ barcodeFormats: ['all-formats'] })
+     *
+     * try {
+     *   const barcodes = await scanner.scanCodesInImageAsync(image)
+     *   console.log('Barcode value:', barcodes[0]?.rawValue)
+     * } finally {
+     *   image.dispose()
+     *   scanner.dispose()
+     * }
+     * ```
+     */
+    scanCodesInImageAsync(image: Image): Promise<Barcode[]>;
+}

package/lib/specs/BarcodeScanner.nitro.js

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

package/lib/specs/BarcodeScannerFactory.nitro.d.ts

@@ -0,0 +1,26 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { TargetBarcodeFormat } from './BarcodeFormat';
+import type { BarcodeScanner } from './BarcodeScanner.nitro';
+export interface BarcodeScannerOptions {
+    /**
+     * Specifies the formats to be used for Barcode
+     * scanning.
+     *
+     * If you want to detect all kinds of barcodes,
+     * use {@linkcode TargetBarcodeFormat | ['all-formats']}
+     */
+    barcodeFormats: TargetBarcodeFormat[];
+}
+export interface ZXingBarcodeScannerFactory extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Create a new {@linkcode BarcodeScanner}.
+     */
+    createBarcodeScanner(options: BarcodeScannerOptions): BarcodeScanner;
+}
+/**
+ * Alias of {@linkcode ZXingBarcodeScannerFactory}.
+ */
+export type BarcodeScannerFactory = ZXingBarcodeScannerFactory;

package/lib/specs/BarcodeScannerFactory.nitro.js

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

package/lib/specs/BarcodeValueType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Represents the semantic type of data encoded in a {@linkcode Barcode} - e.g.
+ * a URL, a phone number, or a WiFi config - or `'unknown'` if the content type
+ * could not be classified.
+ *
+ * This describes **what** the barcode's content represents, not the barcode's
+ * visual format (see {@linkcode BarcodeFormat}).
+ */
+export type BarcodeValueType = 'unknown' | 'contact-info' | 'email' | 'isbn' | 'phone' | 'product' | 'sms' | 'text' | 'url' | 'wifi' | 'geo' | 'calendar-event' | 'driver-license';

package/lib/specs/BarcodeValueType.js

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

package/lib/specs/Point.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents a Point in the current context's
+ * coordinate system.
+ */
+export interface Point {
+    /**
+     * The X coordinate of the Point.
+     */
+    x: number;
+    /**
+     * The Y coordinate of the Point.
+     */
+    y: number;
+}