declare namespace ThinNeo {
    class Base64 {
        static lookup: any[];
        static revLookup: any[];
        static code: string;
        static binited: boolean;
        static init(): void;
        static placeHoldersCount(b64: string): number;
        static byteLength(b64: string): number;
        static toByteArray(b64: string): Uint8Array;
        static tripletToBase64(num: any): any;
        static encodeChunk(uint8: any, start: any, end: any): string;
        static fromByteArray(uint8: Uint8Array): string;
    }
}
declare module ThinNeo {
    class Helper {
        static GetPrivateKeyFromWIF(wif: string): Uint8Array;
        static GetWifFromPrivateKey(prikey: Uint8Array): string;
        static GetPublicKeyFromPrivateKey(privateKey: Uint8Array): Uint8Array;
        static Hash160(data: Uint8Array): Uint8Array;
        static GetAddressCheckScriptFromPublicKey(publicKey: Uint8Array): Uint8Array;
        static GetPublicKeyScriptHashFromPublicKey(publicKey: Uint8Array): Uint8Array;
        static GetScriptHashFromScript(script: Uint8Array): Uint8Array;
        static GetAddressFromScriptHash(scripthash: Uint8Array): string;
        static GetAddressFromPublicKey(publicKey: Uint8Array): string;
        static GetPublicKeyScriptHash_FromAddress(address: string): Uint8Array;
        static Sign(message: Uint8Array, privateKey: Uint8Array): Uint8Array;
        static VerifySignature(message: Uint8Array, signature: Uint8Array, pubkey: Uint8Array): boolean;
        static String2Bytes(str: any): Uint8Array;
        static Bytes2String(_arr: Uint8Array): string;
        static Aes256Encrypt(src: string, key: string): string;
        static Aes256Encrypt_u8(src: Uint8Array, key: Uint8Array): Uint8Array;
        static Aes256Decrypt_u8(encryptedkey: Uint8Array, key: Uint8Array): Uint8Array;
        static GetNep2FromPrivateKey(prikey: Uint8Array, passphrase: string, n: number, r: number, p: number, callback: (info: string, result: string) => void): void;
        static GetPrivateKeyFromNep2(nep2: string, passphrase: string, n: number, r: number, p: number, callback: (info: string, result: string | Uint8Array) => void): void;
    }
}
declare module ThinNeo {
    enum OpCode {
        PUSH0 = 0,
        PUSHF = 0,
        PUSHBYTES1 = 1,
        PUSHBYTES75 = 75,
        PUSHDATA1 = 76,
        PUSHDATA2 = 77,
        PUSHDATA4 = 78,
        PUSHM1 = 79,
        PUSH1 = 81,
        PUSHT = 81,
        PUSH2 = 82,
        PUSH3 = 83,
        PUSH4 = 84,
        PUSH5 = 85,
        PUSH6 = 86,
        PUSH7 = 87,
        PUSH8 = 88,
        PUSH9 = 89,
        PUSH10 = 90,
        PUSH11 = 91,
        PUSH12 = 92,
        PUSH13 = 93,
        PUSH14 = 94,
        PUSH15 = 95,
        PUSH16 = 96,
        NOP = 97,
        JMP = 98,
        JMPIF = 99,
        JMPIFNOT = 100,
        CALL = 101,
        RET = 102,
        APPCALL = 103,
        SYSCALL = 104,
        TAILCALL = 105,
        DUPFROMALTSTACK = 106,
        TOALTSTACK = 107,
        FROMALTSTACK = 108,
        XDROP = 109,
        XSWAP = 114,
        XTUCK = 115,
        DEPTH = 116,
        DROP = 117,
        DUP = 118,
        NIP = 119,
        OVER = 120,
        PICK = 121,
        ROLL = 122,
        ROT = 123,
        SWAP = 124,
        TUCK = 125,
        CAT = 126,
        SUBSTR = 127,
        LEFT = 128,
        RIGHT = 129,
        SIZE = 130,
        INVERT = 131,
        AND = 132,
        OR = 133,
        XOR = 134,
        EQUAL = 135,
        INC = 139,
        DEC = 140,
        SIGN = 141,
        NEGATE = 143,
        ABS = 144,
        NOT = 145,
        NZ = 146,
        ADD = 147,
        SUB = 148,
        MUL = 149,
        DIV = 150,
        MOD = 151,
        SHL = 152,
        SHR = 153,
        BOOLAND = 154,
        BOOLOR = 155,
        NUMEQUAL = 156,
        NUMNOTEQUAL = 158,
        LT = 159,
        GT = 160,
        LTE = 161,
        GTE = 162,
        MIN = 163,
        MAX = 164,
        WITHIN = 165,
        SHA1 = 167,
        SHA256 = 168,
        HASH160 = 169,
        HASH256 = 170,
        CSHARPSTRHASH32 = 171,
        JAVAHASH32 = 173,
        CHECKSIG = 172,
        CHECKMULTISIG = 174,
        ARRAYSIZE = 192,
        PACK = 193,
        UNPACK = 194,
        PICKITEM = 195,
        SETITEM = 196,
        NEWARRAY = 197,
        NEWSTRUCT = 198,
        SWITCH = 208,
        THROW = 240,
        THROWIFNOT = 241,
    }
}
declare namespace ThinNeo {
    class ScriptBuilder {
        writer: number[];
        Offset: number;
        constructor();
        _WriteUint8(num: number): void;
        _WriteUint16(num: number): void;
        _WriteUint32(num: number): void;
        _WriteUint8Array(nums: Uint8Array): void;
        _ConvertInt16ToBytes(num: number): Uint8Array;
        Emit(op: OpCode, arg?: Uint8Array): ScriptBuilder;
        EmitAppCall(scriptHash: Uint8Array, useTailCall?: boolean): ScriptBuilder;
        EmitJump(op: OpCode, offset: number): ScriptBuilder;
        EmitPushNumber(number: Neo.BigInteger): ScriptBuilder;
        EmitPushBool(data: boolean): ScriptBuilder;
        EmitPushBytes(data: Uint8Array): ScriptBuilder;
        EmitPushString(data: string): ScriptBuilder;
        EmitSysCall(api: string): ScriptBuilder;
        ToArray(): Uint8Array;
        EmitParamJson(param: any): ScriptBuilder;
    }
}
declare namespace ThinNeo {
    enum TransactionType {
        MinerTransaction = 0,
        IssueTransaction = 1,
        ClaimTransaction = 2,
        EnrollmentTransaction = 32,
        RegisterTransaction = 64,
        ContractTransaction = 128,
        PublishTransaction = 208,
        InvocationTransaction = 209,
    }
    enum TransactionAttributeUsage {
        ContractHash = 0,
        ECDH02 = 2,
        ECDH03 = 3,
        Script = 32,
        Vote = 48,
        DescriptionUrl = 129,
        Description = 144,
        Hash1 = 161,
        Hash2 = 162,
        Hash3 = 163,
        Hash4 = 164,
        Hash5 = 165,
        Hash6 = 166,
        Hash7 = 167,
        Hash8 = 168,
        Hash9 = 169,
        Hash10 = 170,
        Hash11 = 171,
        Hash12 = 172,
        Hash13 = 173,
        Hash14 = 174,
        Hash15 = 175,
        Remark = 240,
        Remark1 = 241,
        Remark2 = 242,
        Remark3 = 243,
        Remark4 = 244,
        Remark5 = 245,
        Remark6 = 246,
        Remark7 = 247,
        Remark8 = 248,
        Remark9 = 249,
        Remark10 = 250,
        Remark11 = 251,
        Remark12 = 252,
        Remark13 = 253,
        Remark14 = 254,
        Remark15 = 255,
    }
    class Attribute {
        usage: TransactionAttributeUsage;
        data: Uint8Array;
    }
    class TransactionOutput {
        assetId: Uint8Array;
        value: Neo.Fixed8;
        toAddress: Uint8Array;
    }
    class TransactionInput {
        hash: Uint8Array;
        index: number;
    }
    class Witness {
        InvocationScript: Uint8Array;
        VerificationScript: Uint8Array;
        readonly Address: string;
    }
    interface IExtData {
        Serialize(trans: Transaction, writer: Neo.IO.BinaryWriter): void;
        Deserialize(trans: Transaction, reader: Neo.IO.BinaryReader): void;
    }
    class InvokeTransData implements IExtData {
        script: Uint8Array;
        gas: Neo.Fixed8;
        Serialize(trans: Transaction, writer: Neo.IO.BinaryWriter): void;
        Deserialize(trans: Transaction, reader: Neo.IO.BinaryReader): void;
    }
    class ClaimTransData implements IExtData {
        claims: TransactionInput[];
        Serialize(trans: Transaction, writer: Neo.IO.BinaryWriter): void;
        Deserialize(trans: Transaction, reader: Neo.IO.BinaryReader): void;
    }
    class MinerTransData implements IExtData {
        nonce: number;
        Serialize(trans: Transaction, writer: Neo.IO.BinaryWriter): void;
        Deserialize(trans: Transaction, reader: Neo.IO.BinaryReader): void;
    }
    class Transaction {
        type: TransactionType;
        version: number;
        attributes: Attribute[];
        inputs: TransactionInput[];
        outputs: TransactionOutput[];
        witnesses: Witness[];
        SerializeUnsigned(writer: Neo.IO.BinaryWriter): void;
        Serialize(writer: Neo.IO.BinaryWriter): void;
        extdata: IExtData;
        DeserializeUnsigned(ms: Neo.IO.BinaryReader): void;
        Deserialize(ms: Neo.IO.BinaryReader): void;
        GetMessage(): Uint8Array;
        GetRawData(): Uint8Array;
        AddWitness(signdata: Uint8Array, pubkey: Uint8Array, addrs: string): void;
        AddWitnessScript(vscript: Uint8Array, iscript: Uint8Array): void;
        GetHash(): Uint8Array;
    }
}
declare module ThinNeo.Compiler {
    class Avm2Asm {
        static Trans(script: Uint8Array): Op[];
    }
}
declare module ThinNeo.Compiler {
    class ByteReader {
        constructor(data: Uint8Array);
        data: Uint8Array;
        addr: number;
        ReadOP(): OpCode;
        ReadBytes(count: number): Uint8Array;
        ReadByte(): number;
        ReadUInt16(): number;
        ReadInt16(): number;
        ReadUInt32(): number;
        ReadInt32(): number;
        ReadUInt64(): number;
        ReadVarBytes(): Uint8Array;
        ReadVarInt(): number;
        readonly End: boolean;
    }
}
declare module ThinNeo.Compiler {
    enum ParamType {
        None = 0,
        ByteArray = 1,
        String = 2,
        Addr = 3,
    }
    class Op {
        addr: number;
        error: boolean;
        code: ThinNeo.OpCode;
        paramData: Uint8Array;
        paramType: ParamType;
        toString(): string;
        AsHexString(): string;
        AsString(): string;
        AsAddr(): number;
        getCodeName(): string;
    }
}
declare namespace ThinNeo {
    class contract {
        script: string;
        parameters: {
            "name": string;
            "type": string;
        }[];
        deployed: boolean;
    }
    class nep6account {
        address: string;
        nep2key: string;
        contract: contract;
        getPrivateKey(scrypt: nep6ScryptParameters, password: string, callback: (info: string, result: string | Uint8Array) => void): void;
    }
    class nep6ScryptParameters {
        N: number;
        r: number;
        p: number;
    }
    class nep6wallet {
        scrypt: nep6ScryptParameters;
        accounts: nep6account[];
        fromJsonStr(jsonstr: string): void;
        toJson(): any;
    }
}
declare namespace Neo {
    abstract class UintVariable {
        protected _bits: Uint32Array;
        readonly bits: Uint32Array;
        constructor(bits: number | Uint8Array | Uint32Array | number[]);
        compareTo(other: UintVariable): number;
        equals(other: UintVariable): boolean;
        toString(): string;
    }
}
declare namespace Neo {
    class Uint64 extends UintVariable {
        static readonly MaxValue: Uint64;
        static readonly MinValue: Uint64;
        static readonly Zero: Uint64;
        constructor(low?: number, high?: number);
        add(other: Uint64): Uint64;
        and(other: number | Uint64): Uint64;
        leftShift(shift: number): Uint64;
        not(): Uint64;
        or(other: number | Uint64): Uint64;
        static parse(str: string): Uint64;
        rightShift(shift: number): Uint64;
        subtract(other: Uint64): Uint64;
        toInt32(): number;
        toNumber(): number;
        toString(): string;
        toUint32(): number;
        xor(other: number | Uint64): Uint64;
    }
}
declare namespace Neo {
    class BigInteger {
        private _sign;
        private _bits;
        static readonly MinusOne: BigInteger;
        static readonly One: BigInteger;
        static readonly Zero: BigInteger;
        constructor(value: number | string | ArrayBuffer | Uint8Array);
        static add(x: number | BigInteger, y: number | BigInteger): BigInteger;
        add(other: number | BigInteger): BigInteger;
        private static addTo(x, y, r);
        bitLength(): number;
        private static bitLengthInternal(w);
        private clamp();
        static compare(x: number | BigInteger, y: number | BigInteger): number;
        private static compareAbs(x, y);
        compareTo(other: number | BigInteger): number;
        private static create(sign, bits, clamp?);
        static divide(x: number | BigInteger, y: number | BigInteger): BigInteger;
        divide(other: number | BigInteger): BigInteger;
        static divRem(x: number | BigInteger, y: number | BigInteger): {
            result: BigInteger;
            remainder: BigInteger;
        };
        static equals(x: number | BigInteger, y: number | BigInteger): boolean;
        equals(other: number | BigInteger): boolean;
        static fromString(str: string, radix?: number): BigInteger;
        private fromString(str, radix?);
        static fromUint8Array(arr: Uint8Array, sign?: number, littleEndian?: boolean): BigInteger;
        static fromUint8ArrayAutoSign(arr: Uint8Array, littleEndian?: boolean): BigInteger;
        private fromUint8Array(arr, sign?, littleEndian?);
        private fromUint64(i, sign);
        private static getActualLength(arr);
        private static getDoubleParts(dbl);
        getLowestSetBit(): number;
        isEven(): boolean;
        isZero(): boolean;
        leftShift(shift: number): BigInteger;
        static mod(x: number | BigInteger, y: number | BigInteger): BigInteger;
        mod(other: number | BigInteger): BigInteger;
        static modInverse(value: number | BigInteger, modulus: number | BigInteger): BigInteger;
        modInverse(modulus: number | BigInteger): BigInteger;
        static modPow(value: number | BigInteger, exponent: number | BigInteger, modulus: number | BigInteger): BigInteger;
        modPow(exponent: number | BigInteger, modulus: number | BigInteger): BigInteger;
        static multiply(x: number | BigInteger, y: number | BigInteger): BigInteger;
        multiply(other: number | BigInteger): BigInteger;
        private static multiplyTo(x, y, r, offset?);
        negate(): BigInteger;
        static parse(str: string): BigInteger;
        static pow(value: number | BigInteger, exponent: number): BigInteger;
        pow(exponent: number): BigInteger;
        static random(bitLength: number, rng?: any): BigInteger;
        static remainder(x: number | BigInteger, y: number | BigInteger): BigInteger;
        remainder(other: number | BigInteger): BigInteger;
        rightShift(shift: number): BigInteger;
        sign(): number;
        static subtract(x: number | BigInteger, y: number | BigInteger): BigInteger;
        subtract(other: number | BigInteger): BigInteger;
        private static subtractTo(x, y, r?);
        testBit(n: number): boolean;
        toInt32(): number;
        toString(radix?: number): string;
        toUint8Array(littleEndian?: boolean, length?: number): Uint8Array;
        toUint8ArrayWithSign(littleEndian?: boolean, length?: number): Uint8Array;
    }
}
declare namespace Neo {
    class Fixed8 implements IO.ISerializable {
        private data;
        static readonly MaxValue: Fixed8;
        static readonly MinusOne: Fixed8;
        static readonly MinValue: Fixed8;
        static readonly One: Fixed8;
        static readonly Satoshi: Fixed8;
        static readonly Zero: Fixed8;
        constructor(data: Uint64);
        add(other: Fixed8): Fixed8;
        compareTo(other: Fixed8): number;
        equals(other: Fixed8): boolean;
        static fromNumber(value: number): Fixed8;
        getData(): Uint64;
        static max(first: Fixed8, ...others: Fixed8[]): Fixed8;
        static min(first: Fixed8, ...others: Fixed8[]): Fixed8;
        static parse(str: string): Fixed8;
        subtract(other: Fixed8): Fixed8;
        toString(): string;
        deserialize(reader: IO.BinaryReader): void;
        serialize(writer: IO.BinaryWriter): void;
    }
}
declare type Func<T, TResult> = (arg: T) => TResult;
declare type Action<T> = Func<T, void>;
interface Array<T> {
    fill(value: T, start?: number, end?: number): any;
}
interface ArrayConstructor {
    copy<T>(src: ArrayLike<T>, srcOffset: number, dst: ArrayLike<T>, dstOffset: number, count: number): void;
    fromArray<T>(arr: ArrayLike<T>): Array<T>;
}
interface String {
    hexToBytes(): Uint8Array;
}
interface Uint8Array {
    toHexString(): string;
    clone(): Uint8Array;
    concat(data: Uint8Array): Uint8Array;
}
interface Uint8ArrayConstructor {
    fromArrayBuffer(buffer: ArrayBuffer | ArrayBufferView): Uint8Array;
}
declare class NeoMap<TKey, TValue> {
    private _map;
    private _size;
    readonly size: number;
    clear(): void;
    delete(key: TKey): boolean;
    forEach(callback: (value: TValue, key: TKey, map: NeoMap<TKey, TValue>) => void): void;
    get(key: TKey): TValue;
    has(key: TKey): boolean;
    set(key: TKey, value: TValue): void;
}
declare type PromiseExecutor<T> = (resolve: Action<T | PromiseLike<T>>, reject: Action<any>) => void;
declare enum PromiseState {
    pending = 0,
    fulfilled = 1,
    rejected = 2,
}
declare class NeoPromise<T> implements PromiseLike<T> {
    private _state;
    private _callback_attached;
    private _value;
    private _reason;
    private _onFulfilled;
    private _onRejected;
    private _next_promise;
    private _tag;
    constructor(executor: PromiseExecutor<T>);
    static all(iterable: NeoPromise<any>[]): NeoPromise<any[]>;
    catch<TResult>(onRejected: Func<any, TResult | PromiseLike<TResult>>): PromiseLike<TResult>;
    private checkState();
    private reject(reason);
    static reject(reason: any): PromiseLike<any>;
    private resolve(value);
    static resolve<T>(value: T | PromiseLike<T>): PromiseLike<T>;
    then<TResult>(onFulfilled?: Func<T, TResult | PromiseLike<TResult>>, onRejected?: Func<any, TResult | PromiseLike<TResult>>): PromiseLike<TResult>;
}
declare namespace Neo {
    class Uint160 extends UintVariable {
        static readonly Zero: Uint160;
        constructor(value?: ArrayBuffer);
        static parse(str: string): Uint160;
    }
}
declare namespace Neo {
    class Uint256 extends UintVariable {
        static readonly Zero: Uint256;
        constructor(value?: ArrayBuffer);
        static parse(str: string): Uint256;
    }
}
declare namespace Neo.IO {
    class BinaryReader {
        private input;
        private _buffer;
        private array_uint8;
        private array_int8;
        private array_uint16;
        private array_int16;
        private array_uint32;
        private array_int32;
        private array_float32;
        private array_float64;
        constructor(input: Stream);
        canRead(): number;
        close(): void;
        private fillBuffer(buffer, count);
        read(buffer: ArrayBuffer, index: number, count: number): number;
        readBoolean(): boolean;
        readByte(): number;
        readBytes(count: number): ArrayBuffer;
        readDouble(): number;
        readFixed8(): Fixed8;
        readInt16(): number;
        readInt32(): number;
        readSByte(): number;
        readSerializable(T: Function): ISerializable;
        readSerializableArray(T: Function): ISerializable[];
        readSingle(): number;
        readUint16(): number;
        readUint160(): Uint160;
        readUint256(): Uint256;
        readUint32(): number;
        readUint64(): Uint64;
        readVarBytes(max?: number): ArrayBuffer;
        readVarInt(max?: number): number;
        readVarString(): string;
    }
}
declare namespace Neo.IO {
    class BinaryWriter {
        private output;
        private _buffer;
        private array_uint8;
        private array_int8;
        private array_uint16;
        private array_int16;
        private array_uint32;
        private array_int32;
        private array_float32;
        private array_float64;
        constructor(output: Stream);
        close(): void;
        seek(offset: number, origin: SeekOrigin): number;
        write(buffer: ArrayBuffer, index?: number, count?: number): void;
        writeBoolean(value: boolean): void;
        writeByte(value: number): void;
        writeDouble(value: number): void;
        writeInt16(value: number): void;
        writeInt32(value: number): void;
        writeSByte(value: number): void;
        writeSerializableArray(array: ISerializable[]): void;
        writeSingle(value: number): void;
        writeUint16(value: number): void;
        writeUint32(value: number): void;
        writeUint64(value: Uint64): void;
        writeUintVariable(value: UintVariable): void;
        writeVarBytes(value: ArrayBuffer): void;
        writeVarInt(value: number): void;
        writeVarString(value: string): void;
    }
}
interface Uint8Array {
    asSerializable(T: Function): Neo.IO.ISerializable;
}
interface Uint8ArrayConstructor {
    fromSerializable(obj: Neo.IO.ISerializable): Uint8Array;
}
declare namespace Neo.IO {
    interface ISerializable {
        deserialize(reader: BinaryReader): void;
        serialize(writer: BinaryWriter): void;
    }
}
declare namespace Neo.IO {
    enum SeekOrigin {
        Begin = 0,
        Current = 1,
        End = 2,
    }
    abstract class Stream {
        private _array;
        abstract canRead(): boolean;
        abstract canSeek(): boolean;
        abstract canWrite(): boolean;
        close(): void;
        abstract length(): number;
        abstract position(): number;
        abstract read(buffer: ArrayBuffer, offset: number, count: number): number;
        readByte(): number;
        abstract seek(offset: number, origin: SeekOrigin): number;
        abstract setLength(value: number): void;
        abstract write(buffer: ArrayBuffer, offset: number, count: number): void;
        writeByte(value: number): void;
    }
}
declare namespace Neo.IO {
    class MemoryStream extends Stream {
        private _buffers;
        private _origin;
        private _position;
        private _length;
        private _capacity;
        private _expandable;
        private _writable;
        constructor(capacity?: number);
        constructor(buffer: ArrayBuffer, writable?: boolean);
        constructor(buffer: ArrayBuffer, index: number, count: number, writable?: boolean);
        canRead(): boolean;
        canSeek(): boolean;
        canWrite(): boolean;
        capacity(): number;
        private findBuffer(position);
        length(): number;
        position(): number;
        read(buffer: ArrayBuffer, offset: number, count: number): number;
        private readInternal(dst, srcPos);
        seek(offset: number, origin: SeekOrigin): number;
        setLength(value: number): void;
        toArray(): ArrayBuffer;
        write(buffer: ArrayBuffer, offset: number, count: number): void;
    }
}
declare namespace Neo.IO.Caching {
    interface ITrackable<TKey> {
        key: TKey;
        trackState: TrackState;
    }
}
declare namespace Neo.IO.Caching {
    class TrackableCollection<TKey, TItem extends ITrackable<TKey>> {
        private _map;
        constructor(items?: ArrayLike<TItem>);
        add(item: TItem): void;
        clear(): void;
        commit(): void;
        forEach(callback: (value: TItem, key: TKey, collection: TrackableCollection<TKey, TItem>) => void): void;
        get(key: TKey): TItem;
        getChangeSet(): TItem[];
        has(key: TKey): boolean;
        remove(key: TKey): void;
    }
}
declare namespace Neo.IO.Caching {
    enum TrackState {
        None = 0,
        Added = 1,
        Changed = 2,
        Deleted = 3,
    }
}
declare namespace Neo.Cryptography {
    class Aes {
        private static numberOfRounds;
        private static rcon;
        private static S;
        private static Si;
        private static T1;
        private static T2;
        private static T3;
        private static T4;
        private static T5;
        private static T6;
        private static T7;
        private static T8;
        private static U1;
        private static U2;
        private static U3;
        private static U4;
        private _Ke;
        private _Kd;
        private _lastCipherblock;
        readonly mode: string;
        constructor(key: ArrayBuffer | ArrayBufferView, iv: ArrayBuffer | ArrayBufferView);
        private static convertToInt32(bytes);
        decrypt(ciphertext: ArrayBuffer | ArrayBufferView): ArrayBuffer;
        decryptBlock(ciphertext: Uint8Array, plaintext: Uint8Array): void;
        encrypt(plaintext: ArrayBuffer | ArrayBufferView): ArrayBuffer;
        encryptBlock(plaintext: Uint8Array, ciphertext: Uint8Array): void;
    }
}
declare namespace Neo.Cryptography {
    class Base58 {
        static Alphabet: string;
        static decode(input: string): Uint8Array;
        static encode(input: Uint8Array): string;
    }
}
declare namespace Neo.Cryptography {
    interface CAlgorithm {
        name: string;
    }
    class CryptoKey {
        type: string;
        extractable: boolean;
        algorithm: CAlgorithm;
        usages: string[];
        constructor(type: string, extractable: boolean, algorithm: CAlgorithm, usages: string[]);
    }
    class AesCryptoKey extends Neo.Cryptography.CryptoKey {
        private _key_bytes;
        constructor(_key_bytes: Uint8Array);
        static create(length: number): AesCryptoKey;
        export(): Uint8Array;
        static import(keyData: ArrayBuffer | ArrayBufferView): AesCryptoKey;
    }
    class ECDsaCryptoKey extends CryptoKey {
        publicKey: ECPoint;
        privateKey: Uint8Array;
        constructor(publicKey: ECPoint, privateKey?: Uint8Array);
    }
}
declare namespace Neo.Cryptography {
    class ECCurve {
        Q: BigInteger;
        A: ECFieldElement;
        B: ECFieldElement;
        N: BigInteger;
        Infinity: ECPoint;
        G: ECPoint;
        static readonly secp256k1: ECCurve;
        static readonly secp256r1: ECCurve;
        constructor(Q: BigInteger, A: BigInteger, B: BigInteger, N: BigInteger, G: Uint8Array);
    }
}
declare namespace Neo.Cryptography {
    class ECDsa {
        private key;
        constructor(key: ECDsaCryptoKey);
        private static calculateE(n, message);
        static generateKey(curve: ECCurve): {
            privateKey: ECDsaCryptoKey;
            publicKey: ECDsaCryptoKey;
        };
        sign(message: ArrayBuffer | ArrayBufferView): ArrayBuffer;
        private static sumOfTwoMultiplies(P, k, Q, l);
        verify(message: ArrayBuffer | ArrayBufferView, signature: ArrayBuffer | ArrayBufferView): boolean;
    }
}
declare namespace Neo.Cryptography {
    class ECFieldElement {
        value: BigInteger;
        private curve;
        constructor(value: BigInteger, curve: ECCurve);
        add(other: ECFieldElement): ECFieldElement;
        compareTo(other: ECFieldElement): number;
        divide(other: ECFieldElement): ECFieldElement;
        equals(other: ECFieldElement): boolean;
        private static fastLucasSequence(p, P, Q, k);
        multiply(other: ECFieldElement): ECFieldElement;
        negate(): ECFieldElement;
        sqrt(): ECFieldElement;
        square(): ECFieldElement;
        subtract(other: ECFieldElement): ECFieldElement;
    }
}
declare namespace Neo.Cryptography {
    class ECPoint {
        x: ECFieldElement;
        y: ECFieldElement;
        curve: ECCurve;
        constructor(x: ECFieldElement, y: ECFieldElement, curve: ECCurve);
        static add(x: ECPoint, y: ECPoint): ECPoint;
        compareTo(other: ECPoint): number;
        static decodePoint(encoded: Uint8Array, curve: ECCurve): ECPoint;
        private static decompressPoint(yTilde, X1, curve);
        static deserializeFrom(reader: IO.BinaryReader, curve: ECCurve): ECPoint;
        encodePoint(commpressed: boolean): Uint8Array;
        equals(other: ECPoint): boolean;
        static fromUint8Array(arr: Uint8Array, curve: ECCurve): ECPoint;
        isInfinity(): boolean;
        static multiply(p: ECPoint, n: Uint8Array | BigInteger): ECPoint;
        negate(): ECPoint;
        static parse(str: string, curve: ECCurve): ECPoint;
        static subtract(x: ECPoint, y: ECPoint): ECPoint;
        toString(): string;
        twice(): ECPoint;
        private static windowNaf(width, k);
    }
}
interface String {
    base58Decode(): Uint8Array;
    base64UrlDecode(): Uint8Array;
    toAesKey(): PromiseLike<ArrayBuffer>;
}
interface Uint8Array {
    base58Encode(): string;
    base64UrlEncode(): string;
}
declare function escape(s: string): string;
declare function unescape(s: string): string;
declare namespace Neo.Cryptography {
}
declare namespace Neo.Cryptography {
    class RIPEMD160 {
        private static zl;
        private static zr;
        private static sl;
        private static sr;
        private static hl;
        private static hr;
        private static bytesToWords(bytes);
        private static wordsToBytes(words);
        private static processBlock(H, M, offset);
        private static f1(x, y, z);
        private static f2(x, y, z);
        private static f3(x, y, z);
        private static f4(x, y, z);
        private static f5(x, y, z);
        private static rotl(x, n);
        static computeHash(data: ArrayBuffer | ArrayBufferView): ArrayBuffer;
    }
}
declare namespace Neo.Cryptography {
    class Sha256 {
        private static K;
        static computeHash(data: ArrayBuffer | ArrayBufferView): ArrayBuffer;
        private static ROTR(n, x);
        private static Σ0(x);
        private static Σ1(x);
        private static σ0(x);
        private static σ1(x);
        private static Ch(x, y, z);
        private static Maj(x, y, z);
    }
}