## API Report File for "eth-connect"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public (undocumented)
export interface AbiConstructor {
    // (undocumented)
    anonymous?: boolean;
    // (undocumented)
    constant?: boolean;
    // (undocumented)
    gas?: number;
    // (undocumented)
    inputs?: AbiInput[];
    // (undocumented)
    name?: string;
    // (undocumented)
    outputs?: AbiOutput[];
    // (undocumented)
    payable?: boolean;
    // (undocumented)
    stateMutability?: StateMutabilityType;
    // (undocumented)
    type: 'constructor';
}

// @public (undocumented)
export interface AbiEvent {
    // (undocumented)
    anonymous?: boolean;
    // (undocumented)
    constant?: boolean;
    // (undocumented)
    gas?: number;
    // (undocumented)
    inputs?: AbiInput[];
    // (undocumented)
    name?: string;
    // (undocumented)
    outputs?: AbiOutput[];
    // (undocumented)
    payable?: boolean;
    // (undocumented)
    stateMutability?: StateMutabilityType;
    // (undocumented)
    type: 'event';
}

// @public (undocumented)
export interface AbiFallback {
    // (undocumented)
    anonymous?: boolean;
    // (undocumented)
    constant?: boolean;
    // (undocumented)
    gas?: number;
    // (undocumented)
    inputs?: AbiInput[];
    // (undocumented)
    name?: string;
    // (undocumented)
    outputs?: AbiOutput[];
    // (undocumented)
    payable?: boolean;
    // (undocumented)
    stateMutability?: StateMutabilityType;
    // (undocumented)
    type: 'fallback';
}

// @public (undocumented)
export interface AbiFunction {
    // (undocumented)
    anonymous?: boolean;
    // (undocumented)
    constant?: boolean;
    // (undocumented)
    gas?: number;
    // (undocumented)
    inputs?: AbiInput[];
    // (undocumented)
    name?: string;
    // (undocumented)
    outputs?: AbiOutput[];
    // (undocumented)
    payable?: boolean;
    // (undocumented)
    stateMutability?: StateMutabilityType;
    // (undocumented)
    type: 'function';
}

// @public (undocumented)
export interface AbiInput extends AbiOutput {
    // (undocumented)
    indexed?: boolean;
}

// @public (undocumented)
export type AbiItem = AbiFunction | AbiEvent | AbiConstructor | AbiFallback | AbiItemGeneric;

// @public (undocumented)
export interface AbiItemGeneric {
    // (undocumented)
    anonymous?: boolean;
    // (undocumented)
    constant?: boolean;
    // (undocumented)
    gas?: number;
    // (undocumented)
    inputs?: AbiInput[];
    // (undocumented)
    name?: string;
    // (undocumented)
    outputs?: AbiOutput[];
    // (undocumented)
    payable?: boolean;
    // (undocumented)
    stateMutability?: StateMutabilityType;
    // (undocumented)
    type: string;
}

// @public (undocumented)
export interface AbiOutput {
    // (undocumented)
    components?: AbiOutput[];
    // (undocumented)
    internalType?: string;
    // (undocumented)
    name: string;
    // (undocumented)
    type: string;
}

// @public (undocumented)
export type AbiType = 'function' | 'constructor' | 'event' | 'fallback';

// Warning: (ae-missing-release-tag) "AbstractFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export abstract class AbstractFilter<ReceivedLog, TransformedLog = ReceivedLog> {
    constructor(requestManager: RequestManager);
    // (undocumented)
    protected callbacks: ((message: TransformedLog) => void)[];
    // (undocumented)
    protected filterId: IFuture<Data>;
    // (undocumented)
    formatter: (x: ReceivedLog) => TransformedLog;
    // (undocumented)
    protected abstract getChanges(): Promise<ReceivedLog[]>;
    // (undocumented)
    protected abstract getNewFilter(): Promise<Data>;
    // (undocumented)
    isDisposed: boolean;
    // (undocumented)
    isStarted: boolean;
    // (undocumented)
    requestManager: RequestManager;
    // (undocumented)
    start(): Promise<void>;
    // (undocumented)
    stop(): Promise<void>;
    // (undocumented)
    protected stopSemaphore: IFuture<any>;
    // (undocumented)
    protected abstract uninstall(): Promise<boolean>;
    // (undocumented)
    watch(callback: (message: TransformedLog) => void): Promise<void>;
}

// @public
export type Address = string;

// Warning: (ae-missing-release-tag) "BigNumber" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "BigNumber" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
// Warning: (ae-missing-release-tag) "BigNumber" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function BigNumber(n: BigNumber.Value, base?: number): BigNumber;

// @public (undocumented)
export namespace BigNumber {

    export interface Config {

        ALPHABET?: string;

        CRYPTO?: boolean;

        DECIMAL_PLACES?: number;

        EXPONENTIAL_AT?: number | [number, number];

        FORMAT?: BigNumber.Format;

        MODULO_MODE?: BigNumber.ModuloMode;

        POW_PRECISION?: number;

        RANGE?: number | [number, number];

        ROUNDING_MODE?: BigNumber.RoundingMode;
    }

    // (undocumented)
    export type Constructor = typeof BigNumber;

    export interface Format {

        decimalSeparator?: string;

        fractionGroupSeparator?: string;

        fractionGroupSize?: number;

        groupSeparator?: string;

        groupSize?: number;

        prefix?: string;

