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

package/lib/node/lib/qrcode/QRCodeMinimal.d.ts

@@ -0,0 +1,58 @@
+import { ErrorCorrectLevel } from './ErrorCorrectLevel.js';
+import { QRData } from './QRData.js';
+type TypeNumber = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40;
+declare const TypeNumber: { [P in TypeNumber]: P; };
+export { TypeNumber };
+export declare enum ErrorCorrectionLevel {
+    L = "L",
+    M = "M",
+    Q = "Q",
+    H = "H"
+}
+export declare enum Mode {
+    numeric = "numeric",
+    alphanumeric = "alphanumeric",
+    /**
+     * Default
+     */
+    byte = "byte",
+    kanji = "kanji",
+    unicode = "unicode"
+}
+/**
+ * QRCode
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRCodeMinimal {
+    static stringToBytesFuncs: {
+        [encoding: string]: (s: string) => number[];
+    };
+    private static PAD0;
+    private static PAD1;
+    private typeNumber;
+    private errorCorrectLevel;
+    private qrDataList;
+    private modules;
+    private moduleCount;
+    constructor(typeNumber?: TypeNumber, errorCorrectionLevel?: `${ErrorCorrectionLevel}`);
+    getTypeNumber(): number;
+    setTypeNumber(typeNumber: number): void;
+    getErrorCorrectLevel(): ErrorCorrectLevel;
+    setErrorCorrectLevel(errorCorrectLevel: ErrorCorrectLevel): void;
+    clearData(): void;
+    addData(qrData: QRData | string, mode?: `${Mode}`): void;
+    isDark(row: number, col: number): boolean;
+    getModuleCount(): number;
+    make(): void;
+    private getBestMaskPattern;
+    private makeImpl;
+    private mapData;
+    private setupPositionAdjustPattern;
+    private setupPositionProbePattern;
+    private setupTimingPattern;
+    private setupTypeNumber;
+    private setupTypeInfo;
+    static createData(typeNumber: number, errorCorrectLevel: ErrorCorrectLevel, dataArray: QRData[]): number[];
+    private static createBytes;
+}

package/lib/node/lib/qrcode/QRData.d.ts

@@ -0,0 +1,17 @@
+import { BitBuffer } from './BitBuffer.js';
+import { Mode } from './Mode.js';
+/**
+ * QRData
+ *
+ * @author Kazuhiko Arase
+ */
+export declare abstract class QRData {
+    private mode;
+    private data;
+    constructor(mode: Mode, data: string);
+    getMode(): Mode;
+    getData(): string;
+    abstract getLength(): number;
+    abstract write(buffer: BitBuffer): void;
+    getLengthInBits(typeNumber: number): number;
+}

package/lib/node/lib/qrcode/QRKanji.d.ts

@@ -0,0 +1,13 @@
+import { BitBuffer } from './BitBuffer.js';
+import { QRData } from './QRData.js';
+/**
+ * QRKanji(SJIS only)
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRKanji extends QRData {
+    private stringToBytes;
+    constructor(data: string, stringToBytes: (s: string) => number[]);
+    write(buffer: BitBuffer): void;
+    getLength(): number;
+}

package/lib/node/lib/qrcode/QRMath.d.ts

@@ -0,0 +1,13 @@
+/**
+ * QRMath
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRMath {
+    constructor();
+    static initialize: void;
+    private static EXP_TABLE;
+    private static LOG_TABLE;
+    static glog(n: number): number;
+    static gexp(n: number): number;
+}

package/lib/node/lib/qrcode/QRNumber.d.ts

@@ -0,0 +1,14 @@
+import { BitBuffer } from './BitBuffer.js';
+import { QRData } from './QRData.js';
+/**
+ * QRNumber
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRNumber extends QRData {
+    constructor(data: string);
+    write(buffer: BitBuffer): void;
+    getLength(): number;
+    private static strToNum;
+    private static chatToNum;
+}

package/lib/node/lib/qrcode/QRUtil.d.ts

@@ -0,0 +1,25 @@
+import { ErrorCorrectLevel } from './ErrorCorrectLevel.js';
+import { Mode } from './Mode.js';
+import { Polynomial } from './Polynomial.js';
+import { QRCodeMinimal } from './QRCodeMinimal.js';
+/**
+ * QRUtil
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class QRUtil {
+    constructor();
+    static getPatternPosition(typeNumber: number): number[];
+    private static PATTERN_POSITION_TABLE;
+    private static MAX_LENGTH;
+    static getMaxLength(typeNumber: number, mode: Mode, errorCorrectLevel: ErrorCorrectLevel): number;
+    static getErrorCorrectPolynomial(errorCorrectLength: number): Polynomial;
+    static getMaskFunc(maskPattern: number): (i: number, j: number) => boolean;
+    static getLostPoint(qrCode: QRCodeMinimal): number;
+    static getBCHTypeInfo(data: number): number;
+    static getBCHTypeNumber(data: number): number;
+    private static G15;
+    private static G18;
+    private static G15_MASK;
+    private static getBCHDigit;
+}

package/lib/node/lib/qrcode/RSBlock.d.ts

@@ -0,0 +1,16 @@
+import { ErrorCorrectLevel } from './ErrorCorrectLevel.js';
+/**
+ * RSBlock
+ *
+ * @author Kazuhiko Arase
+ */
+export declare class RSBlock {
+    private totalCount;
+    private dataCount;
+    private static RS_BLOCK_TABLE;
+    constructor(totalCount: number, dataCount: number);
+    getDataCount(): number;
+    getTotalCount(): number;
+    static getRSBlocks(typeNumber: number, errorCorrectLevel: ErrorCorrectLevel): RSBlock[];
+    private static getRsBlockTable;
+}

