/// <reference types="node" />
import { ICeloVersionedContract } from '@celo/abis/web3/ICeloVersionedContract';
import { StrongAddress } from '@celo/base/lib/address';
import { CeloTransactionObject, CeloTxObject, Connection, Contract, EventLog, PastEventOptions } from '@celo/connect';
import BigNumber from 'bignumber.js';
import { ContractVersion } from '../versions';
/** Represents web3 native contract Method */
type Method<I extends any[], O> = (...args: I) => CeloTxObject<O>;
type Events<T extends Contract> = keyof T['events'];
type EventsEnum<T extends Contract> = {
    [event in Events<T>]: event;
};
/**
 * @internal -- use its children
 */
export declare abstract class BaseWrapper<T extends Contract> {
    protected readonly connection: Connection;
    protected readonly contract: T;
    protected _version?: T['methods'] extends ICeloVersionedContract['methods'] ? ContractVersion : never;
    constructor(connection: Connection, contract: T);
    /** Contract address */
    get address(): StrongAddress;
    version(): Promise<T["methods"] extends {
        getVersionNumber(): CeloTxObject<{
            0: string;
            1: string;
            2: string;
            3: string;
        }>;
    } ? ContractVersion : never>;
    protected onlyVersionOrGreater(version: ContractVersion): Promise<void>;
    /** Contract getPastEvents */
    getPastEvents(event: Events<T>, options: PastEventOptions): Promise<EventLog[]>;
    events: T['events'];
    eventTypes: EventsEnum<T>;
    methodIds: Record<keyof T["methods"], string>;
}
export declare const valueToBigNumber: (input: BigNumber.Value) => BigNumber;
export declare const fixidityValueToBigNumber: (input: BigNumber.Value) => BigNumber;
export declare const valueToString: (input: BigNumber.Value) => string;
export declare const valueToFixidityString: (input: BigNumber.Value) => string;
export declare const valueToInt: (input: BigNumber.Value) => number;
export declare const valueToFrac: (numerator: BigNumber.Value, denominator: BigNumber.Value) => BigNumber;
declare enum TimeDurations {
    millennium = 31536000000000,
    century = 3153600000000,
    decade = 315360000000,
    year = 31536000000,
    quarter = 7776000000,
    month = 2592000000,
    week = 604800000,
    day = 86400000,
    hour = 3600000,
    minute = 60000,
    second = 1000,
    millisecond = 1
}
type TimeUnit = keyof typeof TimeDurations;
export declare function secondsToDurationString(durationSeconds: BigNumber.Value, outputUnits?: TimeUnit[]): string;
export declare const blocksToDurationString: (input: BigNumber.Value) => string;
export declare const unixSecondsTimestampToDateString: (input: BigNumber.Value) => string;
type SolidityBytes = string | number[];
export declare const stringToSolidityBytes: (input: string) => SolidityBytes;
export declare const bufferToSolidityBytes: (input: Buffer) => SolidityBytes;
export declare const solidityBytesToString: (input: SolidityBytes) => string;
type Parser<A, B> = (input: A) => B;
/** Identity Parser */
export declare const identity: <A>(a: A) => A;
export declare const stringIdentity: (x: string) => string;
/**
 * Tuple parser
 * Useful to map different input arguments
 */
export declare function tupleParser<A0, B0>(parser0: Parser<A0, B0>): (...args: [A0]) => [B0];
export declare function tupleParser<A0, B0, A1, B1>(parser0: Parser<A0, B0>, parser1: Parser<A1, B1>): (...args: [A0, A1]) => [B0, B1];
export declare function tupleParser<A0, B0, A1, B1, A2, B2>(parser0: Parser<A0, B0>, parser1: Parser<A1, B1>, parser2: Parser<A2, B2>): (...args: [A0, A1, A2]) => [B0, B1, B2];
export declare function tupleParser<A0, B0, A1, B1, A2, B2, A3, B3>(parser0: Parser<A0, B0>, parser1: Parser<A1, B1>, parser2: Parser<A2, B2>, parser3: Parser<A3, B3>): (...args: [A0, A1, A2, A3]) => [B0, B1, B2, B3];
/**
 * Creates a proxy to call a web3 native contract method.
 *
 * There are 4 cases:
 *  - methodFn
 *  - parseInputArgs => methodFn
 *  - parseInputArgs => methodFn => parseOutput
 *  - methodFn => parseOutput
 *
 * @param methodFn Web3 methods function
 * @param parseInputArgs [optional] parseInputArgs function, tranforms arguments into `methodFn` expected inputs
 * @param parseOutput [optional] parseOutput function, transforms `methodFn` output into proxy return
 */
export declare function proxyCall<InputArgs extends any[], ParsedInputArgs extends any[], PreParsedOutput, Output>(methodFn: Method<ParsedInputArgs, PreParsedOutput>, parseInputArgs: (...args: InputArgs) => ParsedInputArgs, parseOutput: (o: PreParsedOutput) => Output): (...args: InputArgs) => Promise<Output>;
export declare function proxyCall<InputArgs extends any[], PreParsedOutput, Output>(methodFn: Method<InputArgs, PreParsedOutput>, x: undefined, parseOutput: (o: PreParsedOutput) => Output): (...args: InputArgs) => Promise<Output>;
export declare function proxyCall<InputArgs extends any[], ParsedInputArgs extends any[], Output>(methodFn: Method<ParsedInputArgs, Output>, parseInputArgs: (...args: InputArgs) => ParsedInputArgs): (...args: InputArgs) => Promise<Output>;
export declare function proxyCall<InputArgs extends any[], Output>(methodFn: Method<InputArgs, Output>): (...args: InputArgs) => Promise<Output>;
/**
 * Specifies all different possible proxySend arguments so that
 * it always return a function of type: (...args:InputArgs) => CeloTransactionObject<Output>
 *
 * cases:
 *  - methodFn
 *  - parseInputArgs => methodFn
 */
type ProxySendArgs<InputArgs extends any[], ParsedInputArgs extends any[], Output> = [Method<ParsedInputArgs, Output>, (...arg: InputArgs) => ParsedInputArgs] | [Method<InputArgs, Output>];
/**
 * Creates a proxy to send a tx on a web3 native contract method.
 *
 * There are 2 cases:
 *  - call methodFn (no pre or post parsing)
 *  - preParse arguments & call methodFn
 *
 * @param methodFn Web3 methods function
 * @param preParse [optional] preParse function, tranforms arguments into `methodFn` expected inputs
 */
export declare function proxySend<InputArgs extends any[], ParsedInputArgs extends any[], Output>(connection: Connection, ...sendArgs: ProxySendArgs<InputArgs, ParsedInputArgs, Output>): (...args: InputArgs) => CeloTransactionObject<Output>;
export {};