@qr-platform/qr-code.js 0.8.24 → 0.9.1

package/lib/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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/node/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[];
+}

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

@@ -0,0 +1,38 @@
+export declare enum ErrorCorrectionLevelValues {
+    L = 0,
+    M = 1,
+    Q = 2,
+    H = 3
+}
+/**
+ * <p>See ISO 18004:2006, 6.5.1. This enum encapsulates the four error correction levels
+ * defined by the QR code standard.</p>
+ *
+ * @author Sean Owen
+ */
+export default class ErrorCorrectionLevel {
+    private value;
+    private stringValue;
+    private bits;
+    private static FOR_BITS;
+    private static FOR_VALUE;
+    /** L = ~7% correction */
+    static L: ErrorCorrectionLevel;
+    /** M = ~15% correction */
+    static M: ErrorCorrectionLevel;
+    /** Q = ~25% correction */
+    static Q: ErrorCorrectionLevel;
+    /** H = ~30% correction */
+    static H: ErrorCorrectionLevel;
+    private constructor();
+    getValue(): ErrorCorrectionLevelValues;
+    getBits(): number;
+    static fromString(s: string): ErrorCorrectionLevel;
+    toString(): string;
+    equals(o: any): boolean;
+    /**
+     * @param bits int containing the two bits encoding a QR Code's error correction level
+     * @return ErrorCorrectionLevel representing the encoded error correction level
+     */
+    static forBits(bits: number): ErrorCorrectionLevel;
+}

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

@@ -0,0 +1,33 @@
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+/**
+ * <p>Encapsulates a QR Code's format information, including the data mask used and
+ * error correction level.</p>
+ *
+ * @author Sean Owen
+ * @see DataMask
+ * @see ErrorCorrectionLevel
+ */
+export default class FormatInformation {
+    private static FORMAT_INFO_MASK_QR;
+    /**
+     * See ISO 18004:2006, Annex C, Table C.1
+     */
+    private static FORMAT_INFO_DECODE_LOOKUP;
+    private errorCorrectionLevel;
+    private dataMask;
+    private constructor();
+    static numBitsDiffering(a: number, b: number): number;
+    /**
+     * @param maskedFormatInfo1 format info indicator, with mask still applied
+     * @param maskedFormatInfo2 second copy of same info; both are checked at the same time
+     *  to establish best match
+     * @return information about the format it specifies, or {@code null}
+     *  if doesn't seem to match any known pattern
+     */
+    static decodeFormatInformation(maskedFormatInfo1: number, maskedFormatInfo2: number): FormatInformation | null;
+    private static doDecodeFormatInformation;
+    getErrorCorrectionLevel(): ErrorCorrectionLevel;
+    getDataMask(): number;
+    hashCode(): number;
+    equals(o: Object): boolean;
+}

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

@@ -0,0 +1,56 @@
+import Version from './Version';
+export declare enum ModeValues {
+    TERMINATOR = 0,// Not really a mode...
+    NUMERIC = 1,
+    ALPHANUMERIC = 2,
+    STRUCTURED_APPEND = 3,// Not supported
+    BYTE = 4,
+    ECI = 5,// character counts don't apply
+    KANJI = 6,
+    FNC1_FIRST_POSITION = 7,
+    FNC1_SECOND_POSITION = 8,
+    /** See GBT 18284-2000; "Hanzi" is a transliteration of this mode name. */
+    HANZI = 9
+}
+/**
+ * <p>See ISO 18004:2006, 6.4.1, Tables 2 and 3. This enum encapsulates the various modes in which
+ * data can be encoded to bits in the QR code standard.</p>
+ *
+ * @author Sean Owen
+ */
+export default class Mode {
+    private value;
+    private stringValue;
+    private characterCountBitsForVersions;
+    private bits;
+    private static FOR_BITS;
+    private static FOR_VALUE;
+    static TERMINATOR: Mode;
+    static NUMERIC: Mode;
+    static ALPHANUMERIC: Mode;
+    static STRUCTURED_APPEND: Mode;
+    static BYTE: Mode;
+    static ECI: Mode;
+    static KANJI: Mode;
+    static FNC1_FIRST_POSITION: Mode;
+    static FNC1_SECOND_POSITION: Mode;
+    /** See GBT 18284-2000; "Hanzi" is a transliteration of this mode name. */
+    static HANZI: Mode;
+    private constructor();
+    /**
+     * @param bits four bits encoding a QR Code data mode
+     * @return Mode encoded by these bits
+     * @throws IllegalArgumentException if bits do not correspond to a known mode
+     */
+    static forBits(bits: number): Mode;
+    /**
+     * @param version version in question
+     * @return number of bits used, in this QR Code symbol {@link Version}, to encode the
+     *         count of characters that will follow encoded in this Mode
+     */
+    getCharacterCountBits(version: Version): number;
+    getValue(): ModeValues;
+    getBits(): number;
+    equals(o: any): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,21 @@
+import ResultPoint from '../../ResultPoint';
+/**
+ * Meta-data container for QR Code decoding. Instances of this class may be used to convey information back to the
+ * decoding caller. Callers are expected to process this.
+ *
+ * @see com.google.zxing.common.DecoderResult#getOther()
+ */
+export default class QRCodeDecoderMetaData {
+    private mirrored;
+    constructor(mirrored: boolean);
+    /**
+     * @return true if the QR Code was mirrored.
+     */
+    isMirrored(): boolean;
+    /**
+     * Apply the result points' order correction due to mirroring.
+     *
+     * @param points Array of points to apply mirror correction to.
+     */
+    applyMirroredCorrection(points: Array<ResultPoint>): void;
+}