@qr-platform/qr-code.js 0.8.17

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

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

@@ -0,0 +1,44 @@
+import BitMatrix from '../../common/BitMatrix';
+import ECBlocks from './ECBlocks';
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+/**
+ * See ISO 18004:2006 Annex D
+ *
+ * @author Sean Owen
+ */
+export default class Version {
+    private versionNumber;
+    private alignmentPatternCenters;
+    /**
+     * See ISO 18004:2006 Annex D.
+     * Element i represents the raw version bits that specify version i + 7
+     */
+    private static VERSION_DECODE_INFO;
+    /**
+     * See ISO 18004:2006 6.5.1 Table 9
+     */
+    private static VERSIONS;
+    private ecBlocks;
+    private totalCodewords;
+    private constructor();
+    getVersionNumber(): number;
+    getAlignmentPatternCenters(): Int32Array;
+    getTotalCodewords(): number;
+    getDimensionForVersion(): number;
+    getECBlocksForLevel(ecLevel: ErrorCorrectionLevel): ECBlocks;
+    /**
+     * <p>Deduces version information purely from QR Code dimensions.</p>
+     *
+     * @param dimension dimension in modules
+     * @return Version for a QR Code of that dimension
+     * @throws FormatException if dimension is not 1 mod 4
+     */
+    static getProvisionalVersionForDimension(dimension: number): Version;
+    static getVersionForNumber(versionNumber: number): Version;
+    static decodeVersionInformation(versionBits: number): Version | null;
+    /**
+     * See ISO 18004:2006 Annex E
+     */
+    buildFunctionPattern(): BitMatrix;
+    toString(): string;
+}

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

@@ -0,0 +1,21 @@
+import ResultPoint from '../../ResultPoint';
+/**
+ * <p>Encapsulates an alignment pattern, which are the smaller square patterns found in
+ * all but the simplest QR Codes.</p>
+ *
+ * @author Sean Owen
+ */
+export default class AlignmentPattern extends ResultPoint {
+    private estimatedModuleSize;
+    constructor(posX: number, posY: number, estimatedModuleSize: number);
+    /**
+     * <p>Determines if this alignment pattern "about equals" an alignment pattern at the stated
+     * position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
+     */
+    aboutEquals(moduleSize: number, i: number, j: number): boolean;
+    /**
+     * Combines this object's current estimate of a finder pattern position and module size
+     * with a new estimate. It returns a new {@code FinderPattern} containing an average of the two.
+     */
+    combineEstimate(i: number, j: number, newModuleSize: number): AlignmentPattern;
+}

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

@@ -0,0 +1,82 @@
+import BitMatrix from '../../common/BitMatrix';
+import ResultPointCallback from '../../ResultPointCallback';
+import AlignmentPattern from './AlignmentPattern';
+/**
+ * <p>This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder
+ * patterns but are smaller and appear at regular intervals throughout the image.</p>
+ *
+ * <p>At the moment this only looks for the bottom-right alignment pattern.</p>
+ *
+ * <p>This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,
+ * pasted and stripped down here for maximum performance but does unfortunately duplicate
+ * some code.</p>
+ *
+ * <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.</p>
+ *
+ * @author Sean Owen
+ */
+export default class AlignmentPatternFinder {
+    private image;
+    private startX;
+    private startY;
+    private width;
+    private height;
+    private moduleSize;
+    private resultPointCallback;
+    private possibleCenters;
+    private crossCheckStateCount;
+    /**
+     * <p>Creates a finder that will look in a portion of the whole image.</p>
+     *
+     * @param image image to search
+     * @param startX left column from which to start searching
+     * @param startY top row from which to start searching
+     * @param width width of region to search
+     * @param height height of region to search
+     * @param moduleSize estimated module size so far
+     */
+    constructor(image: BitMatrix, startX: number, startY: number, width: number, height: number, moduleSize: number, resultPointCallback: ResultPointCallback);
+    /**
+     * <p>This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since
+     * it's pretty performance-critical and so is written to be fast foremost.</p>
+     *
+     * @return {@link AlignmentPattern} if found
+     * @throws NotFoundException if not found
+     */
+    find(): AlignmentPattern;
+    /**
+     * Given a count of black/white/black pixels just seen and an end position,
+     * figures the location of the center of this black/white/black run.
+     */
+    private static centerFromEnd;
+    /**
+     * @param stateCount count of black/white/black pixels just read
+     * @return true iff the proportions of the counts is close enough to the 1/1/1 ratios
+     *         used by alignment patterns to be considered a match
+     */
+    private foundPatternCross;
+    /**
+     * <p>After a horizontal scan finds a potential alignment pattern, this method
+     * "cross-checks" by scanning down vertically through the center of the possible
+     * alignment pattern to see if the same proportion is detected.</p>
+     *
+     * @param startI row where an alignment pattern was detected
+     * @param centerJ center of the section that appears to cross an alignment pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     * observed in any reading state, based on the results of the horizontal scan
+     * @return vertical center of alignment pattern, or {@link Float#NaN} if not found
+     */
+    private crossCheckVertical;
+    /**
+     * <p>This is called when a horizontal scan finds a possible alignment pattern. It will
+     * cross check with a vertical scan, and if successful, will see if this pattern had been
+     * found on a previous horizontal scan. If so, we consider it confirmed and conclude we have
+     * found the alignment pattern.</p>
+     *
+     * @param stateCount reading state module counts from horizontal scan
+     * @param i row where alignment pattern may be found
+     * @param j end of possible alignment pattern in row
+     * @return {@link AlignmentPattern} if we have found the same pattern twice, or null if not
+     */
+    private handlePossibleCenter;
+}

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

