import { BigNumberish, Overrides, BytesLike } 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 { ERC721, ApprovalEvent, ApprovalEventFilter, ApprovalForAllEvent, ApprovalForAllEventFilter, TransferEvent, TransferEventFilter } from "./ERC721.js";
export interface ApproveCallObject {
    to: string;
    tokenId: bigint;
}
export type ApproveCallTrace = TypedCallTrace<[
    string,
    bigint
], ApproveCallObject>;
export interface TotalSupplyCallObject {
}
export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
export interface BalanceOfCallObject {
    owner: string;
}
export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
export interface GetApprovedCallObject {
    tokenId: bigint;
}
export type GetApprovedCallTrace = TypedCallTrace<[
    bigint
], GetApprovedCallObject>;
export interface IsApprovedForAllCallObject {
    owner: string;
    operator: string;
}
export type IsApprovedForAllCallTrace = TypedCallTrace<[
    string,
    string
], IsApprovedForAllCallObject>;
export interface NameCallObject {
}
export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
export interface OwnerOfCallObject {
    tokenId: bigint;
}
export type OwnerOfCallTrace = TypedCallTrace<[bigint], OwnerOfCallObject>;
export interface SafeTransferFrom_address_address_uint256CallObject {
    from: string;
    to: string;
    tokenId: bigint;
}
export type SafeTransferFrom_address_address_uint256CallTrace = TypedCallTrace<[
    string,
    string,
    bigint
], SafeTransferFrom_address_address_uint256CallObject>;
export interface SafeTransferFrom_address_address_uint256_bytesCallObject {
    from: string;
    to: string;
    tokenId: bigint;
    data: string;
}
export type SafeTransferFrom_address_address_uint256_bytesCallTrace = TypedCallTrace<[
    string,
    string,
    bigint,
    string
], SafeTransferFrom_address_address_uint256_bytesCallObject>;
export interface SetApprovalForAllCallObject {
    operator: string;
    _approved: boolean;
}
export type SetApprovalForAllCallTrace = TypedCallTrace<[
    string,
    boolean
], SetApprovalForAllCallObject>;
export interface SupportsInterfaceCallObject {
    interfaceId: string;
}
export type SupportsInterfaceCallTrace = TypedCallTrace<[
    string
], SupportsInterfaceCallObject>;
export interface SymbolCallObject {
}
export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
export interface TokenURICallObject {
    tokenId: bigint;
}
export type TokenURICallTrace = TypedCallTrace<[bigint], TokenURICallObject>;
export interface TransferFromCallObject {
    from: string;
    to: string;
    tokenId: bigint;
}
export type TransferFromCallTrace = TypedCallTrace<[
    string,
    string,
    bigint
], TransferFromCallObject>;
export declare class ERC721ContractView extends ContractView<ERC721> {
    constructor(contract: ERC721);
    totalSupply(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    balanceOf(owner: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    getApproved(tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    isApprovedForAll(owner: string, operator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
    name(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    ownerOf(tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    supportsInterface(interfaceId: BytesLike, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
    symbol(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    tokenURI(tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    callStatic: {
        contract: ERC721;
        approve(to: string, tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        safeTransferFrom_address_address_uint256(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        safeTransferFrom_address_address_uint256_bytes(from: string, to: string, tokenId: BigNumberish, data: BytesLike, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        setApprovalForAll(operator: string, _approved: boolean, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        transferFrom(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
    };
    encodeCall: {
        approve(to: string, tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
        totalSupply(callContext: EthCallContext): EthCallParam;
        balanceOf(owner: string, callContext: EthCallContext): EthCallParam;
        getApproved(tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
        isApprovedForAll(owner: string, operator: string, callContext: EthCallContext): EthCallParam;
        name(callContext: EthCallContext): EthCallParam;
        ownerOf(tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
        safeTransferFrom_address_address_uint256(from: string, to: string, tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
        safeTransferFrom_address_address_uint256_bytes(from: string, to: string, tokenId: BigNumberish, data: BytesLike, callContext: EthCallContext): EthCallParam;
        setApprovalForAll(operator: string, _approved: boolean, callContext: EthCallContext): EthCallParam;
        supportsInterface(interfaceId: BytesLike, callContext: EthCallContext): EthCallParam;
        symbol(callContext: EthCallContext): EthCallParam;
        tokenURI(tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
        transferFrom(from: string, to: string, tokenId: BigNumberish, callContext: EthCallContext): EthCallParam;
    };
}
export declare class ERC721BoundContractView extends BoundContractView<ERC721, ERC721ContractView> {
    totalSupply(overrides?: Overrides): Promise<bigint>;
    balanceOf(owner: string, overrides?: Overrides): Promise<bigint>;
    getApproved(tokenId: BigNumberish, overrides?: Overrides): Promise<string>;
    isApprovedForAll(owner: string, operator: string, overrides?: Overrides): Promise<boolean>;
    name(overrides?: Overrides): Promise<string>;
    ownerOf(tokenId: BigNumberish, overrides?: Overrides): Promise<string>;
    supportsInterface(interfaceId: BytesLike, overrides?: Overrides): Promise<boolean>;
    symbol(overrides?: Overrides): Promise<string>;
    tokenURI(tokenId: BigNumberish, overrides?: Overrides): Promise<string>;
    callStatic: {
        view: ERC721ContractView;
        context: EthContext;
        approve(to: string, tokenId: BigNumberish, overrides?: Overrides): Promise<void>;
        safeTransferFrom_address_address_uint256(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides): Promise<void>;
        safeTransferFrom_address_address_uint256_bytes(from: string, to: string, tokenId: BigNumberish, data: BytesLike, overrides?: Overrides): Promise<void>;
        setApprovalForAll(operator: string, _approved: boolean, overrides?: Overrides): Promise<void>;
        transferFrom(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides): Promise<void>;
    };
    encodeCall: {
        view: ERC721ContractView;
        context: EthContext;
        approve(to: string, tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
        totalSupply(overrides?: Overrides): EthCallParam;
        balanceOf(owner: string, overrides?: Overrides): EthCallParam;
        getApproved(tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
        isApprovedForAll(owner: string, operator: string, overrides?: Overrides): EthCallParam;
        name(overrides?: Overrides): EthCallParam;
        ownerOf(tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
        safeTransferFrom_address_address_uint256(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
        safeTransferFrom_address_address_uint256_bytes(from: string, to: string, tokenId: BigNumberish, data: BytesLike, overrides?: Overrides): EthCallParam;
        setApprovalForAll(operator: string, _approved: boolean, overrides?: Overrides): EthCallParam;
        supportsInterface(interfaceId: BytesLike, overrides?: Overrides): EthCallParam;
        symbol(overrides?: Overrides): EthCallParam;
        tokenURI(tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
        transferFrom(from: string, to: string, tokenId: BigNumberish, overrides?: Overrides): EthCallParam;
    };
}
export type ERC721Context = ContractContext<ERC721, ERC721BoundContractView>;
export declare class ERC721Processor extends BaseProcessor<ERC721, ERC721BoundContractView> {
    onEventApproval(handler: (event: ApprovalEvent, ctx: ERC721Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventApprovalForAll(handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void, filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalForAllEvent>, preprocessHandler?: (event: ApprovalForAllEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: ERC721Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onCallApprove(handler: (call: ApproveCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ApproveCallTrace>, preprocessHandler?: (call: ApproveCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallTotalSupply(handler: (call: TotalSupplyCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TotalSupplyCallTrace>, preprocessHandler?: (call: TotalSupplyCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallBalanceOf(handler: (call: BalanceOfCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, BalanceOfCallTrace>, preprocessHandler?: (call: BalanceOfCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallGetApproved(handler: (call: GetApprovedCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, GetApprovedCallTrace>, preprocessHandler?: (call: GetApprovedCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallIsApprovedForAll(handler: (call: IsApprovedForAllCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, IsApprovedForAllCallTrace>, preprocessHandler?: (call: IsApprovedForAllCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallName(handler: (call: NameCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, NameCallTrace>, preprocessHandler?: (call: NameCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallOwnerOf(handler: (call: OwnerOfCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, OwnerOfCallTrace>, preprocessHandler?: (call: OwnerOfCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallSafeTransferFrom_address_address_uint256(handler: (call: SafeTransferFrom_address_address_uint256CallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SafeTransferFrom_address_address_uint256CallTrace>, preprocessHandler?: (call: SafeTransferFrom_address_address_uint256CallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallSafeTransferFrom_address_address_uint256_bytes(handler: (call: SafeTransferFrom_address_address_uint256_bytesCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SafeTransferFrom_address_address_uint256_bytesCallTrace>, preprocessHandler?: (call: SafeTransferFrom_address_address_uint256_bytesCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallSetApprovalForAll(handler: (call: SetApprovalForAllCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SetApprovalForAllCallTrace>, preprocessHandler?: (call: SetApprovalForAllCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallSupportsInterface(handler: (call: SupportsInterfaceCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SupportsInterfaceCallTrace>, preprocessHandler?: (call: SupportsInterfaceCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallSymbol(handler: (call: SymbolCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SymbolCallTrace>, preprocessHandler?: (call: SymbolCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallTokenURI(handler: (call: TokenURICallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TokenURICallTrace>, preprocessHandler?: (call: TokenURICallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    onCallTransferFrom(handler: (call: TransferFromCallTrace, ctx: ERC721Context) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferFromCallTrace>, preprocessHandler?: (call: TransferFromCallTrace, ctx: ERC721Context) => Promise<PreprocessResult>): this;
    static filters: {
        Approval(owner?: string | null, approved?: string | null, tokenId?: BigNumberish | null): ApprovalEventFilter;
        ApprovalForAll(owner?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
        Transfer(from?: string | null, to?: string | null, tokenId?: BigNumberish | null): TransferEventFilter;
    };
    protected CreateBoundContractView(): ERC721BoundContractView;
    static bind(options: BindOptions): ERC721Processor;
}
export declare class ERC721ProcessorTemplate extends BaseProcessorTemplate<ERC721, ERC721BoundContractView> {
    bindInternal(options: BindOptions): ERC721Processor;
    onEventApproval(handler: (event: ApprovalEvent, ctx: ERC721Context) => void, filter?: ApprovalEventFilter | ApprovalEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalEvent>, preprocessHandler?: (event: ApprovalEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventApprovalForAll(handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void, filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, ApprovalForAllEvent>, preprocessHandler?: (event: ApprovalForAllEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventTransfer(handler: (event: TransferEvent, ctx: ERC721Context) => void, filter?: TransferEventFilter | TransferEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, TransferEvent>, preprocessHandler?: (event: TransferEvent, ctx: ERC721Context, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
}
export declare function getERC721Contract(chainId: EthChainId, address: string): ERC721ContractView;
export declare function getERC721ContractOnContext(context: EthContext, address: string): ERC721BoundContractView;
//# sourceMappingURL=erc721-processor.d.ts.map