import { TAddress } from '../../models/TAddress';
import { TAccount } from '../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../clients/ClientEventsStream';
import { ContractBase } from '../../contracts/ContractBase';
import { TxWriter } from '../../txs/TxWriter';
import { ITxLogItem } from '../../txs/receipt/ITxLogItem';
import { Web3Client } from '../../clients/Web3Client';
import { IBlockchainExplorer } from '../../explorer/IBlockchainExplorer';
import { SubjectStream } from '../../class/SubjectStream';
import type { TAbiItem } from '../../types/TAbi';
import type { TEth } from '../../models/TEth';
import type { TOverrideReturns } from '../../utils/types';
export declare namespace ERC721VotesErrors {
    interface InvalidShortString {
        type: 'InvalidShortString';
        params: {};
    }
    interface StringTooLong {
        type: 'StringTooLong';
        params: {
            str: string;
        };
    }
    type Error = InvalidShortString | StringTooLong;
}
export declare class ERC721Votes extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TERC721VotesTypes;
    $meta: {
        class: string;
    };
    CLOCK_MODE(): Promise<string>;
    DOMAIN_SEPARATOR(): Promise<TEth.Hex>;
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    balanceOf(owner: TAddress): Promise<bigint>;
    clock(): Promise<number>;
    delegate(sender: TSender, delegatee: TAddress): Promise<TxWriter>;
    delegateBySig(sender: TSender, delegatee: TAddress, nonce: bigint, expiry: bigint, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    delegates(account: TAddress): Promise<TAddress>;
    eip712Domain(): Promise<{
        fields: TEth.Hex;
        name: string;
        version: string;
        chainId: bigint;
        verifyingContract: TAddress;
        salt: TEth.Hex;
        extensions: bigint[];
    }>;
    getApproved(tokenId: bigint): Promise<TAddress>;
    getPastTotalSupply(timepoint: bigint): Promise<bigint>;
    getPastVotes(account: TAddress, timepoint: bigint): Promise<bigint>;
    getVotes(account: TAddress): Promise<bigint>;
    isApprovedForAll(owner: TAddress, operator: TAddress): Promise<boolean>;
    name(): Promise<string>;
    nonces(owner: TAddress): Promise<bigint>;
    ownerOf(tokenId: bigint): Promise<TAddress>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TxWriter>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TxWriter>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    symbol(): Promise<string>;
    tokenURI(tokenId: bigint): Promise<string>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    $call(): IERC721VotesTxCaller;
    $signed(): TOverrideReturns<IERC721VotesTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IERC721VotesTxData;
    $gas(): TOverrideReturns<IERC721VotesTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TERC721VotesTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TERC721VotesTypes['Methods'][TMethod]['arguments'];
        };
    }>;
    onLog(event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>;
    getPastLogs<TEventName extends keyof TEvents>(events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    getPastLogs<TEventName extends keyof TEvents>(event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    onApproval(fn?: (event: TClientEventsStreamData<TEventArguments<'Approval'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Approval'>>>;
    onApprovalForAll(fn?: (event: TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>>;
    onDelegateChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'DelegateChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DelegateChanged'>>>;
    onDelegateVotesChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'DelegateVotesChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DelegateVotesChanged'>>>;
    onEIP712DomainChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'EIP712DomainChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'EIP712DomainChanged'>>>;
    onTransfer(fn?: (event: TClientEventsStreamData<TEventArguments<'Transfer'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Transfer'>>>;
    extractLogsApproval(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approval'>>[];
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsDelegateChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DelegateChanged'>>[];
    extractLogsDelegateVotesChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DelegateVotesChanged'>>[];
    extractLogsEIP712DomainChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'EIP712DomainChanged'>>[];
    extractLogsTransfer(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Transfer'>>[];
    getPastLogsApproval(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            approved?: TAddress;
            tokenId?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Approval'>>[]>;
    getPastLogsApprovalForAll(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsDelegateChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            delegator?: TAddress;
            fromDelegate?: TAddress;
            toDelegate?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'DelegateChanged'>>[]>;
    getPastLogsDelegateVotesChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            delegate?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'DelegateVotesChanged'>>[]>;
    getPastLogsEIP712DomainChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'EIP712DomainChanged'>>[]>;
    getPastLogsTransfer(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            from?: TAddress;
            to?: TAddress;
            tokenId?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Transfer'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TERC721VotesTypes = {
    Events: {
        Approval: {
            outputParams: {
                owner: TAddress;
                approved: TAddress;
                tokenId: bigint;
            };
            outputArgs: [owner: TAddress, approved: TAddress, tokenId: bigint];
        };
        ApprovalForAll: {
            outputParams: {
                owner: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [owner: TAddress, operator: TAddress, approved: boolean];
        };
        DelegateChanged: {
            outputParams: {
                delegator: TAddress;
                fromDelegate: TAddress;
                toDelegate: TAddress;
            };
            outputArgs: [delegator: TAddress, fromDelegate: TAddress, toDelegate: TAddress];
        };
        DelegateVotesChanged: {
            outputParams: {
                delegate: TAddress;
                previousBalance: bigint;
                newBalance: bigint;
            };
            outputArgs: [delegate: TAddress, previousBalance: bigint, newBalance: bigint];
        };
        EIP712DomainChanged: {
            outputParams: {};
            outputArgs: [];
        };
        Transfer: {
            outputParams: {
                from: TAddress;
                to: TAddress;
                tokenId: bigint;
            };
            outputArgs: [from: TAddress, to: TAddress, tokenId: bigint];
        };
    };
    Methods: {
        CLOCK_MODE: {
            method: "CLOCK_MODE";
            arguments: [];
        };
        DOMAIN_SEPARATOR: {
            method: "DOMAIN_SEPARATOR";
            arguments: [];
        };
        approve: {
            method: "approve";
            arguments: [to: TAddress, tokenId: bigint];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [owner: TAddress];
        };
        clock: {
            method: "clock";
            arguments: [];
        };
        delegate: {
            method: "delegate";
            arguments: [delegatee: TAddress];
        };
        delegateBySig: {
            method: "delegateBySig";
            arguments: [delegatee: TAddress, nonce: bigint, expiry: bigint, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        delegates: {
            method: "delegates";
            arguments: [account: TAddress];
        };
        eip712Domain: {
            method: "eip712Domain";
            arguments: [];
        };
        getApproved: {
            method: "getApproved";
            arguments: [tokenId: bigint];
        };
        getPastTotalSupply: {
            method: "getPastTotalSupply";
            arguments: [timepoint: bigint];
        };
        getPastVotes: {
            method: "getPastVotes";
            arguments: [account: TAddress, timepoint: bigint];
        };
        getVotes: {
            method: "getVotes";
            arguments: [account: TAddress];
        };
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [owner: TAddress, operator: TAddress];
        };
        name: {
            method: "name";
            arguments: [];
        };
        nonces: {
            method: "nonces";
            arguments: [owner: TAddress];
        };
        ownerOf: {
            method: "ownerOf";
            arguments: [tokenId: bigint];
        };
        safeTransferFrom: {
            method: "safeTransferFrom";
            arguments: [from: TAddress, to: TAddress, tokenId: bigint] | [from: TAddress, to: TAddress, tokenId: bigint, data: TEth.Hex];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [operator: TAddress, approved: boolean];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex];
        };
        symbol: {
            method: "symbol";
            arguments: [];
        };
        tokenURI: {
            method: "tokenURI";
            arguments: [tokenId: bigint];
        };
        transferFrom: {
            method: "transferFrom";
            arguments: [from: TAddress, to: TAddress, tokenId: bigint];
        };
    };
};
interface IERC721VotesTxCaller {
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    delegate(sender: TSender, delegatee: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    delegateBySig(sender: TSender, delegatee: TAddress, nonce: bigint, expiry: bigint, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IERC721VotesTxData {
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    delegate(sender: TSender, delegatee: TAddress): Promise<TEth.TxLike>;
    delegateBySig(sender: TSender, delegatee: TAddress, nonce: bigint, expiry: bigint, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TEth.TxLike>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
}
type TEvents = TERC721VotesTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};