package/lib/node/lib/text/createStringToBytes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * createStringToBytes
+ *
+ * @author Kazuhiko Arase
+ * @param unicodeData base64 string of byte array.
+ * [16bit Unicode],[16bit Bytes], ...
+ * @param numChars
+ */
+export declare function createStringToBytes(unicodeData: string, numChars: number): (s: string) => number[];

package/lib/node/lib/text/stringToBytes_SJIS.d.ts

@@ -0,0 +1,8 @@
+/**
+ * stringToBytes_SJIS
+ *
+ * @author Kazuhiko Arase
+ */
+export declare const stringToBytes_SJIS: {
+    SJIS: (s: string) => number[];
+};

package/lib/node/lib/text/stringToBytes_UTF8.d.ts

@@ -0,0 +1,7 @@
+/**
+ * stringToBytes_UTF8
+ * contributed by elhigu
+ */
+export declare const stringToBytes_UTF8: {
+    UTF8: (s: string) => number[];
+};

package/lib/node/lib/zbar-wasm/index.d.ts

@@ -0,0 +1 @@
+declare var zbarWasm: {};

package/lib/node/lib/zxing-js/src/browser/BrowserCodeReader.d.ts

@@ -0,0 +1,150 @@
+import BinaryBitmap from '../core/BinaryBitmap';
+import DecodeHintType from '../core/DecodeHintType';
+import Reader from '../core/Reader';
+import Result from '../core/Result';
+import { HTMLVisualMediaElement } from './HTMLVisualMediaElement';
+/**
+ *
+ * Base class for browser code reader.
+ */
+export declare class BrowserCodeReader {
+    protected readonly reader: Reader;
+    protected timeBetweenScansMillis: number;
+    protected _hints?: Map<DecodeHintType, any> | undefined;
+    /**
+     * If navigator is present.
+     */
+    get hasNavigator(): boolean;
+    /**
+     * If mediaDevices under navigator is supported.
+     */
+    get isMediaDevicesSuported(): boolean;
+    /**
+     * If enumerateDevices under navigator is supported.
+     */
+    get canEnumerateDevices(): boolean;
+    /**
+     * Delay time between decode attempts made by the scanner.
+     */
+    protected _timeBetweenDecodingAttempts: number;
+    /** Time between two decoding tries in milli seconds. */
+    get timeBetweenDecodingAttempts(): number;
+    /**
+     * Change the time span the decoder waits between two decoding tries.
+     *
+     * @param {number} millis Time between two decoding tries in milli seconds.
+     */
+    set timeBetweenDecodingAttempts(millis: number);
+    /**
+     * The HTML canvas element, used to draw the video or image's frame for decoding.
+     */
+    protected captureCanvas: HTMLCanvasElement;
+    /**
+     * The HTML canvas element context.
+     */
+    protected captureCanvasContext: CanvasRenderingContext2D;
+    /**
+     * The HTML image element, used as a fallback for the video element when decoding.
+     */
+    protected imageElement: HTMLImageElement;
+    /**
+     * Should contain the current registered listener for image loading,
+     * used to unregister that listener when needed.
+     */
+    protected imageLoadedListener: EventListener;
+    /**
+     * Sets the hints.
+     */
+    set hints(hints: Map<DecodeHintType, any>);
+    /**
+     * Sets the hints.
+     */
+    get hints(): Map<DecodeHintType, any>;
+    /**
+     * Creates an instance of BrowserCodeReader.
+     * @param {Reader} reader The reader instance to decode the barcode
+     * @param {number} [timeBetweenScansMillis=500] the time delay between subsequent successful decode tries
+     *
+     * @memberOf BrowserCodeReader
+     */
+    constructor(reader: Reader, timeBetweenScansMillis?: number, _hints?: Map<DecodeHintType, any> | undefined);
+    /**
+     * Searches and validates a media element.
+     */
+    getMediaElement(mediaElementId: string, type: string): HTMLVisualMediaElement;
+    /**
+     * Decodes the barcode from an image.
+     *
+     * @param {(string|HTMLImageElement)} [source] The image element that can be either an element id or the element itself. Can be undefined in which case the decoding will be done from the imageUrl parameter.
+     * @param {string} [url]
+     * @returns {Promise<Result>} The decoding result.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    decodeFromImage(source?: string | HTMLImageElement, url?: string): Promise<Result>;
+    /**
+     * Decodes something from an image HTML element.
+     */
+    decodeFromImageElement(source: string | HTMLImageElement): Promise<Result>;
+    /**
+     * Decodes an image from a URL.
+     */
+    decodeFromImageUrl(url?: string): Promise<Result>;
+    private _decodeOnLoadImage;
+    isImageLoaded(img: HTMLImageElement): boolean;
+    prepareImageElement(imageSource?: HTMLImageElement | string): HTMLImageElement;
+    /**
+     * Tries to decode from the image input until it finds some value.
+     */
+    decodeOnce(element: HTMLVisualMediaElement, retryIfNotFound?: boolean, retryIfChecksumOrFormatError?: boolean): Promise<Result>;
+    /**
+     * Gets the BinaryBitmap for ya! (and decodes it)
+     */
+    decode(element: HTMLVisualMediaElement): Result;
+    /**
+     * Creates a binaryBitmap based in some image source.
+     *
+     * @param mediaElement HTML element containing drawable image source.
+     */
+    createBinaryBitmap(mediaElement: HTMLVisualMediaElement): BinaryBitmap;
+    /**
+     *
+     */
+    protected getCaptureCanvasContext(mediaElement?: HTMLVisualMediaElement): CanvasRenderingContext2D;
+    /**
+     *
+     */
+    protected getCaptureCanvas(mediaElement?: HTMLVisualMediaElement): HTMLCanvasElement;
+    /**
+     * Ovewriting this allows you to manipulate the snapshot image in anyway you want before decode.
+     */
+    drawImageOnCanvas(srcElement: HTMLImageElement, dimensions?: {
+        sx: number;
+        sy: number;
+        sWidth: number;
+        sHeight: number;
+        dx: number;
+        dy: number;
+        dWidth: number;
+        dHeight: number;
+    }, canvasElementContext?: CanvasRenderingContext2D): void;
+    /**
+     * Call the encapsulated readers decode
+     */
+    decodeBitmap(binaryBitmap: BinaryBitmap): Result;
+    /**
+     * 🖌 Prepares the canvas for capture and scan frames.
+     */
+    createCaptureCanvas(mediaElement?: HTMLVisualMediaElement): HTMLCanvasElement;
+    /**
+     * Resets the code reader to the initial state.
+     *
+     * @memberOf BrowserCodeReader
+     */
+    reset(): void;
+    private _destroyImageElement;
+    /**
+     * Destroys the capture canvas and context.
+     */
+    private _destroyCaptureCanvas;
+}