@@ -0,0 +1,87 @@
+import BitMatrix from '../../common/BitMatrix';
+import DetectorResult from '../../common/DetectorResult';
+import DecodeHintType from '../../DecodeHintType';
+import ResultPoint from '../../ResultPoint';
+import ResultPointCallback from '../../ResultPointCallback';
+import AlignmentPattern from './AlignmentPattern';
+import FinderPatternInfo from './FinderPatternInfo';
+/**
+ * <p>Encapsulates logic that can detect a QR Code in an image, even if the QR Code
+ * is rotated or skewed, or partially obscured.</p>
+ *
+ * @author Sean Owen
+ */
+export default class Detector {
+    private image;
+    private resultPointCallback?;
+    constructor(image: BitMatrix);
+    protected getImage(): BitMatrix;
+    protected getResultPointCallback(): ResultPointCallback | undefined;
+    /**
+     * <p>Detects a QR Code in an image.</p>
+     *
+     * @return {@link DetectorResult} encapsulating results of detecting a QR Code
+     * @throws NotFoundException if QR Code cannot be found
+     * @throws FormatException if a QR Code cannot be decoded
+     */
+    /**
+     * <p>Detects a QR Code in an image.</p>
+     *
+     * @param hints optional hints to detector
+     * @return {@link DetectorResult} encapsulating results of detecting a QR Code
+     * @throws NotFoundException if QR Code cannot be found
+     * @throws FormatException if a QR Code cannot be decoded
+     */
+    detect(hints: Map<DecodeHintType, any>): DetectorResult;
+    protected processFinderPatternInfo(info: FinderPatternInfo): DetectorResult;
+    private static createTransform;
+    private static sampleGrid;
+    /**
+     * <p>Computes the dimension (number of modules on a size) of the QR Code based on the position
+     * of the finder patterns and estimated module size.</p>
+     */
+    private static computeDimension;
+    /**
+     * <p>Computes an average estimated module size based on estimated derived from the positions
+     * of the three finder patterns.</p>
+     *
+     * @param topLeft detected top-left finder pattern center
+     * @param topRight detected top-right finder pattern center
+     * @param bottomLeft detected bottom-left finder pattern center
+     * @return estimated module size
+     */
+    protected calculateModuleSize(topLeft: ResultPoint, topRight: ResultPoint, bottomLeft: ResultPoint): number;
+    /**
+     * <p>Estimates module size based on two finder patterns -- it uses
+     * {@link #sizeOfBlackWhiteBlackRunBothWays(int, int, int, int)} to figure the
+     * width of each, measuring along the axis between their centers.</p>
+     */
+    private calculateModuleSizeOneWay;
+    /**
+     * See {@link #sizeOfBlackWhiteBlackRun(int, int, int, int)}; computes the total width of
+     * a finder pattern by looking for a black-white-black run from the center in the direction
+     * of another point (another finder pattern center), and in the opposite direction too.
+     */
+    private sizeOfBlackWhiteBlackRunBothWays;
+    /**
+     * <p>This method traces a line from a point in the image, in the direction towards another point.
+     * It begins in a black region, and keeps going until it finds white, then black, then white again.
+     * It reports the distance from the start to this point.</p>
+     *
+     * <p>This is used when figuring out how wide a finder pattern is, when the finder pattern
+     * may be skewed or rotated.</p>
+     */
+    private sizeOfBlackWhiteBlackRun;
+    /**
+     * <p>Attempts to locate an alignment pattern in a limited region of the image, which is
+     * guessed to contain it. This method uses {@link AlignmentPattern}.</p>
+     *
+     * @param overallEstModuleSize estimated module size so far
+     * @param estAlignmentX x coordinate of center of area probably containing alignment pattern
+     * @param estAlignmentY y coordinate of above
+     * @param allowanceFactor number of pixels in all directions to search from the center
+     * @return {@link AlignmentPattern} if found, or null otherwise
+     * @throws NotFoundException if an unexpected error occurs during detection
+     */
+    protected findAlignmentInRegion(overallEstModuleSize: number, estAlignmentX: number, estAlignmentY: number, allowanceFactor: number): AlignmentPattern;
+}

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