        secondaryGroupSize?: number;

        suffix?: string;
    }

    // (undocumented)
    export interface Instance {

        // (undocumented)
        [key: string]: any;

        readonly c: number[] | null;

        readonly e: number | null;

        readonly s: number | null;
    }

    // (undocumented)
    export type ModuloMode = 0 | 1 | 3 | 6 | 9;

    // (undocumented)
    export type RoundingMode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

    // (undocumented)
    export type Value = string | number | Instance;
}

// @public (undocumented)
export class BigNumber implements BigNumber.Instance {

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    constructor(n: BigNumber.Value, base?: number);

    abs(): BigNumber;

    absoluteValue(): BigNumber;

    readonly c: number[] | null;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    static clone(object?: BigNumber.Config): BigNumber.Constructor;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    comparedTo(n: BigNumber.Value, base?: number): number;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static config(object?: BigNumber.Config): BigNumber.Config;

    static DEBUG?: boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    decimalPlaces(): number | null;

    // (undocumented)
    decimalPlaces(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    div(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    dividedBy(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    dividedToIntegerBy(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    dp(): number | null;

    // (undocumented)
    dp(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;

    readonly e: number | null;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    eq(n: BigNumber.Value, base?: number): boolean;

    static readonly EUCLID: 9;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    exponentiatedBy(n: BigNumber.Value, m?: BigNumber.Value): BigNumber;

    // (undocumented)
    exponentiatedBy(n: number, m?: BigNumber.Value): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    gt(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    gte(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    idiv(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    integerValue(rm?: BigNumber.RoundingMode): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static isBigNumber(value: any): value is BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    isEqualTo(n: BigNumber.Value, base?: number): boolean;

    isFinite(): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    isGreaterThan(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    isGreaterThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;

    isInteger(): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    isLessThan(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    isLessThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;

    isNaN(): boolean;

    isNegative(): boolean;

    isPositive(): boolean;

    isZero(): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    lt(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    lte(n: BigNumber.Value, base?: number): boolean;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static max(...n: BigNumber.Value[]): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static maximum(...n: BigNumber.Value[]): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static min(...n: BigNumber.Value[]): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static minimum(...n: BigNumber.Value[]): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    minus(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    mod(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    modulo(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    multipliedBy(n: BigNumber.Value, base?: number): BigNumber;

    negated(): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    plus(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    pow(n: BigNumber.Value, m?: BigNumber.Value): BigNumber;

    // (undocumented)
    pow(n: number, m?: BigNumber.Value): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    precision(includeZeros?: boolean): number;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    precision(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    static random(decimalPlaces?: number): BigNumber;

    static readonly ROUND_CEIL: 2;

    static readonly ROUND_DOWN: 1;

    static readonly ROUND_FLOOR: 3;

    static readonly ROUND_HALF_CEIL: 7;

    static readonly ROUND_HALF_DOWN: 5;

    static readonly ROUND_HALF_EVEN: 6;

    static readonly ROUND_HALF_FLOOR: 8;

    static readonly ROUND_HALF_UP: 4;

    static readonly ROUND_UP: 0;

    readonly s: number | null;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    sd(includeZeros?: boolean): number;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    sd(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static set(object?: BigNumber.Config): BigNumber.Config;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    shiftedBy(n: number): BigNumber;

    sqrt(): BigNumber;

    squareRoot(): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    static sum(...n: BigNumber.Value[]): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    times(n: BigNumber.Value, base?: number): BigNumber;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toExponential(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;

    // (undocumented)
    toExponential(): string;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toFixed(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;

    // (undocumented)
    toFixed(): string;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toFormat(decimalPlaces: number, roundingMode: BigNumber.RoundingMode, format?: BigNumber.Format): string;

    // (undocumented)
    toFormat(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;

    // (undocumented)
    toFormat(decimalPlaces?: number): string;

    // (undocumented)
    toFormat(decimalPlaces: number, format: BigNumber.Format): string;

    // (undocumented)
    toFormat(format: BigNumber.Format): string;

    // Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toFraction(max_denominator?: BigNumber.Value): [BigNumber, BigNumber];

    toJSON(): string;

    toNumber(): number;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toPrecision(significantDigits: number, roundingMode?: BigNumber.RoundingMode): string;

    // (undocumented)
    toPrecision(): string;

    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
    toString(base?: number): string;

    // Warning: (tsdoc-code-span-empty) A code span must contain at least one character between the backticks
    // Warning: (tsdoc-code-fence-missing-delimiter) Error parsing code fence: Missing closing delimiter
    valueOf(): string;
}

// @public (undocumented)
export type BlockIdentifier = Quantity | Tag;

// @public (undocumented)
export type BlockObject = {
    number: Quantity;
    hash: TxHash;
    parentHash: TxHash;
    nonce: Data;
    sha3Uncles: TxHash;
    logsBloom: Data;
    transactionsRoot: TxHash;
    stateRoot: TxHash;
    receiptsRoot: TxHash;
    miner: Address;
    difficulty: BigNumber;
    totalDifficulty: BigNumber;
    extraData: Data;
    size: Quantity;
    gasLimit: Quantity;
    gasUsed: Quantity;
    timestamp: Quantity;
    transactions: Array<TxHash> | Array<TransactionObject>;
    uncles: Array<TxHash>;
};

// @public (undocumented)
export function bytesToHex(bytes: Uint8Array): string;

// @public
export function bytesToUtf8String(bytesOrHexString: Uint8Array | string): string;

// Warning: (ae-missing-release-tag) "Callback" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type Callback = (err: Error | null, message?: any) => void;

// Warning: (ae-missing-release-tag) "coder" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export namespace coder {
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@method" is not defined in this configuration
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
    // Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@return" is not defined in this configuration
    export function decodeParams(outputs: ReadonlyArray<Readonly<AbiOutput | string>>, bytes: string): any;
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@method" is not defined in this configuration
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
    // Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@return" is not defined in this configuration
    export function encodeParams(types: ReadonlyArray<Readonly<AbiOutput | string>>, params: any[]): string;
}

// Warning: (ae-missing-release-tag) "concatBytes" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function concatBytes(...buffers: Uint8Array[]): Uint8Array;

// @public (undocumented)
export type ConfirmedTransaction = TransactionObject & {
    type: TransactionType.confirmed;
    receipt: TransactionReceipt;
};

// @public
export class Contract {
    constructor(requestManager: RequestManager, abi: AbiItem[], address: string);
    // (undocumented)
    abi: AbiItem[];
    // (undocumented)
    address: string;
    // (undocumented)
    allEvents: (options: FilterOptions) => Promise<EthFilter>;
    // (undocumented)
    events: {
        [key: string]: EventFilterCreator;
    };
    // (undocumented)
    requestManager: RequestManager;
    // (undocumented)
    transactionHash: string | null;
}

// @public
export class ContractFactory {
    constructor(requestManager: RequestManager, abi: any[]);
    // (undocumented)
    abi: any[];
    at(address: string): Promise<Contract>;
    deploy(param1: any, param2: any, options: TransactionOptions): Promise<Contract>;
    // (undocumented)
    deploy(param1: any, options: TransactionOptions): Promise<Contract>;
    // (undocumented)
    deploy(options: TransactionOptions): Promise<Contract>;
    // (undocumented)
    requestManager: RequestManager;
}

// @public
export type Data = string;

// @public (undocumented)
export type DroppedTransaction = {
    type: TransactionType.dropped;
    hash: string;
    nonce: number;
};

// @public (undocumented)
export namespace eth {
    const // (undocumented)
    eth_getBalance: Method<BigNumber>;
    const // (undocumented)
    eth_getStorageAt: Method<string>;
    const // (undocumented)
    eth_getCode: Method<string>;
    const // (undocumented)
    eth_getBlockByHash: Method<BlockObject | null>;
    const // (undocumented)
    eth_getBlockByNumber: Method<BlockObject | null>;
    const // (undocumented)
    eth_getUncleByBlockHashAndIndex: Method<BlockObject | null>;
    const // (undocumented)
    eth_getUncleByBlockNumberAndIndex: Method<BlockObject | null>;
    const // (undocumented)
    eth_getBlockTransactionCountByHash: Method<number>;
    const // (undocumented)
    eth_getBlockTransactionCountByNumber: Method<number>;
    const // (undocumented)
    eth_getUncleCountByBlockHash: Method<number>;
    const // (undocumented)
    eth_getUncleCountByBlockNumber: Method<number>;
    const // (undocumented)
    eth_getTransactionByHash: Method<TransactionObject | null>;
    const // (undocumented)
    eth_getTransactionByBlockHashAndIndex: Method<TransactionObject | null>;
    const // (undocumented)
    eth_getTransactionByBlockNumberAndIndex: Method<TransactionObject | null>;
    const // (undocumented)
    eth_getTransactionReceipt: Method<TransactionReceipt | null>;
    const // (undocumented)
    eth_getTransactionCount: Method<number>;
    const // (undocumented)
    eth_sendRawTransaction: Method<string>;
    const // (undocumented)
    web3_sha3: Method<string>;
    const // (undocumented)
    eth_sendTransaction: Method<string>;
    const // (undocumented)
    eth_sign: Method<string>;
    const // (undocumented)
    eth_call: Method<string>;
    const // (undocumented)
    eth_estimateGas: Method<number>;
    const // (undocumented)
    eth_submitWork: Method<boolean>;
    const // (undocumented)
    eth_getWork: Method<any[]>;
    const // (undocumented)
    eth_coinbase: Property<string>;
    const // (undocumented)
    eth_mining: Property<boolean>;
    const // (undocumented)
    eth_hashrate: Property<number>;
    const // (undocumented)
    eth_syncing: Property<Syncing>;
    const // (undocumented)
    eth_gasPrice: Property<BigNumber>;
    const // (undocumented)
    eth_accounts: Property<any[]>;
    const // (undocumented)
    eth_blockNumber: Property<number>;
    const // (undocumented)
    eth_protocolVersion: Property<number>;
    const // (undocumented)
    web3_clientVersion: Property<string>;
    const // (undocumented)
    net_version: Property<string>;
    const // (undocumented)
    shh_version: Method<number>;
    const // (undocumented)
    shh_post: Method<boolean>;
    const // (undocumented)
    personal_newAccount: Method<string>;
    const // (undocumented)
    personal_importRawKey: Method<string>;
    const // (undocumented)
    personal_sign: Method<string>;
    const // (undocumented)
    personal_ecRecover: Method<string>;
    const // (undocumented)
    personal_unlockAccount: Method<boolean>;
    const // (undocumented)
    personal_sendTransaction: Method<string>;
    const // (undocumented)
    personal_lockAccount: Method<boolean>;
    const // (undocumented)
    personal_listAccounts: Property<any[]>;
    const // (undocumented)
    net_listening: Property<boolean>;
    const // (undocumented)
    net_peerCount: Property<number>;
    const // (undocumented)
    eth_newFilter: Method<string>;
    const // (undocumented)
    eth_getLogs: Method<any[]>;
    const // (undocumented)
    eth_newBlockFilter: Method<string>;
    const // (undocumented)
    eth_newPendingTransactionFilter: Method<string>;
    const // (undocumented)
    eth_uninstallFilter: Method<boolean>;
    const // (undocumented)
    eth_getFilterLogs: Method<any[]>;
    const // (undocumented)
    eth_getFilterChanges: Method<any[]>;
    const // (undocumented)
    eth_submitHashrate: Method<boolean>;
    const // (undocumented)
    shh_newIdentity: Method<string>;
    const // (undocumented)
    shh_hasIdentity: Method<boolean>;
    const // (undocumented)
    shh_newGroup: Method<string>;
    const // (undocumented)
    shh_addToGroup: Method<boolean>;
    const // (undocumented)
    shh_newFilter: Method<string>;
    const // (undocumented)
    shh_uninstallFilter: Method<boolean>;
    const // (undocumented)
    shh_getLogs: Method<any[]>;
    const // (undocumented)
    shh_getFilterMessages: Method<any[]>;
    const // (undocumented)
    shh_getFilterChanges: Method<any[]>;
    const // (undocumented)
    shh_getMessages: Method<any[]>;
}

// Warning: (ae-missing-release-tag) "EthBlockFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export class EthBlockFilter extends EthFilter<TxHash, TxHash> {
    constructor(requestManager: RequestManager);
    // (undocumented)
    getNewFilter(): Promise<string>;
}

// Warning: (ae-missing-release-tag) "EthFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export class EthFilter<TransformedLog = LogObject, ReceivedLog = LogObject> extends AbstractFilter<ReceivedLog, TransformedLog> {
    constructor(requestManager: RequestManager, options: FilterOptions, formatter?: (message: ReceivedLog) => TransformedLog);
    // (undocumented)
    formatter: (message: ReceivedLog) => TransformedLog;
    // (undocumented)
    protected getChanges(): Promise<ReceivedLog[]>;
    // (undocumented)
    getLogs(): Promise<ReceivedLog[]>;
    // (undocumented)
    protected getNewFilter(): Promise<Data>;
    // (undocumented)
    options: FilterOptions;
    // (undocumented)
    requestManager: RequestManager;
    // (undocumented)
    protected uninstall(): Promise<boolean>;
}

// Warning: (ae-missing-release-tag) "EthPendingTransactionFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export class EthPendingTransactionFilter extends EthFilter<TxHash, TxHash> {
    constructor(requestManager: RequestManager);
    // (undocumented)
    getNewFilter(): Promise<string>;
}

// @public (undocumented)
export type EventData = {
    data: string;
    topics: string[];
    address: string;
};

// @public (undocumented)
export type EventFilterCreator = (indexed: {
    [key: string]: any;
}, options?: FilterOptions) => Promise<EthFilter>;

// @public
export function extractDisplayName(name: string): string;

// @public
export function extractTypeName(name: string): string;

// Warning: (ae-missing-release-tag) "FetchFunction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type FetchFunction = (url: string, params: {
    body?: any;
    method?: string;
    mode?: string;
    headers?: any;
}) => Promise<any>;

// Warning: (ae-missing-release-tag) "FilterCallback" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type FilterCallback = (messages: LogObject[] | string[]) => void;

// @public (undocumented)
export type FilterOptions = {
    fromBlock?: BlockIdentifier;
    toBlock?: BlockIdentifier;
    address?: Data | Address;
    topics?: TopicFilter;
};

// @public (undocumented)
export type FinishedTransactionAndReceipt = TransactionAndReceipt & {
    status: TransactionStatus;
};

// @public
export function fromAscii(str: string, num?: number): string;

// @public
export function fromDecimal(value: BigNumber.Value): string;

// @public
export function fromTwosComplement(num: BigNumber, bits?: number): BigNumber;

// Warning: (ae-missing-release-tag) "fromWei" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function fromWei(num: BigNumber, unit: Unit): BigNumber;

// @public (undocumented)
export function fromWei(num: string | number, unit: Unit): string;

// @public (undocumented)
export function getAddress(address: string): string;

// @public
export function getValueOfUnit(_unit: Unit): BigNumber;

// @public (undocumented)
export type Hex = string;

// @public (undocumented)
export function hexToBytes(hex: string): Uint8Array;

// @public
export class HTTPProvider {
    constructor(host: string, options?: HTTPProviderOptions);
    // (undocumented)
    debug: boolean;
    // (undocumented)
    host: string;
    // (undocumented)
    options: HTTPProviderOptions;
    // (undocumented)
    send(): void;
    sendAsync(payload: RPCMessage | RPCMessage[], callback: Callback): void;
}

// Warning: (ae-missing-release-tag) "HTTPProviderOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type HTTPProviderOptions = {
    headers?: {
        [key: string]: string;
    };
    timeout?: number;
    fetch?: FetchFunction;
};

// Warning: (ae-missing-release-tag) "IFuture" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type IFuture<T> = Promise<T> & {
    resolve: (x: T) => void;
    reject: (x: Error) => void;
    finally: (fn: () => void) => void;
    isPending: boolean;
};

// Warning: (ae-missing-release-tag) "inputAddressFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function inputAddressFormatter(address: string): string;

// Warning: (ae-missing-release-tag) "inputBlockNumberFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function inputBlockNumberFormatter(blockNumber: Quantity | Tag | null): string | null;

// Warning: (ae-missing-release-tag) "inputCallFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function inputCallFormatter(options: TransactionOptions): TransactionOptions;

// Warning: (ae-missing-release-tag) "inputDefaultBlockNumberFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function inputDefaultBlockNumberFormatter(blockNumber?: Quantity | Tag): string | Tag | null;

// Warning: (ae-missing-release-tag) "inputFilterOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function inputFilterOptions(options: FilterOptions): FilterOptions;

// Warning: (ae-missing-release-tag) "inputPostFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function inputPostFormatter(post: any): any;

// Warning: (ae-missing-release-tag) "inputTransactionFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function inputTransactionFormatter(options: TransactionOptions): TransactionOptions;

// Warning: (ae-missing-release-tag) "inputTransactionId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function inputTransactionId(txId: string): string;

// Warning: (ae-missing-release-tag) "IPropertyOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface IPropertyOptions<V> {
    // (undocumented)
    getter: string;
    // (undocumented)
    outputFormatter: (_: any) => V;
}

// @public
export function isAddress(address: any): boolean;

// @public
export function isArray<T extends Array<any>>(object: any): object is T;

// @public
export function isBigNumber(object: any): object is BigNumber;

// @public
export function isBloom(bloom: string): boolean;

// @public
export function isBoolean(object: any): object is boolean;

// @public
export function isChecksumAddress(_address: string): boolean;

// @public
export function isFunction(object: any): object is CallableFunction;

// @public
export function isHex(value: string): boolean;

// @public
export function isJson(str: string): boolean;

// @public
export function isObject<T extends object>(object: any): object is T;

// Warning: (ae-missing-release-tag) "isPredefinedBlockNumber" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function isPredefinedBlockNumber(blockNumber: Quantity | Tag): blockNumber is Tag;

// @public
export function isStrictAddress(address: any): boolean;

// @public
export function isString(value: any): value is string;

// @public
export function isTopic(topic: string): boolean;

// Warning: (ae-forgotten-export) The symbol "RPCResponse" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "isValidResponse" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function isValidResponse(response: RPCResponse | RPCResponse[]): boolean;

// Warning: (ae-missing-release-tag) "IWebSocket" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface IWebSocket {
    close(code?: number, reason?: string): void;
    // (undocumented)
    onclose: ((this: this, ev: any) => any) | null;
    // (undocumented)
    onerror: ((this: this, ev: any) => any) | null;
    // (undocumented)
    onmessage: ((this: this, ev: any) => any) | null;
    // (undocumented)
    onopen: ((this: this, ev: any) => any) | null;
    send(data: string): void;
}

// @public (undocumented)
export type LogObject = {
    removed: boolean;
    logIndex: Quantity;
    transactionIndex: Quantity;
    transactionHash: TxHash;
    blockHash: TxHash;
    blockNumber: Quantity;
    address: Address;
    data: Data;
    topics: Array<Data>;
};

// Warning: (ae-missing-release-tag) "messageId" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export let messageId: number;

// @public (undocumented)
export class Method<Output> {
    constructor(options: {
        callName: string;
        params: number;
        inputFormatter: Array<null | ((a: any) => any)>;
        outputFormatter: (val: any) => Output;
    });
    // (undocumented)
    callName: string;
    // (undocumented)
    execute(requestManager: RequestManager, ...args: any[]): Promise<Output | null>;
    formatInput(args: any[]): any[];
    formatOutput(result: any): Output | null;
    // (undocumented)
    inputFormatter: Array<null | ((a: any) => any)>;
    // (undocumented)
    outputFormatter: (something: any) => Output;
    // (undocumented)
    params: number;
    toPayload(args: any[]): {
        method: string;
        params: any[];
    };
    validateArgs(args: any[]): void;
}

// Warning: (ae-missing-release-tag) "outputBigNumberFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputBigNumberFormatter(output: BigNumber.Value): BigNumber;

// Warning: (ae-missing-release-tag) "outputBlockFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputBlockFormatter(block: BlockObject | null): BlockObject | null;

// Warning: (ae-missing-release-tag) "outputLogFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputLogFormatter(log: LogObject): LogObject;

// Warning: (ae-missing-release-tag) "outputPostFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputPostFormatter(post: SHHFilterMessage): SHHFilterMessage | null;

// Warning: (ae-missing-release-tag) "outputSyncingFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function outputSyncingFormatter(result: Syncing): Syncing;

// Warning: (ae-missing-release-tag) "outputTransactionFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputTransactionFormatter(tx: TransactionObject): TransactionObject | null;

// Warning: (ae-missing-release-tag) "outputTransactionReceiptFormatter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function outputTransactionReceiptFormatter(receipt: TransactionReceipt): TransactionReceipt | null;

// @public
export function padLeft(str: string, chars: number, sign?: string): string;

// @public
export function padRight(str: string, chars: number, sign?: string): string;

// @public (undocumented)
export type PendingTransaction = TransactionObject & {
    type: TransactionType.pending;
};

// @public (undocumented)
export class Property<V> {
    constructor(options: IPropertyOptions<V>);
    // (undocumented)
    execute(requestManager: RequestManager, ..._unusedArgs: any[]): Promise<V>;
    formatOutput(result: any): V;
    // (undocumented)
    getter: string;
    // (undocumented)
    outputFormatter: (_: any) => V;
}

// @public (undocumented)
export type Quantity = number | Hex;

// @public (undocumented)
export type QueuedTransaction = {
    type: TransactionType.queued;
    hash: string;
    nonce: number;
};

// @public (undocumented)
export type ReplacedTransaction = {
    type: TransactionType.replaced;
    hash: string;
    nonce: number;
};

// @public
class RequestManager {
    constructor(provider: any);
    eth_accounts: () => Promise<Address[]>;
    eth_blockNumber: () => Promise<Quantity>;
    eth_call: (options: TransactionCallOptions, block: BlockIdentifier) => Promise<Data>;
    eth_coinbase: () => Promise<Address>;
    eth_estimateGas: (data: Partial<TransactionCallOptions> & Partial<TransactionOptions>) => Promise<Quantity>;
    eth_gasPrice: () => Promise<BigNumber>;
    eth_getBalance: (address: Address, block: BlockIdentifier) => Promise<BigNumber>;
    eth_getBlockByHash: (blockHash: TxHash, fullTransactionObjects: boolean) => Promise<BlockObject>;
    eth_getBlockByNumber: (block: BlockIdentifier, fullTransactionObjects: boolean) => Promise<BlockObject>;
    eth_getBlockTransactionCountByHash: (blockHash: TxHash) => Promise<number>;
    eth_getBlockTransactionCountByNumber: (block: BlockIdentifier) => Promise<number>;
    eth_getCode: (address: Address, block: BlockIdentifier) => Promise<Data>;
    eth_getFilterChanges: (filterId: Data) => Promise<Array<TxHash> | Array<LogObject>>;
    eth_getFilterLogs: (filterId: Data) => Promise<Array<TxHash> | Array<LogObject>>;
    eth_getLogs: (options: FilterOptions) => Promise<Array<TxHash> | Array<LogObject>>;
    eth_getStorageAt: (address: Address, position: Quantity, block: BlockIdentifier) => Promise<Data>;
    eth_getTransactionByBlockHashAndIndex: (blockHash: TxHash, txIndex: Quantity) => Promise<TransactionObject>;
    eth_getTransactionByBlockNumberAndIndex: (block: BlockIdentifier, txIndex: Quantity) => Promise<TransactionObject>;
    eth_getTransactionByHash: (hash: TxHash) => Promise<TransactionObject>;
    eth_getTransactionCount: (address: Address, block: BlockIdentifier) => Promise<number>;
    eth_getTransactionReceipt: (hash: TxHash) => Promise<TransactionReceipt>;
    eth_getUncleByBlockHashAndIndex: (blockHash: TxHash, index: Quantity) => Promise<BlockObject>;
    eth_getUncleByBlockNumberAndIndex: (block: BlockIdentifier, index: Quantity) => Promise<BlockObject>;
    eth_getUncleCountByBlockHash: (blockHash: TxHash) => Promise<number>;
    eth_getUncleCountByBlockNumber: (block: BlockIdentifier) => Promise<number>;
    // @alpha
    eth_getWork: (blockHeaderHash: Data) => Promise<Array<TxHash>>;
    eth_hashrate: () => Promise<Quantity>;
    eth_mining: () => Promise<boolean>;
    eth_newBlockFilter: () => Promise<Data>;
    eth_newFilter: (options: FilterOptions) => Promise<Data>;
    eth_newPendingTransactionFilter: () => Promise<Data>;
    eth_protocolVersion: () => Promise<number>;
    eth_sendRawTransaction: (rawTransaction: Data) => Promise<TxHash>;
    eth_sendTransaction: (options: TransactionOptions) => Promise<TxHash>;
    // @deprecated
    eth_sign: (address: Address, message: Data) => Promise<Data>;
    eth_submitHashrate: (hashRate: Data, id: Data) => Promise<boolean>;
    eth_submitWork: (data: Data, powHash: TxHash, digest: TxHash) => Promise<boolean>;
    eth_syncing: () => Promise<false | Syncing>;
    eth_uninstallFilter: (filterId: Data) => Promise<boolean>;
    getConfirmedTransaction(txId: string): Promise<FinishedTransactionAndReceipt>;
    getTransaction(txId: string): Promise<Transaction | null>;
    getTransactionAndReceipt(txId: string): Promise<TransactionAndReceipt>;
    isFailure(tx: TransactionAndReceipt): boolean;
    isPending(tx: TransactionAndReceipt): boolean;
    isTxDropped(txId: string, _retryAttemps?: number): Promise<boolean>;
    net_listening: () => Promise<boolean>;
    net_peerCount: () => Promise<Quantity>;
    net_version: () => Promise<string>;
    personal_ecRecover: (message: Data, signature: Data) => Promise<Address>;
    personal_importRawKey: (keydata: Data, passPhrase: Data) => Promise<Address>;
    personal_listAccounts: () => Promise<Array<Address>>;
    personal_lockAccount: (address: Address) => Promise<boolean>;
    personal_newAccount: (passPhrase: Data) => Promise<Address>;
    personal_sendTransaction: (txObject: TransactionOptions, passPhrase: Data) => Promise<TxHash>;
    personal_sign: (data: Data, signerAddress: Address, passPhrase: Data) => Promise<Data>;
    personal_unlockAccount: (account: Address, passPhrase?: Data, seconds?: Quantity) => Promise<boolean>;
    // (undocumented)
    provider: any;
    sendAsync(data: RPCSendableMessage): Promise<any>;
    setProvider(p: any): void;
    // (undocumented)
    shh_addToGroup: (group: Data) => Promise<boolean>;
    shh_getFilterChanges: (filterId: Data) => Promise<Array<SHHFilterMessage>>;
    shh_getMessages: (filterId: Data) => Promise<Array<SHHFilterMessage>>;
    shh_hasIdentity: (identity: Data) => Promise<boolean>;
    shh_newFilter: (options: SHHFilterOptions) => Promise<Data>;
    // (undocumented)
    shh_newGroup: () => Promise<Data>;
    shh_newIdentity: () => Promise<Data>;
    shh_post: (data: SHHPost) => Promise<boolean>;
    shh_uninstallFilter: (filterId: Data) => Promise<boolean>;
    shh_version: () => Promise<string>;
    waitForCompletion(txId: string, retriesOnEmpty?: number): Promise<FinishedTransactionAndReceipt>;
    web3_clientVersion: () => Promise<string>;
    web3_sha3: (data: Data) => Promise<Data>;
}
export { RequestManager }
export default RequestManager;

// @public (undocumented)
export type RevertedTransaction = TransactionObject & {
    type: TransactionType.reverted;
};

// Warning: (ae-missing-release-tag) "RPCMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type RPCMessage = {
    jsonrpc: '2.0';
    id: number;
    method: string;
    params: any[] | {
        [key: string]: any;
    };
};

// Warning: (ae-missing-release-tag) "RPCSendableMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type RPCSendableMessage = {
    method: string;
    params: any[];
};

// @public (undocumented)
export function sha3(value: string | number[] | ArrayBuffer | Uint8Array, options?: {
    encoding?: 'hex';
}): string;

// Warning: (ae-missing-release-tag) "SHHFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export class SHHFilter extends AbstractFilter<SHHFilterMessage> {
    constructor(requestManager: RequestManager, options: SHHFilterOptions);
    // (undocumented)
    protected getChanges(): Promise<SHHFilterMessage[]>;
    // (undocumented)
    getMessages(): Promise<SHHFilterMessage[]>;
    // (undocumented)
    protected getNewFilter(): Promise<string>;
    // (undocumented)
    options: SHHFilterOptions;
    // (undocumented)
    requestManager: RequestManager;
    // (undocumented)
    protected uninstall(): Promise<boolean>;
}

// @public (undocumented)
export type SHHFilterMessage = {
    hash: TxHash;
    from: Data;
    to: Data;
    expiry: Quantity;
    ttl: Quantity;
    sent: Quantity;
    topics: Array<Data>;
    payload: Data;
    workProved: Quantity;
};

// @public (undocumented)
export type SHHFilterOptions = {
    to?: Data;
    topics: TopicFilter;
};

// @public (undocumented)
export type SHHPost = {
    from: Data;
    to: Data;
    topics: Array<Data>;
    payload: Data;
    priority: Quantity;
    ttl: Quantity;
};

// Warning: (ae-missing-release-tag) "signedIsNegative" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function signedIsNegative(value: BigNumber, bits: number): boolean;

// Warning: (ae-missing-release-tag) "SolidityEvent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export class SolidityEvent {
    constructor(requestManager: RequestManager, json: AbiEvent, address: string);
    // (undocumented)
    address: string;
    // (undocumented)
    _anonymous: boolean;
    // Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
    // Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
    // Warning: (tsdoc-param-tag-with-invalid-name) The @param block should be followed by a parameter name
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    attachToContract(contract: Contract): void;
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    decode(data: LogObject): LogObject & {
        event: string;
        address: string;
        args: Record<string, any>;
    };
    displayName(): string;
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    encode(indexed?: Record<string, any>, options?: FilterOptions): FilterOptions;
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    // Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
    execute(indexed: Record<string, any>, options?: FilterOptions): Promise<EthFilter<LogObject>>;
    // (undocumented)
    _name: string;
    // (undocumented)
    _params: AbiInput[];
    // (undocumented)
    requestManager: RequestManager;
    signature(): string;
    typeName(): string;
    types(indexed: boolean): AbiInput[];
}

// Warning: (ae-missing-release-tag) "SolidityFunction" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export class SolidityFunction {
    constructor(json: AbiFunction);
    attachToContract(contract: Contract): void;
    // (undocumented)
    _constant: boolean;
    displayName(): string;
    estimateGas(requestManager: RequestManager, address: string, ...args: any[]): Promise<Quantity>;
    execute(requestManager: RequestManager, address: string, ...args: any[]): Promise<any>;
    // (undocumented)
    extractDefaultBlock(args: any[]): string;
    // (undocumented)
    _inputTypes: AbiInput[];
    // (undocumented)
    json: AbiFunction;
    // (undocumented)
    _name: string;
    // (undocumented)
    needsToBeTransaction: boolean;
    // (undocumented)
    _outputTypes: AbiOutput[];
    // (undocumented)
    _payable: boolean;
    signature(): string;
    toPayload(args: any[]): any;
    typeName(): string;
    // (undocumented)
    unpackOutput(output: string): any;
    validateArgs(args: any[]): void;
}

// @public (undocumented)
export type StateMutabilityType = 'pure' | 'view' | 'nonpayable' | 'payable';

// @public
export function stringToUtf8Bytes(str: string): Uint8Array;

// @public (undocumented)
export type Syncing = {
    startingBlock: Quantity;
    currentBlock: Quantity;
    highestBlock: Quantity;
};

// @public (undocumented)
export type Tag = 'latest' | 'earliest' | 'pending';

// @public
export function toAddress(address: string): string;

// @public
export function toArray(value: any): any[];

// @public
export function toAscii(hex: string): string;

// Warning: (ae-missing-release-tag) "toBatchPayload" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function toBatchPayload(messages: RPCSendableMessage[]): {
    jsonrpc: string;
    id: number;
    method: string;
    params: any[];
}[];

// @public
export function toBigNumber(_num: BigNumber.Value): BigNumber;

// @public
export function toBoolean(value: BigNumber.Value | boolean): boolean;

// @public
export function toChecksumAddress(_address: string): string;

// @public
export function toData(val: BigNumber.Value): string;

// @public
export function toDecimal(value: BigNumber.Value): number;

// @public
export function toHex(val: BigNumber.Value | boolean | Uint8Array): string;

// Warning: (ae-missing-release-tag) "toJsonRpcRequest" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function toJsonRpcRequest(method: string, params: any[]): {
    jsonrpc: string;
    id: number;
    method: string;
    params: any[];
};

// @public
export function toNullDecimal(value: BigNumber.Value): number;

// Warning: (ae-missing-release-tag) "TopicFilter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type TopicFilter = Array<Data | null | TopicFilter>;

// @public
function toString_2(value: BigNumber.Value): string;
export { toString_2 as toString }

// @public
export function toStringData(val: BigNumber.Value): string;

// @public
export function toTwosComplement(num: BigNumber.Value, bits?: number): BigNumber;

// @public
export function toWei(num: number | string, unit: Unit): string | BigNumber;

// @public (undocumented)
export type Transaction = DroppedTransaction | ReplacedTransaction | QueuedTransaction | PendingTransaction | ConfirmedTransaction | RevertedTransaction;

// @public (undocumented)
export type TransactionAndReceipt = TransactionObject & {
    receipt: TransactionReceipt;
};

// @public (undocumented)
export type TransactionCallOptions = {
    from?: Address;
    to: Address;
    gas?: BigNumber.Value;
    gasPrice?: BigNumber.Value;
    value?: BigNumber.Value;
    data?: string;
};

// @public (undocumented)
export type TransactionObject = {
    hash: TxHash;
    nonce: number;
    blockHash: TxHash;
    blockNumber: number;
    transactionIndex: number;
    from: Address;
    to: Address | null;
    value: BigNumber;
    gasPrice: BigNumber;
    gas: Quantity;
    input: Data;
    v?: Data;
    r?: Data;
    s?: Data;
};

// @public (undocumented)
export type TransactionOptions = {
    from: Address;
    to: Address;
    gas?: BigNumber.Value;
    gasPrice?: BigNumber.Value;
    value?: BigNumber.Value;
    data: string;
    nonce?: BigNumber.Value;
};

// @public (undocumented)
export type TransactionReceipt = {
    transactionHash: TxHash;
    transactionIndex: Quantity;
    blockHash: TxHash;
    blockNumber: Quantity;
    cumulativeGasUsed: Quantity;
    gasUsed: Quantity;
    contractAddress: Address;
    logs: Array<LogObject>;
    logsBloom: Data;
    root?: TxHash;
    status?: Quantity;
};

// @public (undocumented)
export enum TransactionStatus {
    // (undocumented)
    confirmed = "confirmed",
    // (undocumented)
    failed = "failed",
    // (undocumented)
    pending = "pending"
}

// @public (undocumented)
export enum TransactionType {
    // (undocumented)
    confirmed = "confirmed",
    // (undocumented)
    dropped = "dropped",
    // (undocumented)
    pending = "pending",
    // (undocumented)
    queued = "queued",
    // (undocumented)
    replaced = "replaced",
    // (undocumented)
    reverted = "reverted"
}

// @public
export function transformToFullName(json: AbiItem): string;

// @public
export type TxHash = string;

// Warning: (ae-forgotten-export) The symbol "unitMap" needs to be exported by the entry point index.d.ts
// Warning: (ae-missing-release-tag) "Unit" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type Unit = keyof typeof unitMap;

// @public (undocumented)
export class WebSocketProvider<T extends IWebSocket> {
    constructor(url: string, options?: WebSocketProviderOptions);
    // (undocumented)
    connection: IFuture<T>;
    // (undocumented)
    debug: boolean;
    // (undocumented)
    dispose(): void;
    // (undocumented)
    isDisposed: boolean;
    // (undocumented)
    options: WebSocketProviderOptions;
    // (undocumented)
    send(): void;
    // (undocumented)
    sendAsync(payload: RPCMessage | RPCMessage[], callback: Callback): void;
    // (undocumented)
    url: string;
}

// Warning: (ae-missing-release-tag) "WebSocketProviderOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type WebSocketProviderOptions = {
    WebSocketConstructor?: any;
    timeout?: number;
    protocol?: string;
};

// (No @packageDocumentation comment for this package)

```