package/lib/node/lib/zxing-js/src/browser/BrowserQRCodeReader.d.ts

@@ -0,0 +1,29 @@
+import BinaryBitmap from '../core/BinaryBitmap';
+import Result from '../core/Result';
+import { BrowserCodeReader } from './BrowserCodeReader';
+/**
+ * QR Code reader to use from browser with improved error handling.
+ * This implementation properly handles promise rejections when QR codes can't be decoded.
+ */
+export declare class BrowserQRCodeReader extends BrowserCodeReader {
+    private qrReader;
+    private inProgressDecodes;
+    constructor(timeBetweenScansMillis?: number);
+    /**
+     * Safely reset the reader without causing message channel issues
+     */
+    private safeReset;
+    /**
+     * Overrides the decodeBitmap method to ensure proper error handling and reader reset.
+     * This makes BrowserQRCodeReader behave consistently with BrowserMultiFormatReader.
+     */
+    decodeBitmap(binaryBitmap: BinaryBitmap): Result;
+    /**
+     * Overrides decodeFromImageUrl to ensure proper resource handling
+     */
+    decodeFromImageUrl(url: string): Promise<Result>;
+    /**
+     * Override the reset method to safely clean up resources
+     */
+    reset(): void;
+}

package/lib/node/lib/zxing-js/src/browser/HTMLCanvasElementLuminanceSource.d.ts

