@qr-platform/qr-code.js 0.8.17

package/lib/lib/zxing-js/src/core/common/detector/MathUtils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * General math-related and numeric utility functions.
+ */
+export default class MathUtils {
+    private constructor();
+    /**
+     * Ends up being a bit faster than {@link Math#round(float)}. This merely rounds its
+     * argument to the nearest int, where x.5 rounds up to x+1. Semantics of this shortcut
+     * differ slightly from {@link Math#round(float)} in that half rounds down for negative
+     * values. -2.5 rounds to -3, not -2. For purposes here it makes no difference.
+     *
+     * @param d real value to round
+     * @return nearest {@code int}
+     */
+    static round(d: number): number;
+    /**
+     * @param aX point A x coordinate
+     * @param aY point A y coordinate
+     * @param bX point B x coordinate
+     * @param bY point B y coordinate
+     * @return Euclidean distance between points A and B
+     */
+    static distance(aX: number, aY: number, bX: number, bY: number): number;
+    /**
+     * @param aX point A x coordinate
+     * @param aY point A y coordinate
+     * @param bX point B x coordinate
+     * @param bY point B y coordinate
+     * @return Euclidean distance between points A and B
+     */
+    /**
+     * @param array values to sum
+     * @return sum of values in array
+     */
+    static sum(array: Int32Array): number;
+}

package/lib/lib/zxing-js/src/core/common/detector/WhiteRectangleDetector.d.ts