@@ -0,0 +1,26 @@
+import ResultPoint from '../../ResultPoint';
+/**
+ * <p>Encapsulates a finder pattern, which are the three square patterns found in
+ * the corners of QR Codes. It also encapsulates a count of similar finder patterns,
+ * as a convenience to the finder's bookkeeping.</p>
+ *
+ * @author Sean Owen
+ */
+export default class FinderPattern extends ResultPoint {
+    private estimatedModuleSize;
+    private count?;
+    constructor(posX: number, posY: number, estimatedModuleSize: number, count?: number | undefined);
+    getEstimatedModuleSize(): number;
+    getCount(): number | undefined;
+    /**
+     * <p>Determines if this finder pattern "about equals" a finder pattern at the stated
+     * position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
+     */
+    aboutEquals(moduleSize: number, i: number, j: number): boolean;
+    /**
+     * Combines this object's current estimate of a finder pattern position and module size
+     * with a new estimate. It returns a new {@code FinderPattern} containing a weighted average
+     * based on count.
+     */
+    combineEstimate(i: number, j: number, newModuleSize: number): FinderPattern;
+}

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

@@ -0,0 +1,114 @@
+import BitMatrix from '../../common/BitMatrix';
+import DecodeHintType from '../../DecodeHintType';
+import ResultPointCallback from '../../ResultPointCallback';
+import FinderPattern from './FinderPattern';
+import FinderPatternInfo from './FinderPatternInfo';
+/**
+ * <p>This class attempts to find finder patterns in a QR Code. Finder patterns are the square
+ * markers at three corners of a QR Code.</p>
+ *
+ * <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.
+ *
+ * @author Sean Owen
+ */
+export default class FinderPatternFinder {
+    private image;
+    private resultPointCallback;
+    private static CENTER_QUORUM;
+    protected static MIN_SKIP: number;
+    protected static MAX_MODULES: number;
+    private possibleCenters;
+    private hasSkipped?;
+    private crossCheckStateCount;
+    /**
+     * <p>Creates a finder that will search the image for three finder patterns.</p>
+     *
+     * @param image image to search
+     */
+    constructor(image: BitMatrix, resultPointCallback: ResultPointCallback);
+    protected getImage(): BitMatrix;
+    protected getPossibleCenters(): FinderPattern[];
+    find(hints: Map<DecodeHintType, any>): FinderPatternInfo;
+    /**
+     * Given a count of black/white/black/white/black pixels just seen and an end position,
+     * figures the location of the center of this run.
+     */
+    private static centerFromEnd;
+    /**
+     * @param stateCount count of black/white/black/white/black pixels just read
+     * @return true iff the proportions of the counts is close enough to the 1/1/3/1/1 ratios
+     *         used by finder patterns to be considered a match
+     */
+    protected static foundPatternCross(stateCount: Int32Array): boolean;
+    private getCrossCheckStateCount;
+    /**
+     * After a vertical and horizontal scan finds a potential finder pattern, this method
+     * "cross-cross-cross-checks" by scanning down diagonally through the center of the possible
+     * finder pattern to see if the same proportion is detected.
+     *
+     * @param startI row where a finder pattern was detected
+     * @param centerJ center of the section that appears to cross a finder pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     *  observed in any reading state, based on the results of the horizontal scan
+     * @param originalStateCountTotal The original state count total.
+     * @return true if proportions are withing expected limits
+     */
+    private crossCheckDiagonal;
+    /**
+     * <p>After a horizontal scan finds a potential finder pattern, this method
+     * "cross-checks" by scanning down vertically through the center of the possible
+     * finder pattern to see if the same proportion is detected.</p>
+     *
+     * @param startI row where a finder pattern was detected
+     * @param centerJ center of the section that appears to cross a finder pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     * observed in any reading state, based on the results of the horizontal scan
+     * @return vertical center of finder pattern, or {@link Float#NaN} if not found
+     */
+    private crossCheckVertical;
+    /**
+     * <p>Like {@link #crossCheckVertical(int, int, int, int)}, and in fact is basically identical,
+     * except it reads horizontally instead of vertically. This is used to cross-cross
+     * check a vertical cross check and locate the real center of the alignment pattern.</p>
+     */
+    private crossCheckHorizontal;
+    /**
+     * <p>This is called when a horizontal scan finds a possible alignment pattern. It will
+     * cross check with a vertical scan, and if successful, will, ah, cross-cross-check
+     * with another horizontal scan. This is needed primarily to locate the real horizontal
+     * center of the pattern in cases of extreme skew.
+     * And then we cross-cross-cross check with another diagonal scan.</p>
+     *
+     * <p>If that succeeds the finder pattern location is added to a list that tracks
+     * the number of times each location has been nearly-matched as a finder pattern.
+     * Each additional find is more evidence that the location is in fact a finder
+     * pattern center
+     *
+     * @param stateCount reading state module counts from horizontal scan
+     * @param i row where finder pattern may be found
+     * @param j end of possible finder pattern in row
+     * @param pureBarcode true if in "pure barcode" mode
+     * @return true if a finder pattern candidate was found this time
+     */
+    protected handlePossibleCenter(stateCount: Int32Array, i: number, j: number, pureBarcode: boolean): boolean;
+    /**
+     * @return number of rows we could safely skip during scanning, based on the first
+     *         two finder patterns that have been located. In some cases their position will
+     *         allow us to infer that the third pattern must lie below a certain point farther
+     *         down in the image.
+     */
+    private findRowSkip;
+    /**
+     * @return true iff we have found at least 3 finder patterns that have been detected
+     *         at least {@link #CENTER_QUORUM} times each, and, the estimated module size of the
+     *         candidates is "pretty similar"
+     */
+    private haveMultiplyConfirmedCenters;
+    /**
+     * @return the 3 best {@link FinderPattern}s from our list of candidates. The "best" are
+     *         those that have been detected at least {@link #CENTER_QUORUM} times, and whose module
+     *         size differs from the average among those patterns the least
+     * @throws NotFoundException if 3 such finder patterns do not exist
+     */
+    private selectBestPatterns;
+}

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