@@ -0,0 +1,27 @@
+import LuminanceSource from '../core/LuminanceSource';
+export declare class HTMLCanvasElementLuminanceSource extends LuminanceSource {
+    private canvas;
+    private buffer;
+    private static DEGREE_TO_RADIANS;
+    private static FRAME_INDEX;
+    private tempCanvasElement;
+    constructor(canvas: HTMLCanvasElement, doAutoInvert?: boolean);
+    private static makeBufferFromCanvasImageData;
+    private static toGrayscaleBuffer;
+    getRow(y: number, row: Uint8ClampedArray): Uint8ClampedArray;
+    getMatrix(): Uint8ClampedArray;
+    isCropSupported(): boolean;
+    crop(left: number, top: number, width: number, height: number): LuminanceSource;
+    /**
+     * This is always true, since the image is a gray-scale image.
+     *
+     * @return true
+     */
+    isRotateSupported(): boolean;
+    rotateCounterClockwise(): LuminanceSource;
+    rotateCounterClockwise45(): LuminanceSource;
+    private getTempCanvasElement;
+    private rotate;
+    invert(): LuminanceSource;
+    hightContrast(threshold?: number): LuminanceSource;
+}

package/lib/node/lib/zxing-js/src/browser/HTMLVisualMediaElement.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTML elements that can be decoded.
+ */
+export type HTMLVisualMediaElement = HTMLVideoElement | HTMLImageElement;

package/lib/node/lib/zxing-js/src/browser.d.ts

@@ -0,0 +1,3 @@
+export * from './browser/BrowserQRCodeReader';
+export * from './browser/HTMLCanvasElementLuminanceSource';
+export * from './core/UniversalLuminanceSource';

package/lib/node/lib/zxing-js/src/core/ArgumentException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArgumentException extends Exception {
+    static readonly kind: string;
+}

package/lib/node/lib/zxing-js/src/core/ArithmeticException.d.ts

@@ -0,0 +1,7 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArithmeticException extends Exception {
+    static readonly kind: string;
+}

package/lib/node/lib/zxing-js/src/core/ArrayIndexOutOfBoundsException.d.ts

@@ -0,0 +1,10 @@
+import IndexOutOfBoundsException from './IndexOutOfBoundsException';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
+    index: number;
+    message: string;
+    static readonly kind: string;
+    constructor(index: number, message: string);
+}

package/lib/node/lib/zxing-js/src/core/BarcodeFormat.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Enumerates barcode formats known to this package. Please keep alphabetized.
+ *
+ * @author Sean Owen
+ */
+declare enum BarcodeFormat {
+    /** Aztec 2D barcode format. */
+    AZTEC = 0,
+    /** CODABAR 1D format. */
+    CODABAR = 1,
+    /** Code 39 1D format. */
+    CODE_39 = 2,
+    /** Code 93 1D format. */
+    CODE_93 = 3,
+    /** Code 128 1D format. */
+    CODE_128 = 4,
+    /** Data Matrix 2D barcode format. */
+    DATA_MATRIX = 5,
+    /** EAN-8 1D format. */
+    EAN_8 = 6,
+    /** EAN-13 1D format. */
+    EAN_13 = 7,
+    /** ITF (Interleaved Two of Five) 1D format. */
+    ITF = 8,
+    /** MaxiCode 2D barcode format. */
+    MAXICODE = 9,
+    /** PDF417 format. */
+    PDF_417 = 10,
+    /** QR Code 2D barcode format. */
+    QR_CODE = 11,
+    /** RSS 14 */
+    RSS_14 = 12,
+    /** RSS EXPANDED */
+    RSS_EXPANDED = 13,
+    /** UPC-A 1D format. */
+    UPC_A = 14,
+    /** UPC-E 1D format. */
+    UPC_E = 15,
+    /** UPC/EAN extension format. Not a stand-alone format. */
+    UPC_EAN_EXTENSION = 16
+}
+export default BarcodeFormat;

package/lib/node/lib/zxing-js/src/core/Binarizer.d.ts

