import { BigNumberish, Overrides } from "ethers";
import { HandlerOptions } from "@sentio/sdk";
import { BindOptions, BaseProcessor, BaseProcessorTemplate, BoundContractView, ContractContext, ContractView, EthChainId, TypedCallTrace, EthContext, EthFetchConfig, PreprocessResult } from "@sentio/sdk/eth";
import { EthCallParam, EthCallContext, PreparedData } from "@sentio/protos";
import { WETH9, ApprovalEvent, ApprovalEventFilter, TransferEvent, TransferEventFilter, DepositEvent, DepositEventFilter, WithdrawalEvent, WithdrawalEventFilter } from "./WETH9.js";
export interface NameCallObject {
}
export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
export interface ApproveCallObject {
    guy: string;
    wad: bigint;
}
export type ApproveCallTrace = TypedCallTrace<[
    string,
    bigint
], ApproveCallObject>;
export interface TotalSupplyCallObject {
}
export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
export interface TransferFromCallObject {
    src: string;
    dst: string;
    wad: bigint;
}
export type TransferFromCallTrace = TypedCallTrace<[
    string,
    string,
    bigint
], TransferFromCallObject>;
export interface WithdrawCallObject {
    wad: bigint;
}
export type WithdrawCallTrace = TypedCallTrace<[bigint], WithdrawCallObject>;
export interface DecimalsCallObject {
}
export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;
export interface BalanceOfCallObject {
}
export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
export interface SymbolCallObject {
}
export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
export interface TransferCallObject {
    dst: string;
    wad: bigint;
}
export type TransferCallTrace = TypedCallTrace<[
    string,
    bigint
], TransferCallObject>;
export interface DepositCallObject {
}
export type DepositCallTrace = TypedCallTrace<[], DepositCallObject>;
export interface AllowanceCallObject {
}
export type AllowanceCallTrace = TypedCallTrace<[
    string,
    string
], AllowanceCallObject>;
export declare class WETH9ContractView extends ContractView<WETH9> {
    constructor(contract: WETH9);
    name(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    totalSupply(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    decimals(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    balanceOf(arg0: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    symbol(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    allowance(arg0: string, arg1: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    callStatic: {
        contract: WETH9;
        approve(guy: string, wad: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        transferFrom(src: string, dst: string, wad: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        withdraw(wad: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        transfer(dst: string, wad: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        deposit(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
    };
    encodeCall: {
        name(callContext: EthCallContext): EthCallParam;
        approve(guy: string, wad: BigNumberish, callContext: EthCallContext): EthCallParam;
        totalSupply(callContext: EthCallContext): EthCallParam;
        transferFrom(src: string, dst: string, wad: BigNumberish, callContext: EthCallContext): EthCallParam;
        withdraw(wad: BigNumberish, callContext: EthCallContext): EthCallParam;
        decimals(callContext: EthCallContext): EthCallParam;
        balanceOf(arg0: string, callContext: EthCallContext): EthCallParam;
        symbol(callContext: EthCallContext): EthCallParam;
        transfer(dst: string, wad: BigNumberish, callContext: EthCallContext): EthCallParam;
        deposit(callContext: EthCallContext): EthCallParam;
        allowance(arg0: string, arg1: string, callContext: EthCallContext): EthCallParam;
    };
}
export declare class WETH9BoundContractView extends BoundContractView<WETH9, WETH9ContractView> {
    name(overrides?: Overrides): Promise<string>;
    totalSupply(overrides?: Overrides): Promise<bigint>;
    decimals(overrides?: Overrides): Promise<bigint>;
    balanceOf(arg0: string, overrides?: Overrides): Promise<bigint>;
    symbol(overrides?: Overrides): Promise<string>;
    allowance(arg0: string, arg1: string, overrides?: Overrides): Promise<bigint>;
    callStatic: {
        view: WETH9ContractView;
        context: EthContext;
        approve(guy: string, wad: BigNumberish, overrides?: Overrides): Promise<boolean>;
        transferFrom(src: string, dst: string, wad: BigNumberish, overrides?: Overrides): Promise<boolean>;
        withdraw(wad: BigNumberish, overrides?: Overrides): Promise<void>;
        transfer(dst: string, wad: BigNumberish, overrides?: Overrides): Promise<boolean>;
        deposit(overrides?: Overrides): Promise<void>;
    };
    encodeCall: {
        view: WETH9ContractView;
        context: EthContext;
        name(overrides?: Overrides): EthCallParam;
        approve(guy: string, wad: BigNumberish, overrides?: Overrides): EthCallParam;
        totalSupply(overrides?: Overrides): EthCallParam;
        transferFrom(src: string, dst: string, wad: BigNumberish, overrides?: Overrides): EthCallParam;
        withdraw(wad: BigNumberish, overrides?: Overrides): EthCallParam;
        decimals(overrides?: Overrides): EthCallParam;
        balanceOf(arg0: string, overrides?: Overrides): EthCallParam;
        symbol(overrides?: Overrides): EthCallParam;
        transfer(dst: string, wad: BigNumberish, overrides?: Overrides): EthCallParam;
        deposit(overrides?: Overrides): EthCallParam;
        allowance(arg0: string, arg1: string, overrides?: Overrides): EthCallParam;
    };
}
export type WETH9Context = ContractContext<WETH9, WETH9BoundContractView>;
export declare class WETH9Processor extends BaseProcessor<WETH9, WETH9BoundContractView> {
    onEventApproval(handler: (event: ApprovalEvent, ctx: WETH9Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: WETH9Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventDeposit(handler: (event: DepositEvent, ctx: WETH9Context) => void, filter?: DepositEventFilter | DepositEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, DepositEvent>, preprocessHandler?: (event: DepositEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventWithdrawal(handler: (event: WithdrawalEvent, ctx: WETH9Context) => void, filter?: WithdrawalEventFilter | WithdrawalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawalEvent>, preprocessHandler?: (event: WithdrawalEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onCallName(handler: (call: NameCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, NameCallTrace>, preprocessHandler?: (call: NameCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallApprove(handler: (call: ApproveCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ApproveCallTrace>, preprocessHandler?: (call: ApproveCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallTotalSupply(handler: (call: TotalSupplyCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TotalSupplyCallTrace>, preprocessHandler?: (call: TotalSupplyCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallTransferFrom(handler: (call: TransferFromCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferFromCallTrace>, preprocessHandler?: (call: TransferFromCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallWithdraw(handler: (call: WithdrawCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawCallTrace>, preprocessHandler?: (call: WithdrawCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallDecimals(handler: (call: DecimalsCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>, preprocessHandler?: (call: DecimalsCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallBalanceOf(handler: (call: BalanceOfCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, BalanceOfCallTrace>, preprocessHandler?: (call: BalanceOfCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallSymbol(handler: (call: SymbolCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SymbolCallTrace>, preprocessHandler?: (call: SymbolCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallTransfer(handler: (call: TransferCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferCallTrace>, preprocessHandler?: (call: TransferCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallDeposit(handler: (call: DepositCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DepositCallTrace>, preprocessHandler?: (call: DepositCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    onCallAllowance(handler: (call: AllowanceCallTrace, ctx: WETH9Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, AllowanceCallTrace>, preprocessHandler?: (call: AllowanceCallTrace, ctx: WETH9Context) => Promise<PreprocessResult>): this;
    static filters: {
        Approval(src?: string | null, guy?: string | null, wad?: null): ApprovalEventFilter;
        Transfer(src?: string | null, dst?: string | null, wad?: null): TransferEventFilter;
        Deposit(dst?: string | null, wad?: null): DepositEventFilter;
        Withdrawal(src?: string | null, wad?: null): WithdrawalEventFilter;
    };
    protected CreateBoundContractView(): WETH9BoundContractView;
    static bind(options: BindOptions): WETH9Processor;
}
export declare class WETH9ProcessorTemplate extends BaseProcessorTemplate<WETH9, WETH9BoundContractView> {
    bindInternal(options: BindOptions): WETH9Processor;
    onEventApproval(handler: (event: ApprovalEvent, ctx: WETH9Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: WETH9Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventDeposit(handler: (event: DepositEvent, ctx: WETH9Context) => void, filter?: DepositEventFilter | DepositEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, DepositEvent>, preprocessHandler?: (event: DepositEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventWithdrawal(handler: (event: WithdrawalEvent, ctx: WETH9Context) => void, filter?: WithdrawalEventFilter | WithdrawalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, WithdrawalEvent>, preprocessHandler?: (event: WithdrawalEvent, ctx: WETH9Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
}
export declare function getWETH9Contract(chainId: EthChainId, address: string): WETH9ContractView;
export declare function getWETH9ContractOnContext(context: EthContext, address: string): WETH9BoundContractView;
//# sourceMappingURL=weth9-processor.d.ts.map