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 { ERC20, ApprovalEvent, ApprovalEventFilter, OwnershipTransferredEvent, OwnershipTransferredEventFilter, TransferEvent, TransferEventFilter } from "./ERC20.js";
export interface AllowanceCallObject {
    owner: string;
    spender: string;
}
export type AllowanceCallTrace = TypedCallTrace<[
    string,
    string
], AllowanceCallObject>;
export interface ApproveCallObject {
    spender: string;
    amount: bigint;
}
export type ApproveCallTrace = TypedCallTrace<[
    string,
    bigint
], ApproveCallObject>;
export interface BalanceOfCallObject {
    account: string;
}
export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
export interface BurnCallObject {
    amount: bigint;
}
export type BurnCallTrace = TypedCallTrace<[bigint], BurnCallObject>;
export interface BurnFromCallObject {
    account: string;
    amount: bigint;
}
export type BurnFromCallTrace = TypedCallTrace<[
    string,
    bigint
], BurnFromCallObject>;
export interface DecimalsCallObject {
}
export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;
export interface DecreaseAllowanceCallObject {
    spender: string;
    subtractedValue: bigint;
}
export type DecreaseAllowanceCallTrace = TypedCallTrace<[
    string,
    bigint
], DecreaseAllowanceCallObject>;
export interface IncreaseAllowanceCallObject {
    spender: string;
    addedValue: bigint;
}
export type IncreaseAllowanceCallTrace = TypedCallTrace<[
    string,
    bigint
], IncreaseAllowanceCallObject>;
export interface LockerCallObject {
}
export type LockerCallTrace = TypedCallTrace<[], LockerCallObject>;
export interface NameCallObject {
}
export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
export interface OwnerCallObject {
}
export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject>;
export interface RenounceOwnershipCallObject {
}
export type RenounceOwnershipCallTrace = TypedCallTrace<[
], RenounceOwnershipCallObject>;
export interface SetLockerCallObject {
    _locker: string;
}
export type SetLockerCallTrace = TypedCallTrace<[string], SetLockerCallObject>;
export interface SymbolCallObject {
}
export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
export interface TotalSupplyCallObject {
}
export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
export interface TransferCallObject {
    recipient: string;
    amount: bigint;
}
export type TransferCallTrace = TypedCallTrace<[
    string,
    bigint
], TransferCallObject>;
export interface TransferFromCallObject {
    sender: string;
    recipient: string;
    amount: bigint;
}
export type TransferFromCallTrace = TypedCallTrace<[
    string,
    string,
    bigint
], TransferFromCallObject>;
export interface TransferOwnershipCallObject {
    newOwner: string;
}
export type TransferOwnershipCallTrace = TypedCallTrace<[
    string
], TransferOwnershipCallObject>;
export declare class ERC20ContractView extends ContractView<ERC20> {
    constructor(contract: ERC20);
    allowance(owner: string, spender: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    balanceOf(account: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    decimals(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    locker(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    name(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    owner(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    symbol(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    totalSupply(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    callStatic: {
        contract: ERC20;
        approve(spender: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        burn(amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        renounceOwnership(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        setLocker(_locker: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
        transferOwnership(newOwner: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
    };
    encodeCall: {
        allowance(owner: string, spender: string, callContext: EthCallContext): EthCallParam;
        approve(spender: string, amount: BigNumberish, callContext: EthCallContext): EthCallParam;
        balanceOf(account: string, callContext: EthCallContext): EthCallParam;
        burn(amount: BigNumberish, callContext: EthCallContext): EthCallParam;
        burnFrom(account: string, amount: BigNumberish, callContext: EthCallContext): EthCallParam;
        decimals(callContext: EthCallContext): EthCallParam;
        decreaseAllowance(spender: string, subtractedValue: BigNumberish, callContext: EthCallContext): EthCallParam;
        increaseAllowance(spender: string, addedValue: BigNumberish, callContext: EthCallContext): EthCallParam;
        locker(callContext: EthCallContext): EthCallParam;
        name(callContext: EthCallContext): EthCallParam;
        owner(callContext: EthCallContext): EthCallParam;
        renounceOwnership(callContext: EthCallContext): EthCallParam;
        setLocker(_locker: string, callContext: EthCallContext): EthCallParam;
        symbol(callContext: EthCallContext): EthCallParam;
        totalSupply(callContext: EthCallContext): EthCallParam;
        transfer(recipient: string, amount: BigNumberish, callContext: EthCallContext): EthCallParam;
        transferFrom(sender: string, recipient: string, amount: BigNumberish, callContext: EthCallContext): EthCallParam;
        transferOwnership(newOwner: string, callContext: EthCallContext): EthCallParam;
    };
}
export declare class ERC20BoundContractView extends BoundContractView<ERC20, ERC20ContractView> {
    allowance(owner: string, spender: string, overrides?: Overrides): Promise<bigint>;
    balanceOf(account: string, overrides?: Overrides): Promise<bigint>;
    decimals(overrides?: Overrides): Promise<bigint>;
    locker(overrides?: Overrides): Promise<string>;
    name(overrides?: Overrides): Promise<string>;
    owner(overrides?: Overrides): Promise<string>;
    symbol(overrides?: Overrides): Promise<string>;
    totalSupply(overrides?: Overrides): Promise<bigint>;
    callStatic: {
        view: ERC20ContractView;
        context: EthContext;
        approve(spender: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
        burn(amount: BigNumberish, overrides?: Overrides): Promise<void>;
        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides): Promise<void>;
        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides): Promise<boolean>;
        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides): Promise<boolean>;
        renounceOwnership(overrides?: Overrides): Promise<void>;
        setLocker(_locker: string, overrides?: Overrides): Promise<void>;
        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
        transferOwnership(newOwner: string, overrides?: Overrides): Promise<void>;
    };
    encodeCall: {
        view: ERC20ContractView;
        context: EthContext;
        allowance(owner: string, spender: string, overrides?: Overrides): EthCallParam;
        approve(spender: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
        balanceOf(account: string, overrides?: Overrides): EthCallParam;
        burn(amount: BigNumberish, overrides?: Overrides): EthCallParam;
        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
        decimals(overrides?: Overrides): EthCallParam;
        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides): EthCallParam;
        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides): EthCallParam;
        locker(overrides?: Overrides): EthCallParam;
        name(overrides?: Overrides): EthCallParam;
        owner(overrides?: Overrides): EthCallParam;
        renounceOwnership(overrides?: Overrides): EthCallParam;
        setLocker(_locker: string, overrides?: Overrides): EthCallParam;
        symbol(overrides?: Overrides): EthCallParam;
        totalSupply(overrides?: Overrides): EthCallParam;
        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
        transferOwnership(newOwner: string, overrides?: Overrides): EthCallParam;
    };
}
export type ERC20Context = ContractContext<ERC20, ERC20BoundContractView>;
export declare class ERC20Processor extends BaseProcessor<ERC20, ERC20BoundContractView> {
    onEventApproval(handler: (event: ApprovalEvent, ctx: ERC20Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferred(handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void, filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>, preprocessHandler?: (event: OwnershipTransferredEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: ERC20Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onCallAllowance(handler: (call: AllowanceCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, AllowanceCallTrace>, preprocessHandler?: (call: AllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallApprove(handler: (call: ApproveCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ApproveCallTrace>, preprocessHandler?: (call: ApproveCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallBalanceOf(handler: (call: BalanceOfCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, BalanceOfCallTrace>, preprocessHandler?: (call: BalanceOfCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallBurn(handler: (call: BurnCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, BurnCallTrace>, preprocessHandler?: (call: BurnCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallBurnFrom(handler: (call: BurnFromCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, BurnFromCallTrace>, preprocessHandler?: (call: BurnFromCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallDecimals(handler: (call: DecimalsCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>, preprocessHandler?: (call: DecimalsCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallDecreaseAllowance(handler: (call: DecreaseAllowanceCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DecreaseAllowanceCallTrace>, preprocessHandler?: (call: DecreaseAllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallIncreaseAllowance(handler: (call: IncreaseAllowanceCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, IncreaseAllowanceCallTrace>, preprocessHandler?: (call: IncreaseAllowanceCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallLocker(handler: (call: LockerCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, LockerCallTrace>, preprocessHandler?: (call: LockerCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallName(handler: (call: NameCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, NameCallTrace>, preprocessHandler?: (call: NameCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallOwner(handler: (call: OwnerCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, OwnerCallTrace>, preprocessHandler?: (call: OwnerCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallRenounceOwnership(handler: (call: RenounceOwnershipCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, RenounceOwnershipCallTrace>, preprocessHandler?: (call: RenounceOwnershipCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallSetLocker(handler: (call: SetLockerCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SetLockerCallTrace>, preprocessHandler?: (call: SetLockerCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallSymbol(handler: (call: SymbolCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SymbolCallTrace>, preprocessHandler?: (call: SymbolCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallTotalSupply(handler: (call: TotalSupplyCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TotalSupplyCallTrace>, preprocessHandler?: (call: TotalSupplyCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallTransfer(handler: (call: TransferCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferCallTrace>, preprocessHandler?: (call: TransferCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallTransferFrom(handler: (call: TransferFromCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferFromCallTrace>, preprocessHandler?: (call: TransferFromCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    onCallTransferOwnership(handler: (call: TransferOwnershipCallTrace, ctx: ERC20Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferOwnershipCallTrace>, preprocessHandler?: (call: TransferOwnershipCallTrace, ctx: ERC20Context) => Promise<PreprocessResult>): this;
    static filters: {
        Approval(owner?: string | null, spender?: string | null, value?: null): ApprovalEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        Transfer(from?: string | null, to?: string | null, value?: null): TransferEventFilter;
    };
    protected CreateBoundContractView(): ERC20BoundContractView;
    static bind(options: BindOptions): ERC20Processor;
}
export declare class ERC20ProcessorTemplate extends BaseProcessorTemplate<ERC20, ERC20BoundContractView> {
    bindInternal(options: BindOptions): ERC20Processor;
    onEventApproval(handler: (event: ApprovalEvent, ctx: ERC20Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferred(handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void, filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>, preprocessHandler?: (event: OwnershipTransferredEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: ERC20Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: ERC20Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
}
export declare function getERC20Contract(chainId: EthChainId, address: string): ERC20ContractView;
export declare function getERC20ContractOnContext(context: EthContext, address: string): ERC20BoundContractView;
//# sourceMappingURL=erc20-processor.d.ts.map