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 class ERC777 extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TERC777Types;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, name_: string, symbol_: string, defaultOperators_: TAddress[]): Promise<TxWriter>;
    allowance(holder: TAddress, spender: TAddress): Promise<bigint>;
    approve(sender: TSender, spender: TAddress, value: bigint): Promise<TxWriter>;
    authorizeOperator(sender: TSender, operator: TAddress): Promise<TxWriter>;
    balanceOf(tokenHolder: TAddress): Promise<bigint>;
    burn(sender: TSender, amount: bigint, data: TEth.Hex): Promise<TxWriter>;
    decimals(): Promise<number>;
    defaultOperators(): Promise<TAddress[]>;
    granularity(): Promise<bigint>;
    isOperatorFor(operator: TAddress, tokenHolder: TAddress): Promise<boolean>;
    name(): Promise<string>;
    operatorBurn(sender: TSender, account: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<TxWriter>;
    operatorSend(sender: TSender, _sender: TAddress, recipient: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<TxWriter>;
    revokeOperator(sender: TSender, operator: TAddress): Promise<TxWriter>;
    send(sender: TSender, recipient: TAddress, amount: bigint, data: TEth.Hex): Promise<TxWriter>;
    symbol(): Promise<string>;
    totalSupply(): Promise<bigint>;
    transfer(sender: TSender, recipient: TAddress, amount: bigint): Promise<TxWriter>;
    transferFrom(sender: TSender, holder: TAddress, recipient: TAddress, amount: bigint): Promise<TxWriter>;
    $call(): IERC777TxCaller;
    $signed(): TOverrideReturns<IERC777TxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IERC777TxData;
    $gas(): TOverrideReturns<IERC777TxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TERC777Types['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TERC777Types['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'>>>;
    onAuthorizedOperator(fn?: (event: TClientEventsStreamData<TEventArguments<'AuthorizedOperator'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AuthorizedOperator'>>>;
    onBurned(fn?: (event: TClientEventsStreamData<TEventArguments<'Burned'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Burned'>>>;
    onMinted(fn?: (event: TClientEventsStreamData<TEventArguments<'Minted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Minted'>>>;
    onRevokedOperator(fn?: (event: TClientEventsStreamData<TEventArguments<'RevokedOperator'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RevokedOperator'>>>;
    onSent(fn?: (event: TClientEventsStreamData<TEventArguments<'Sent'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Sent'>>>;
    onTransfer(fn?: (event: TClientEventsStreamData<TEventArguments<'Transfer'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Transfer'>>>;
    extractLogsApproval(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approval'>>[];
    extractLogsAuthorizedOperator(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AuthorizedOperator'>>[];
    extractLogsBurned(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Burned'>>[];
    extractLogsMinted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Minted'>>[];
    extractLogsRevokedOperator(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RevokedOperator'>>[];
    extractLogsSent(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Sent'>>[];
    extractLogsTransfer(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Transfer'>>[];
    getPastLogsApproval(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            spender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Approval'>>[]>;
    getPastLogsAuthorizedOperator(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            tokenHolder?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'AuthorizedOperator'>>[]>;
    getPastLogsBurned(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Burned'>>[]>;
    getPastLogsMinted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Minted'>>[]>;
    getPastLogsRevokedOperator(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            tokenHolder?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RevokedOperator'>>[]>;
    getPastLogsSent(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Sent'>>[]>;
    getPastLogsTransfer(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            from?: TAddress;
            to?: TAddress;
        };
    }): 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 TERC777Types = {
    Events: {
        Approval: {
            outputParams: {
                owner: TAddress;
                spender: TAddress;
                value: bigint;
            };
            outputArgs: [owner: TAddress, spender: TAddress, value: bigint];
        };
        AuthorizedOperator: {
            outputParams: {
                operator: TAddress;
                tokenHolder: TAddress;
            };
            outputArgs: [operator: TAddress, tokenHolder: TAddress];
        };
        Burned: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                amount: bigint;
                data: TEth.Hex;
                operatorData: TEth.Hex;
            };
            outputArgs: [operator: TAddress, from: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex];
        };
        Minted: {
            outputParams: {
                operator: TAddress;
                to: TAddress;
                amount: bigint;
                data: TEth.Hex;
                operatorData: TEth.Hex;
            };
            outputArgs: [operator: TAddress, to: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex];
        };
        RevokedOperator: {
            outputParams: {
                operator: TAddress;
                tokenHolder: TAddress;
            };
            outputArgs: [operator: TAddress, tokenHolder: TAddress];
        };
        Sent: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                to: TAddress;
                amount: bigint;
                data: TEth.Hex;
                operatorData: TEth.Hex;
            };
            outputArgs: [operator: TAddress, from: TAddress, to: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex];
        };
        Transfer: {
            outputParams: {
                from: TAddress;
                to: TAddress;
                value: bigint;
            };
            outputArgs: [from: TAddress, to: TAddress, value: bigint];
        };
    };
    Methods: {
        allowance: {
            method: "allowance";
            arguments: [holder: TAddress, spender: TAddress];
        };
        approve: {
            method: "approve";
            arguments: [spender: TAddress, value: bigint];
        };
        authorizeOperator: {
            method: "authorizeOperator";
            arguments: [operator: TAddress];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [tokenHolder: TAddress];
        };
        burn: {
            method: "burn";
            arguments: [amount: bigint, data: TEth.Hex];
        };
        decimals: {
            method: "decimals";
            arguments: [];
        };
        defaultOperators: {
            method: "defaultOperators";
            arguments: [];
        };
        granularity: {
            method: "granularity";
            arguments: [];
        };
        isOperatorFor: {
            method: "isOperatorFor";
            arguments: [operator: TAddress, tokenHolder: TAddress];
        };
        name: {
            method: "name";
            arguments: [];
        };
        operatorBurn: {
            method: "operatorBurn";
            arguments: [account: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex];
        };
        operatorSend: {
            method: "operatorSend";
            arguments: [_sender: TAddress, recipient: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex];
        };
        revokeOperator: {
            method: "revokeOperator";
            arguments: [operator: TAddress];
        };
        send: {
            method: "send";
            arguments: [recipient: TAddress, amount: bigint, data: TEth.Hex];
        };
        symbol: {
            method: "symbol";
            arguments: [];
        };
        totalSupply: {
            method: "totalSupply";
            arguments: [];
        };
        transfer: {
            method: "transfer";
            arguments: [recipient: TAddress, amount: bigint];
        };
        transferFrom: {
            method: "transferFrom";
            arguments: [holder: TAddress, recipient: TAddress, amount: bigint];
        };
    };
};
interface IERC777TxCaller {
    approve(sender: TSender, spender: TAddress, value: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    authorizeOperator(sender: TSender, operator: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    burn(sender: TSender, amount: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    operatorBurn(sender: TSender, account: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    operatorSend(sender: TSender, _sender: TAddress, recipient: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    revokeOperator(sender: TSender, operator: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    send(sender: TSender, recipient: TAddress, amount: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transfer(sender: TSender, recipient: TAddress, amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferFrom(sender: TSender, holder: TAddress, recipient: TAddress, amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IERC777TxData {
    approve(sender: TSender, spender: TAddress, value: bigint): Promise<TEth.TxLike>;
    authorizeOperator(sender: TSender, operator: TAddress): Promise<TEth.TxLike>;
    burn(sender: TSender, amount: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    operatorBurn(sender: TSender, account: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<TEth.TxLike>;
    operatorSend(sender: TSender, _sender: TAddress, recipient: TAddress, amount: bigint, data: TEth.Hex, operatorData: TEth.Hex): Promise<TEth.TxLike>;
    revokeOperator(sender: TSender, operator: TAddress): Promise<TEth.TxLike>;
    send(sender: TSender, recipient: TAddress, amount: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    transfer(sender: TSender, recipient: TAddress, amount: bigint): Promise<TEth.TxLike>;
    transferFrom(sender: TSender, holder: TAddress, recipient: TAddress, amount: bigint): Promise<TEth.TxLike>;
}
type TEvents = TERC777Types['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};