@@ -0,0 +1,16 @@
+import FinderPattern from './FinderPattern';
+/**
+ * <p>Encapsulates information about finder patterns in an image, including the location of
+ * the three finder patterns, and their estimated module size.</p>
+ *
+ * @author Sean Owen
+ */
+export default class FinderPatternInfo {
+    private bottomLeft;
+    private topLeft;
+    private topRight;
+    constructor(patternCenters: FinderPattern[]);
+    getBottomLeft(): FinderPattern;
+    getTopLeft(): FinderPattern;
+    getTopRight(): FinderPattern;
+}

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

@@ -0,0 +1,7 @@
+export default class BlockPair {
+    private dataBytes;
+    private errorCorrectionBytes;
+    constructor(dataBytes: Uint8Array, errorCorrectionBytes: Uint8Array);
+    getDataBytes(): Uint8Array;
+    getErrorCorrectionBytes(): Uint8Array;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * JAVAPORT: The original code was a 2D array of ints, but since it only ever gets assigned
+ * -1, 0, and 1, I'm going to use less memory and go with bytes.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export default class ByteMatrix {
+    private width;
+    private height;
+    private bytes;
+    constructor(width: number, height: number);
+    getHeight(): number;
+    getWidth(): number;
+    get(x: number, y: number): number;
+    /**
+     * @return an internal representation as bytes, in row-major order. array[y][x] represents point (x,y)
+     */
+    getArray(): Array<Uint8Array>;
+    setNumber(x: number, y: number, value: number): void;
+    setBoolean(x: number, y: number, value: boolean): void;
+    clear(value: number): void;
+    equals(o: any): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,85 @@
+import ErrorCorrectionLevel from '../decoder/ErrorCorrectionLevel';
+import Mode from '../decoder/Mode';
+import Version from '../decoder/Version';
+import QRCode from './QRCode';
+/**
+ * @author satorux@google.com (Satoru Takabayashi) - creator
+ * @author dswitkin@google.com (Daniel Switkin) - ported from C++
+ */
+export default class Encoder {
+    private static ALPHANUMERIC_TABLE;
+    static DEFAULT_BYTE_MODE_ENCODING: string;
+    private constructor();
+    private static calculateMaskPenalty;
+    /**
+     * @param content text to encode
+     * @param ecLevel error correction level to use
+     * @return {@link QRCode} representing the encoded QR code
+     * @throws WriterException if encoding can't succeed, because of for example invalid content
+     *   or configuration
+     */
+    static encode(content: string, ecLevel: ErrorCorrectionLevel, hints?: Map<EncodeHintType, any>): QRCode;
+    /**
+     * Decides the smallest version of QR code that will contain all of the provided data.
+     *
+     * @throws WriterException if the data cannot fit in any version
+     */
+    private static recommendVersion;
+    private static calculateBitsNeeded;
+    /**
+     * @return the code point of the table used in alphanumeric mode or
+     *  -1 if there is no corresponding code in the table.
+     */
+    static getAlphanumericCode(code: number): number;
+    /**
+     * Choose the best mode by examining the content. Note that 'encoding' is used as a hint;
+     * if it is Shift_JIS, and the input is only double-byte Kanji, then we return {@link Mode#KANJI}.
+     */
+    static chooseMode(content: string, encoding?: string): Mode;
+    private static isOnlyDoubleByteKanji;
+    private static chooseMaskPattern;
+    private static chooseVersion;
+    /**
+     * @return true if the number of input bits will fit in a code with the specified version and
+     * error correction level.
+     */
+    private static willFit;
+    /**
+     * Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).
+     */
+    static terminateBits(numDataBytes: number, bits: BitArray): void;
+    /**
+     * Get number of data bytes and number of error correction bytes for block id "blockID". Store
+     * the result in "numDataBytesInBlock", and "numECBytesInBlock". See table 12 in 8.5.1 of
+     * JISX0510:2004 (p.30)
+     */
+    static getNumDataBytesAndNumECBytesForBlockID(numTotalBytes: number, numDataBytes: number, numRSBlocks: number, blockID: number, numDataBytesInBlock: Int32Array, numECBytesInBlock: Int32Array): void;
+    /**
+     * Interleave "bits" with corresponding error correction bytes. On success, store the result in
+     * "result". The interleave rule is complicated. See 8.6 of JISX0510:2004 (p.37) for details.
+     */
+    static interleaveWithECBytes(bits: BitArray, numTotalBytes: number, numDataBytes: number, numRSBlocks: number): BitArray;
+    static generateECBytes(dataBytes: Uint8Array, numEcBytesInBlock: number): Uint8Array;
+    /**
+     * Append mode info. On success, store the result in "bits".
+     */
+    static appendModeInfo(mode: Mode, bits: BitArray): void;
+    /**
+     * Append length info. On success, store the result in "bits".
+     */
+    static appendLengthInfo(numLetters: number, version: Version, mode: Mode, bits: BitArray): void;
+    /**
+     * Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
+     */
+    static appendBytes(content: string, mode: Mode, bits: BitArray, encoding: string): void;
+    private static getDigit;
+    private static isDigit;
+    static appendNumericBytes(content: string, bits: BitArray): void;
+    static appendAlphanumericBytes(content: string, bits: BitArray): void;
+    static append8BitBytes(content: string, bits: BitArray, encoding: string): void;
+    /**
+     * @throws WriterException
+     */
+    static appendKanjiBytes(content: string, bits: BitArray): void;
+    private static appendECI;
+}