@@ -0,0 +1,53 @@
+import BitArray from './common/BitArray';
+import BitMatrix from './common/BitMatrix';
+import LuminanceSource from './LuminanceSource';
+/**
+ * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
+ * It allows the algorithm to vary polymorphically, for example allowing a very expensive
+ * thresholding technique for servers and a fast one for mobile. It also permits the implementation
+ * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+declare abstract class Binarizer {
+    private source;
+    protected constructor(source: LuminanceSource);
+    getLuminanceSource(): LuminanceSource;
+    /**
+     * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+     * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+     * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+     * For callers which only examine one row of pixels at a time, the same BitArray should be reused
+     * and passed in with each call for performance. However it is legal to keep more than one row
+     * at a time if needed.
+     *
+     * @param y The row to fetch, which must be in [0, bitmap height)
+     * @param row An optional preallocated array. If null or too small, it will be ignored.
+     *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+     * @return The array of bits for this row (true means black).
+     * @throws NotFoundException if row can't be binarized
+     */
+    abstract getBlackRow(y: number, row: BitArray): BitArray;
+    /**
+     * Converts a 2D array of luminance data to 1 bit data. As above, assume this method is expensive
+     * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+     * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+     * fetched using getBlackRow(), so don't mix and match between them.
+     *
+     * @return The 2D array of bits for the image (true means black).
+     * @throws NotFoundException if image can't be binarized to make a matrix
+     */
+    abstract getBlackMatrix(): BitMatrix;
+    /**
+     * Creates a new object with the same type as this Binarizer implementation, but with pristine
+     * state. This is needed because Binarizer implementations may be stateful, e.g. keeping a cache
+     * of 1 bit data. See Effective Java for why we can't use Java's clone() method.
+     *
+     * @param source The LuminanceSource this Binarizer will operate on.
+     * @return A new concrete Binarizer implementation object.
+     */
+    abstract createBinarizer(source: LuminanceSource): Binarizer;
+    getWidth(): number;
+    getHeight(): number;
+}
+export default Binarizer;

package/lib/node/lib/zxing-js/src/core/BinaryBitmap.d.ts

@@ -0,0 +1,78 @@
+/**
+ * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+ * accept a BinaryBitmap and attempt to decode it.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+import Binarizer from './Binarizer';
+import BitArray from './common/BitArray';
+import BitMatrix from './common/BitMatrix';
+export default class BinaryBitmap {
+    private binarizer;
+    private matrix;
+    constructor(binarizer: Binarizer);
+    /**
+     * @return The width of the bitmap.
+     */
+    getWidth(): number;
+    /**
+     * @return The height of the bitmap.
+     */
+    getHeight(): number;
+    /**
+     * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+     * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+     * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+     *
+     * @param y The row to fetch, which must be in [0, bitmap height)
+     * @param row An optional preallocated array. If null or too small, it will be ignored.
+     *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+     * @return The array of bits for this row (true means black).
+     * @throws NotFoundException if row can't be binarized
+     */
+    getBlackRow(y: number, row: BitArray): BitArray;
+    /**
+     * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
+     * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+     * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+     * fetched using getBlackRow(), so don't mix and match between them.
+     *
+     * @return The 2D array of bits for the image (true means black).
+     * @throws NotFoundException if image can't be binarized to make a matrix
+     */
+    getBlackMatrix(): BitMatrix;
+    /**
+     * @return Whether this bitmap can be cropped.
+     */
+    isCropSupported(): boolean;
+    /**
+     * Returns a new object with cropped image data. Implementations may keep a reference to the
+     * original data rather than a copy. Only callable if isCropSupported() is true.
+     *
+     * @param left The left coordinate, which must be in [0,getWidth())
+     * @param top The top coordinate, which must be in [0,getHeight())
+     * @param width The width of the rectangle to crop.
+     * @param height The height of the rectangle to crop.
+     * @return A cropped version of this object.
+     */
+    crop(left: number, top: number, width: number, height: number): BinaryBitmap;
+    /**
+     * @return Whether this bitmap supports counter-clockwise rotation.
+     */
+    isRotateSupported(): boolean;
+    /**
+     * Returns a new object with rotated image data by 90 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise(): BinaryBitmap;
+    /**
+     * Returns a new object with rotated image data by 45 degrees counterclockwise.
+     * Only callable if {@link #isRotateSupported()} is true.
+     *
+     * @return A rotated version of this object.
+     */
+    rotateCounterClockwise45(): BinaryBitmap;
+    toString(): string;
+}

package/lib/node/lib/zxing-js/src/core/ChecksumException.d.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+/**
+ * Custom Error class of type Exception.
+ */
+export default class ChecksumException extends Exception {
+    static readonly kind: string;
+    static getChecksumInstance(): ChecksumException;
+}