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 GovernorCountingSimpleErrors {
    interface Empty {
        type: 'Empty';
        params: {};
    }
    interface InvalidShortString {
        type: 'InvalidShortString';
        params: {};
    }
    interface StringTooLong {
        type: 'StringTooLong';
        params: {
            str: string;
        };
    }
    type Error = Empty | InvalidShortString | StringTooLong;
}
export declare class GovernorCountingSimple extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TGovernorCountingSimpleTypes;
    $meta: {
        class: string;
    };
    BALLOT_TYPEHASH(): Promise<TEth.Hex>;
    CLOCK_MODE(): Promise<string>;
    COUNTING_MODE(): Promise<string>;
    EXTENDED_BALLOT_TYPEHASH(): Promise<TEth.Hex>;
    cancel(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<TxWriter>;
    castVote(sender: TSender, proposalId: bigint, support: number): Promise<TxWriter>;
    castVoteBySig(sender: TSender, proposalId: bigint, support: number, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    castVoteWithReason(sender: TSender, proposalId: bigint, support: number, reason: string): Promise<TxWriter>;
    castVoteWithReasonAndParams(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex): Promise<TxWriter>;
    castVoteWithReasonAndParamsBySig(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TxWriter>;
    clock(): Promise<number>;
    eip712Domain(): Promise<{
        fields: TEth.Hex;
        name: string;
        version: string;
        chainId: bigint;
        verifyingContract: TAddress;
        salt: TEth.Hex;
        extensions: bigint[];
    }>;
    execute(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<TxWriter>;
    getVotes(account: TAddress, timepoint: bigint): Promise<bigint>;
    getVotesWithParams(account: TAddress, timepoint: bigint, params: TEth.Hex): Promise<bigint>;
    hasVoted(proposalId: bigint, account: TAddress): Promise<boolean>;
    hashProposal(targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<bigint>;
    name(): Promise<string>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<TxWriter>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<TxWriter>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<TxWriter>;
    proposalDeadline(proposalId: bigint): Promise<bigint>;
    proposalProposer(proposalId: bigint): Promise<TAddress>;
    proposalSnapshot(proposalId: bigint): Promise<bigint>;
    proposalThreshold(): Promise<bigint>;
    proposalVotes(proposalId: bigint): Promise<{
        againstVotes: bigint;
        forVotes: bigint;
        abstainVotes: bigint;
    }>;
    propose(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], description: string): Promise<TxWriter>;
    quorum(timepoint: bigint): Promise<bigint>;
    relay(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    state(proposalId: bigint): Promise<number>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    version(): Promise<string>;
    votingDelay(): Promise<bigint>;
    votingPeriod(): Promise<bigint>;
    $call(): IGovernorCountingSimpleTxCaller;
    $signed(): TOverrideReturns<IGovernorCountingSimpleTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IGovernorCountingSimpleTxData;
    $gas(): TOverrideReturns<IGovernorCountingSimpleTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TGovernorCountingSimpleTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TGovernorCountingSimpleTypes['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>[]>;
    onEIP712DomainChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'EIP712DomainChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'EIP712DomainChanged'>>>;
    onProposalCanceled(fn?: (event: TClientEventsStreamData<TEventArguments<'ProposalCanceled'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ProposalCanceled'>>>;
    onProposalCreated(fn?: (event: TClientEventsStreamData<TEventArguments<'ProposalCreated'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ProposalCreated'>>>;
    onProposalExecuted(fn?: (event: TClientEventsStreamData<TEventArguments<'ProposalExecuted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ProposalExecuted'>>>;
    onVoteCast(fn?: (event: TClientEventsStreamData<TEventArguments<'VoteCast'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'VoteCast'>>>;
    onVoteCastWithParams(fn?: (event: TClientEventsStreamData<TEventArguments<'VoteCastWithParams'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'VoteCastWithParams'>>>;
    extractLogsEIP712DomainChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'EIP712DomainChanged'>>[];
    extractLogsProposalCanceled(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ProposalCanceled'>>[];
    extractLogsProposalCreated(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ProposalCreated'>>[];
    extractLogsProposalExecuted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ProposalExecuted'>>[];
    extractLogsVoteCast(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'VoteCast'>>[];
    extractLogsVoteCastWithParams(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'VoteCastWithParams'>>[];
    getPastLogsEIP712DomainChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'EIP712DomainChanged'>>[]>;
    getPastLogsProposalCanceled(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'ProposalCanceled'>>[]>;
    getPastLogsProposalCreated(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'ProposalCreated'>>[]>;
    getPastLogsProposalExecuted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'ProposalExecuted'>>[]>;
    getPastLogsVoteCast(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            voter?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'VoteCast'>>[]>;
    getPastLogsVoteCastWithParams(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            voter?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'VoteCastWithParams'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TGovernorCountingSimpleTypes = {
    Events: {
        EIP712DomainChanged: {
            outputParams: {};
            outputArgs: [];
        };
        ProposalCanceled: {
            outputParams: {
                proposalId: bigint;
            };
            outputArgs: [proposalId: bigint];
        };
        ProposalCreated: {
            outputParams: {
                proposalId: bigint;
                proposer: TAddress;
                targets: TAddress[];
                values: bigint[];
                signatures: string[];
                calldatas: TEth.Hex[];
                voteStart: bigint;
                voteEnd: bigint;
                description: string;
            };
            outputArgs: [proposalId: bigint, proposer: TAddress, targets: TAddress[], values: bigint[], signatures: string[], calldatas: TEth.Hex[], voteStart: bigint, voteEnd: bigint, description: string];
        };
        ProposalExecuted: {
            outputParams: {
                proposalId: bigint;
            };
            outputArgs: [proposalId: bigint];
        };
        VoteCast: {
            outputParams: {
                voter: TAddress;
                proposalId: bigint;
                support: number;
                weight: bigint;
                reason: string;
            };
            outputArgs: [voter: TAddress, proposalId: bigint, support: number, weight: bigint, reason: string];
        };
        VoteCastWithParams: {
            outputParams: {
                voter: TAddress;
                proposalId: bigint;
                support: number;
                weight: bigint;
                reason: string;
                params: TEth.Hex;
            };
            outputArgs: [voter: TAddress, proposalId: bigint, support: number, weight: bigint, reason: string, params: TEth.Hex];
        };
    };
    Methods: {
        BALLOT_TYPEHASH: {
            method: "BALLOT_TYPEHASH";
            arguments: [];
        };
        CLOCK_MODE: {
            method: "CLOCK_MODE";
            arguments: [];
        };
        COUNTING_MODE: {
            method: "COUNTING_MODE";
            arguments: [];
        };
        EXTENDED_BALLOT_TYPEHASH: {
            method: "EXTENDED_BALLOT_TYPEHASH";
            arguments: [];
        };
        cancel: {
            method: "cancel";
            arguments: [targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex];
        };
        castVote: {
            method: "castVote";
            arguments: [proposalId: bigint, support: number];
        };
        castVoteBySig: {
            method: "castVoteBySig";
            arguments: [proposalId: bigint, support: number, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        castVoteWithReason: {
            method: "castVoteWithReason";
            arguments: [proposalId: bigint, support: number, reason: string];
        };
        castVoteWithReasonAndParams: {
            method: "castVoteWithReasonAndParams";
            arguments: [proposalId: bigint, support: number, reason: string, params: TEth.Hex];
        };
        castVoteWithReasonAndParamsBySig: {
            method: "castVoteWithReasonAndParamsBySig";
            arguments: [proposalId: bigint, support: number, reason: string, params: TEth.Hex, v: number, r: TEth.Hex, s: TEth.Hex];
        };
        clock: {
            method: "clock";
            arguments: [];
        };
        eip712Domain: {
            method: "eip712Domain";
            arguments: [];
        };
        execute: {
            method: "execute";
            arguments: [targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex];
        };
        getVotes: {
            method: "getVotes";
            arguments: [account: TAddress, timepoint: bigint];
        };
        getVotesWithParams: {
            method: "getVotesWithParams";
            arguments: [account: TAddress, timepoint: bigint, params: TEth.Hex];
        };
        hasVoted: {
            method: "hasVoted";
            arguments: [proposalId: bigint, account: TAddress];
        };
        hashProposal: {
            method: "hashProposal";
            arguments: [targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex];
        };
        name: {
            method: "name";
            arguments: [];
        };
        onERC1155BatchReceived: {
            method: "onERC1155BatchReceived";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex];
        };
        onERC1155Received: {
            method: "onERC1155Received";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex];
        };
        onERC721Received: {
            method: "onERC721Received";
            arguments: [input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex];
        };
        proposalDeadline: {
            method: "proposalDeadline";
            arguments: [proposalId: bigint];
        };
        proposalProposer: {
            method: "proposalProposer";
            arguments: [proposalId: bigint];
        };
        proposalSnapshot: {
            method: "proposalSnapshot";
            arguments: [proposalId: bigint];
        };
        proposalThreshold: {
            method: "proposalThreshold";
            arguments: [];
        };
        proposalVotes: {
            method: "proposalVotes";
            arguments: [proposalId: bigint];
        };
        propose: {
            method: "propose";
            arguments: [targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], description: string];
        };
        quorum: {
            method: "quorum";
            arguments: [timepoint: bigint];
        };
        relay: {
            method: "relay";
            arguments: [target: TAddress, value: bigint, data: TEth.Hex];
        };
        state: {
            method: "state";
            arguments: [proposalId: bigint];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex];
        };
        version: {
            method: "version";
            arguments: [];
        };
        votingDelay: {
            method: "votingDelay";
            arguments: [];
        };
        votingPeriod: {
            method: "votingPeriod";
            arguments: [];
        };
    };
};
interface IGovernorCountingSimpleTxCaller {
    cancel(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    castVote(sender: TSender, proposalId: bigint, support: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    castVoteBySig(sender: TSender, proposalId: bigint, support: number, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    castVoteWithReason(sender: TSender, proposalId: bigint, support: number, reason: string): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    castVoteWithReasonAndParams(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    castVoteWithReasonAndParamsBySig(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex, v: number, r: TEth.Hex, s: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execute(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    propose(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], description: string): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    relay(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IGovernorCountingSimpleTxData {
    cancel(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<TEth.TxLike>;
    castVote(sender: TSender, proposalId: bigint, support: number): Promise<TEth.TxLike>;
    castVoteBySig(sender: TSender, proposalId: bigint, support: number, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    castVoteWithReason(sender: TSender, proposalId: bigint, support: number, reason: string): Promise<TEth.TxLike>;
    castVoteWithReasonAndParams(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex): Promise<TEth.TxLike>;
    castVoteWithReasonAndParamsBySig(sender: TSender, proposalId: bigint, support: number, reason: string, params: TEth.Hex, v: number, r: TEth.Hex, s: TEth.Hex): Promise<TEth.TxLike>;
    execute(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], descriptionHash: TEth.Hex): Promise<TEth.TxLike>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<TEth.TxLike>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<TEth.TxLike>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<TEth.TxLike>;
    propose(sender: TSender, targets: TAddress[], values: bigint[], calldatas: TEth.Hex[], description: string): Promise<TEth.TxLike>;
    relay(sender: TSender, target: TAddress, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TGovernorCountingSimpleTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};