@@ -0,0 +1,71 @@
+import ResultPoint from '../../ResultPoint';
+import BitMatrix from '../BitMatrix';
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ * </p>
+ *
+ * @author David Olivier
+ */
+export default class WhiteRectangleDetector {
+    private image;
+    private static INIT_SIZE;
+    private static CORR;
+    private height;
+    private width;
+    private leftInit;
+    private rightInit;
+    private downInit;
+    private upInit;
+    /**
+     * @param image barcode image to find a rectangle in
+     * @param initSize initial size of search area around center
+     * @param x x position of search center
+     * @param y y position of search center
+     * @throws NotFoundException if image is too small to accommodate {@code initSize}
+     */
+    constructor(image: BitMatrix, initSize?: number, x?: number, y?: number);
+    /**
+     * <p>
+     * Detects a candidate barcode-like rectangular region within an image. It
+     * starts around the center of the image, increases the size of the candidate
+     * region until it finds a white rectangular region.
+     * </p>
+     *
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     * @throws NotFoundException if no Data Matrix Code can be found
+     */
+    detect(): Array<ResultPoint>;
+    private getBlackPointOnSegment;
+    /**
+     * recenters the points of a constant distance towards the center
+     *
+     * @param y bottom most point
+     * @param z left most point
+     * @param x right most point
+     * @param t top most point
+     * @return {@link ResultPoint}[] describing the corners of the rectangular
+     *         region. The first and last points are opposed on the diagonal, as
+     *         are the second and third. The first point will be the topmost
+     *         point and the last, the bottommost. The second point will be
+     *         leftmost and the third, the rightmost
+     */
+    private centerEdges;
+    /**
+     * Determines whether a segment contains a black point
+     *
+     * @param a          min value of the scanned coordinate
+     * @param b          max value of the scanned coordinate
+     * @param fixed      value of fixed coordinate
+     * @param horizontal set to true if scan must be horizontal, false if vertical
+     * @return true if a black point has been found, else false.
+     */
+    private containsBlackPoint;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/AbstractGenericGF.d.ts

@@ -0,0 +1,34 @@
+/**
+ * <p>This class contains utility methods for performing mathematical operations over
+ * the Galois Fields. Operations use a given primitive polynomial in calculations.</p>
+ *
+ * <p>Throughout this package, elements of the GF are represented as an {@code int}
+ * for convenience and speed (but at the cost of memory).
+ * </p>
+ *
+ * @author Sean Owen
+ * @author David Olivier
+ */
+export default abstract class AbstractGenericGF {
+    protected expTable: any;
+    protected logTable: any;
+    abstract getZero(): any;
+    abstract buildMonomial(degree: number, coefficient: number): any;
+    abstract equals(o: Object): boolean;
+    abstract multiply(a: number, b: number): number;
+    abstract inverse(a: number): number;
+    /**
+     * @return 2 to the power of a in GF(size)
+     */
+    exp(a: number): number;
+    /**
+     * @return base 2 log of a in GF(size)
+     */
+    log(a: number): number;
+    /**
+     * Implements both addition and subtraction -- they are the same in GF(size).
+     *
+     * @return sum/difference of a and b
+     */
+    static addOrSubtract(a: number, b: number): number;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/AbstractGenericGFPoly.d.ts

@@ -0,0 +1,36 @@
+/**
+ * <p>Represents a polynomial whose coefficients are elements of a GF.
+ * Instances of this class are immutable.</p>
+ *
+ * <p>Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.</p>
+ *
+ * @author Sean Owen
+ */
+export default abstract class AbstractGenericGFPoly {
+    protected field: any;
+    protected coefficients: any;
+    getCoefficients(): Int32Array;
+    /**
+     * @return degree of this polynomial
+     */
+    getDegree(): number;
+    /**
+     * @return true iff this polynomial is the monomial "0"
+     */
+    isZero(): boolean;
+    /**
+     * @return coefficient of x^degree term in this polynomial
+     */
+    getCoefficient(degree: number): number;
+    /**
+     * @return evaluation of this polynomial at a given point
+     */
+    evaluateAt(a: number): number;
+    abstract addOrSubtract(other: AbstractGenericGFPoly): AbstractGenericGFPoly;
+    abstract multiply(other: AbstractGenericGFPoly): AbstractGenericGFPoly;
+    abstract multiplyScalar(scalar: number): AbstractGenericGFPoly;
+    abstract multiplyByMonomial(degree: number, coefficient: number): AbstractGenericGFPoly;
+    abstract divide(other: AbstractGenericGFPoly): AbstractGenericGFPoly[];
+    toString(): string;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/GenericGF.d.ts

@@ -0,0 +1,58 @@
+import AbstractGenericGF from './AbstractGenericGF';
+import GenericGFPoly from './GenericGFPoly';
+/**
+ * <p>This class contains utility methods for performing mathematical operations over
+ * the Galois Fields. Operations use a given primitive polynomial in calculations.</p>
+ *
+ * <p>Throughout this package, elements of the GF are represented as an {@code int}
+ * for convenience and speed (but at the cost of memory).
+ * </p>
+ *
+ * @author Sean Owen
+ * @author David Olivier
+ */
+export default class GenericGF extends AbstractGenericGF {
+    private primitive;
+    private size;
+    private generatorBase;
+    static AZTEC_DATA_12: GenericGF;
+    static AZTEC_DATA_10: GenericGF;
+    static AZTEC_DATA_6: GenericGF;
+    static AZTEC_PARAM: GenericGF;
+    static QR_CODE_FIELD_256: GenericGF;
+    static DATA_MATRIX_FIELD_256: GenericGF;
+    static AZTEC_DATA_8: GenericGF;
+    static MAXICODE_FIELD_64: GenericGF;
+    private zero;
+    private one;
+    /**
+     * Create a representation of GF(size) using the given primitive polynomial.
+     *
+     * @param primitive irreducible polynomial whose coefficients are represented by
+     *  the bits of an int, where the least-significant bit represents the constant
+     *  coefficient
+     * @param size the size of the field
+     * @param b the factor b in the generator polynomial can be 0- or 1-based
+     *  (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))).
+     *  In most cases it should be 1, but for QR code it is 0.
+     */
+    constructor(primitive: number, size: number, generatorBase: number);
+    getZero(): GenericGFPoly;
+    getOne(): GenericGFPoly;
+    /**
+     * @return the monomial representing coefficient * x^degree
+     */
+    buildMonomial(degree: number, coefficient: number): GenericGFPoly;
+    /**
+     * @return multiplicative inverse of a
+     */
+    inverse(a: number): number;
+    /**
+     * @return product of a and b in GF(size)
+     */
+    multiply(a: number, b: number): number;
+    getSize(): number;
+    getGeneratorBase(): number;
+    toString(): string;
+    equals(o: Object): boolean;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/GenericGFPoly.d.ts

@@ -0,0 +1,47 @@
+import AbstractGenericGF from './AbstractGenericGF';
+/**
+ * <p>Represents a polynomial whose coefficients are elements of a GF.
+ * Instances of this class are immutable.</p>
+ *
+ * <p>Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.</p>
+ *
+ * @author Sean Owen
+ */
+export default class GenericGFPoly {
+    private field;
+    private coefficients;
+    /**
+     * @param field the {@link GenericGF} instance representing the field to use
+     * to perform computations
+     * @param coefficients coefficients as ints representing elements of GF(size), arranged
+     * from most significant (highest-power term) coefficient to least significant
+     * @throws IllegalArgumentException if argument is null or empty,
+     * or if leading coefficient is 0 and this is not a
+     * constant polynomial (that is, it is not the monomial "0")
+     */
+    constructor(field: AbstractGenericGF, coefficients: Int32Array);
+    getCoefficients(): Int32Array;
+    /**
+     * @return degree of this polynomial
+     */
+    getDegree(): number;
+    /**
+     * @return true iff this polynomial is the monomial "0"
+     */
+    isZero(): boolean;
+    /**
+     * @return coefficient of x^degree term in this polynomial
+     */
+    getCoefficient(degree: number): number;
+    /**
+     * @return evaluation of this polynomial at a given point
+     */
+    evaluateAt(a: number): number;
+    addOrSubtract(other: GenericGFPoly): GenericGFPoly;
+    multiply(other: GenericGFPoly): GenericGFPoly;
+    multiplyScalar(scalar: number): GenericGFPoly;
+    multiplyByMonomial(degree: number, coefficient: number): GenericGFPoly;
+    divide(other: GenericGFPoly): GenericGFPoly[];
+    toString(): string;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/ReedSolomonDecoder.d.ts

@@ -0,0 +1,40 @@
+import GenericGF from './GenericGF';
+/**
+ * <p>Implements Reed-Solomon decoding, as the name implies.</p>
+ *
+ * <p>The algorithm will not be explained here, but the following references were helpful
+ * in creating this implementation:</p>
+ *
+ * <ul>
+ * <li>Bruce Maggs.
+ * <a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/project/pscico-guyb/realworld/www/rs_decode.ps">
+ * "Decoding Reed-Solomon Codes"</a> (see discussion of Forney's Formula)</li>
+ * <li>J.I. Hall. <a href="www.mth.msu.edu/~jhall/classes/codenotes/GRS.pdf">
+ * "Chapter 5. Generalized Reed-Solomon Codes"</a>
+ * (see discussion of Euclidean algorithm)</li>
+ * </ul>
+ *
+ * <p>Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.</p>
+ *
+ * @author Sean Owen
+ * @author William Rucklidge
+ * @author sanfordsquires
+ */
+export default class ReedSolomonDecoder {
+    private field;
+    constructor(field: GenericGF);
+    /**
+     * <p>Decodes given set of received codewords, which include both data and error-correction
+     * codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,
+     * in the input.</p>
+     *
+     * @param received data and error-correction codewords
+     * @param twoS number of error-correction codewords available
+     * @throws ReedSolomonException if decoding fails for any reason
+     */
+    decode(received: Int32Array, twoS: number): void;
+    private runEuclideanAlgorithm;
+    private findErrorLocations;
+    private findErrorMagnitudes;
+}

package/lib/lib/zxing-js/src/core/common/reedsolomon/ReedSolomonEncoder.d.ts

@@ -0,0 +1,41 @@
+import GenericGF from './GenericGF';
+/**
+ * <p>Implements Reed-Solomon encoding, as the name implies.</p>
+ *
+ * @author Sean Owen
+ * @author William Rucklidge
+ */
+export default class ReedSolomonEncoder {
+    private field;
+    private cachedGenerators;
+    /**
+     * A reed solomon error-correcting encoding constructor is created by
+     * passing as Galois Field with of size equal to the number of code
+     * words (symbols) in the alphabet (the number of values in each
+     * element of arrays that are encoded/decoded).
+     * @param field A galois field with a number of elements equal to the size
+     * of the alphabet of symbols to encode.
+     */
+    constructor(field: GenericGF);
+    private buildGenerator;
+    /**
+     * <p>Encode a sequence of code words (symbols) using Reed-Solomon to allow decoders
+     * to detect and correct errors that may have been introduced when the resulting
+     * data is stored or transmitted.</p>
+     *
+     * @param toEncode array used for both and output. Caller initializes the array with
+     * the code words (symbols) to be encoded followed by empty elements allocated to make
+     * space for error-correction code words in the encoded output. The array contains
+     * the encdoded output when encode returns. Code words are encoded as numbers from
+     * 0 to n-1, where n is the number of possible code words (symbols), as determined
+     * by the size of the Galois Field passed in the constructor of this object.
+     * @param ecBytes the number of elements reserved in the array (first parameter)
+     * to store error-correction code words. Thus, the number of code words (symbols)
+     * to encode in the first parameter is thus toEncode.length - ecBytes.
+     * Note, the use of "bytes" in the name of this parameter is misleading, as there may
+     * be more or fewer than 256 symbols being encoded, as determined by the number of
+     * elements in the Galois Field passed as a constructor to this object.
+     * @throws IllegalArgumentException thrown in response to validation errros.
+     */
+    encode(toEncode: Int32Array, ecBytes: number): void;
+}

package/lib/lib/zxing-js/src/core/qrcode/QRCodeReader.d.ts

@@ -0,0 +1,35 @@
+import BinaryBitmap from '../BinaryBitmap';
+import DecodeHintType from '../DecodeHintType';
+import Result from '../Result';
+import Decoder from './decoder/Decoder';
+/**
+ * This implementation can detect and decode QR Codes in an image.
+ *
+ * @author Sean Owen
+ */
+export default class QRCodeReader {
+    private static NO_POINTS;
+    private decoder;
+    protected getDecoder(): Decoder;
+    /**
+     * Locates and decodes a QR code in an image.
+     *
+     * @return a representing: string the content encoded by the QR code
+     * @throws NotFoundException if a QR code cannot be found
+     * @throws FormatException if a QR code cannot be decoded
+     * @throws ChecksumException if error correction fails
+     */
+    decode(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
+    decode2(image: BinaryBitmap, hints?: Map<DecodeHintType, any>): Result;
+    reset(): void;
+    /**
+     * This method detects a code in a "pure" image -- that is, pure monochrome image
+     * which contains only an unrotated, unskewed, image of a code, with some white border
+     * around it. This is a specialized method that works exceptionally fast in this special
+     * case.
+     *
+     * @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
+     */
+    private static extractPureBits;
+    private static moduleSize;
+}

package/lib/lib/zxing-js/src/core/qrcode/QRCodeWriter.d.ts

@@ -0,0 +1,13 @@
+import BarcodeFormat from '../BarcodeFormat';
+import BitMatrix from '../common/BitMatrix';
+import EncodeHintType from '../EncodeHintType';
+/**
+ * This object renders a QR Code as a BitMatrix 2D array of greyscale values.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export default class QRCodeWriter {
+    private static QUIET_ZONE_SIZE;
+    encode(contents: string, format: BarcodeFormat, width: number, height: number, hints: Map<EncodeHintType, any>): BitMatrix;
+    private static renderResult;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/BitMatrixParser.d.ts

@@ -0,0 +1,58 @@
+import BitMatrix from '../../common/BitMatrix';
+import FormatInformation from './FormatInformation';
+import Version from './Version';
+/**
+ * @author Sean Owen
+ */
+export default class BitMatrixParser {
+    private bitMatrix;
+    private parsedVersion?;
+    private parsedFormatInfo?;
+    private isMirror?;
+    /**
+     * @param bitMatrix {@link BitMatrix} to parse
+     * @throws FormatException if dimension is not >= 21 and 1 mod 4
+     */
+    constructor(bitMatrix: BitMatrix);
+    /**
+     * <p>Reads format information from one of its two locations within the QR Code.</p>
+     *
+     * @return {@link FormatInformation} encapsulating the QR Code's format info
+     * @throws FormatException if both format information locations cannot be parsed as
+     * the valid encoding of format information
+     */
+    readFormatInformation(): FormatInformation;
+    /**
+     * <p>Reads version information from one of its two locations within the QR Code.</p>
+     *
+     * @return {@link Version} encapsulating the QR Code's version
+     * @throws FormatException if both version information locations cannot be parsed as
+     * the valid encoding of version information
+     */
+    readVersion(): Version;
+    private copyBit;
+    /**
+     * <p>Reads the bits in the {@link BitMatrix} representing the finder pattern in the
+     * correct order in order to reconstruct the codewords bytes contained within the
+     * QR Code.</p>
+     *
+     * @return bytes encoded within the QR Code
+     * @throws FormatException if the exact number of bytes expected is not read
+     */
+    readCodewords(): Uint8Array;
+    /**
+     * Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.
+     */
+    remask(): void;
+    /**
+     * Prepare the parser for a mirrored operation.
+     * This flag has effect only on the {@link #readFormatInformation()} and the
+     * {@link #readVersion()}. Before proceeding with {@link #readCodewords()} the
+     * {@link #mirror()} method should be called.
+     *
+     * @param mirror Whether to read version and format information mirrored.
+     */
+    setMirror(isMirror: boolean): void;
+    /** Mirror the bit matrix in order to attempt a second reading. */
+    mirror(): void;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/DataBlock.d.ts

@@ -0,0 +1,28 @@
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+import Version from './Version';
+/**
+ * <p>Encapsulates a block of data within a QR Code. QR Codes may split their data into
+ * multiple blocks, each of which is a unit of data and error-correction codewords. Each
+ * is represented by an instance of this class.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DataBlock {
+    private numDataCodewords;
+    private codewords;
+    private constructor();
+    /**
+     * <p>When QR Codes use multiple data blocks, they are actually interleaved.
+     * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
+     * method will separate the data into original blocks.</p>
+     *
+     * @param rawCodewords bytes as read directly from the QR Code
+     * @param version version of the QR Code
+     * @param ecLevel error-correction level of the QR Code
+     * @return DataBlocks containing original bytes, "de-interleaved" from representation in the
+     *         QR Code
+     */
+    static getDataBlocks(rawCodewords: Uint8Array, version: Version, ecLevel: ErrorCorrectionLevel): DataBlock[];
+    getNumDataCodewords(): number;
+    getCodewords(): Uint8Array;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/DataMask.d.ts

@@ -0,0 +1,36 @@
+import BitMatrix from '../../common/BitMatrix';
+export declare enum DataMaskValues {
+    DATA_MASK_000 = 0,
+    DATA_MASK_001 = 1,
+    DATA_MASK_010 = 2,
+    DATA_MASK_011 = 3,
+    DATA_MASK_100 = 4,
+    DATA_MASK_101 = 5,
+    DATA_MASK_110 = 6,
+    DATA_MASK_111 = 7
+}
+/**
+ * <p>Encapsulates data masks for the data bits in a QR code, per ISO 18004:2006 6.8. Implementations
+ * of this class can un-mask a raw BitMatrix. For simplicity, they will unmask the entire BitMatrix,
+ * including areas used for finder patterns, timing patterns, etc. These areas should be unused
+ * after the point they are unmasked anyway.</p>
+ *
+ * <p>Note that the diagram in section 6.8.1 is misleading since it indicates that i is column position
+ * and j is row position. In fact, as the text says, i is row position and j is column position.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DataMask {
+    private value;
+    private isMasked;
+    constructor(value: DataMaskValues, isMasked: (i: number, j: number) => boolean);
+    static values: Map<DataMaskValues, DataMask>;
+    /**
+     * <p>Implementations of this method reverse the data masking process applied to a QR Code and
+     * make its bits ready to read.</p>
+     *
+     * @param bits representation of QR Code bits
+     * @param dimension dimension of QR Code, represented by bits, being unmasked
+     */
+    unmaskBitMatrix(bits: BitMatrix, dimension: number): void;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/DecodedBitStreamParser.d.ts

@@ -0,0 +1,30 @@
+import DecoderResult from '../../common/DecoderResult';
+import DecodeHintType from '../../DecodeHintType';
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+import Version from './Version';
+/**
+ * <p>QR Codes can encode text as bits in one of several modes, and can use multiple modes
+ * in one QR Code. This class decodes the bits back into text.</p>
+ *
+ * <p>See ISO 18004:2006, 6.4.3 - 6.4.7</p>
+ *
+ * @author Sean Owen
+ */
+export default class DecodedBitStreamParser {
+    /**
+     * See ISO 18004:2006, 6.4.4 Table 5
+     */
+    private static ALPHANUMERIC_CHARS;
+    private static GB2312_SUBSET;
+    static decode(bytes: Uint8Array, version: Version, ecLevel: ErrorCorrectionLevel, hints: Map<DecodeHintType, any>): DecoderResult;
+    /**
+     * See specification GBT 18284-2000
+     */
+    private static decodeHanziSegment;
+    private static decodeKanjiSegment;
+    private static decodeByteSegment;
+    private static toAlphaNumericChar;
+    private static decodeAlphanumericSegment;
+    private static decodeNumericSegment;
+    private static parseECIValue;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/Decoder.d.ts

@@ -0,0 +1,44 @@
+import BitMatrix from '../../common/BitMatrix';
+import DecoderResult from '../../common/DecoderResult';
+import DecodeHintType from '../../DecodeHintType';
+/**
+ * <p>The main class which implements QR Code decoding -- as opposed to locating and extracting
+ * the QR Code from an image.</p>
+ *
+ * @author Sean Owen
+ */
+export default class Decoder {
+    private rsDecoder;
+    constructor();
+    /**
+     * <p>Convenience method that can decode a QR Code represented as a 2D array of booleans.
+     * "true" is taken to mean a black module.</p>
+     *
+     * @param image booleans representing white/black QR Code modules
+     * @param hints decoding hints that should be used to influence decoding
+     * @return text and bytes encoded within the QR Code
+     * @throws FormatException if the QR Code cannot be decoded
+     * @throws ChecksumException if error correction fails
+     */
+    decodeBooleanArray(image: boolean[][], hints?: Map<DecodeHintType, any>): DecoderResult;
+    /**
+     * <p>Decodes a QR Code represented as a {@link BitMatrix}. A 1 or "true" is taken to mean a black module.</p>
+     *
+     * @param bits booleans representing white/black QR Code modules
+     * @param hints decoding hints that should be used to influence decoding
+     * @return text and bytes encoded within the QR Code
+     * @throws FormatException if the QR Code cannot be decoded
+     * @throws ChecksumException if error correction fails
+     */
+    decodeBitMatrix(bits: BitMatrix, hints?: Map<DecodeHintType, any>): DecoderResult;
+    private decodeBitMatrixParser;
+    /**
+     * <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
+     * correct the errors in-place using Reed-Solomon error correction.</p>
+     *
+     * @param codewordBytes data and error correction codewords
+     * @param numDataCodewords number of codewords that are data bytes
+     * @throws ChecksumException if error correction fails
+     */
+    private correctErrors;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/ECB.d.ts

@@ -0,0 +1,12 @@
+/**
+ * <p>Encapsulates the parameters for one error-correction block in one symbol version.
+ * This includes the number of data codewords, and the number of times a block with these
+ * parameters is used consecutively in the QR code version's format.</p>
+ */
+export default class ECB {
+    private count;
+    private dataCodewords;
+    constructor(count: number, dataCodewords: number);
+    getCount(): number;
+    getDataCodewords(): number;
+}

package/lib/lib/zxing-js/src/core/qrcode/decoder/ECBlocks.d.ts

@@ -0,0 +1,16 @@
+import ECB from './ECB';
+/**
+ * <p>Encapsulates a set of error-correction blocks in one symbol version. Most versions will
+ * use blocks of differing sizes within one version, so, this encapsulates the parameters for
+ * each set of blocks. It also holds the number of error-correction codewords per block since it
+ * will be the same across all blocks within one version.</p>
+ */
+export default class ECBlocks {
+    private ecCodewordsPerBlock;
+    private ecBlocks;
+    constructor(ecCodewordsPerBlock: number, ...ecBlocks: ECB[]);
+    getECCodewordsPerBlock(): number;
+    getNumBlocks(): number;
+    getTotalECCodewords(): number;
+    getECBlocks(): ECB[];
+}