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 ERC1155PresetMinterPauser extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TERC1155PresetMinterPauserTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, uri: string): Promise<TxWriter>;
    DEFAULT_ADMIN_ROLE(): Promise<TEth.Hex>;
    MINTER_ROLE(): Promise<TEth.Hex>;
    PAUSER_ROLE(): Promise<TEth.Hex>;
    balanceOf(account: TAddress, id: bigint): Promise<bigint>;
    balanceOfBatch(accounts: TAddress[], ids: bigint[]): Promise<bigint[]>;
    burn(sender: TSender, account: TAddress, id: bigint, value: bigint): Promise<TxWriter>;
    burnBatch(sender: TSender, account: TAddress, ids: bigint[], values: bigint[]): Promise<TxWriter>;
    getRoleAdmin(role: TEth.Hex): Promise<TEth.Hex>;
    getRoleMember(role: TEth.Hex, index: bigint): Promise<TAddress>;
    getRoleMemberCount(role: TEth.Hex): Promise<bigint>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    hasRole(role: TEth.Hex, account: TAddress): Promise<boolean>;
    isApprovedForAll(account: TAddress, operator: TAddress): Promise<boolean>;
    mint(sender: TSender, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TxWriter>;
    mintBatch(sender: TSender, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TxWriter>;
    pause(sender: TSender): Promise<TxWriter>;
    paused(): Promise<boolean>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TxWriter>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TxWriter>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TxWriter>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TxWriter>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    unpause(sender: TSender): Promise<TxWriter>;
    uri(input0: bigint): Promise<string>;
    $call(): IERC1155PresetMinterPauserTxCaller;
    $signed(): TOverrideReturns<IERC1155PresetMinterPauserTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IERC1155PresetMinterPauserTxData;
    $gas(): TOverrideReturns<IERC1155PresetMinterPauserTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TERC1155PresetMinterPauserTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TERC1155PresetMinterPauserTypes['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>[]>;
    onApprovalForAll(fn?: (event: TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>>;
    onPaused(fn?: (event: TClientEventsStreamData<TEventArguments<'Paused'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Paused'>>>;
    onRoleAdminChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleAdminChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleAdminChanged'>>>;
    onRoleGranted(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleGranted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleGranted'>>>;
    onRoleRevoked(fn?: (event: TClientEventsStreamData<TEventArguments<'RoleRevoked'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RoleRevoked'>>>;
    onTransferBatch(fn?: (event: TClientEventsStreamData<TEventArguments<'TransferBatch'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'TransferBatch'>>>;
    onTransferSingle(fn?: (event: TClientEventsStreamData<TEventArguments<'TransferSingle'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'TransferSingle'>>>;
    onURI(fn?: (event: TClientEventsStreamData<TEventArguments<'URI'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'URI'>>>;
    onUnpaused(fn?: (event: TClientEventsStreamData<TEventArguments<'Unpaused'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Unpaused'>>>;
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsPaused(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Paused'>>[];
    extractLogsRoleAdminChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleAdminChanged'>>[];
    extractLogsRoleGranted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleGranted'>>[];
    extractLogsRoleRevoked(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RoleRevoked'>>[];
    extractLogsTransferBatch(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'TransferBatch'>>[];
    extractLogsTransferSingle(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'TransferSingle'>>[];
    extractLogsURI(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'URI'>>[];
    extractLogsUnpaused(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Unpaused'>>[];
    getPastLogsApprovalForAll(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsPaused(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Paused'>>[]>;
    getPastLogsRoleAdminChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            previousAdminRole?: TEth.Hex;
            newAdminRole?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleAdminChanged'>>[]>;
    getPastLogsRoleGranted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            account?: TAddress;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleGranted'>>[]>;
    getPastLogsRoleRevoked(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            role?: TEth.Hex;
            account?: TAddress;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'RoleRevoked'>>[]>;
    getPastLogsTransferBatch(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'TransferBatch'>>[]>;
    getPastLogsTransferSingle(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'TransferSingle'>>[]>;
    getPastLogsURI(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'URI'>>[]>;
    getPastLogsUnpaused(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Unpaused'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TERC1155PresetMinterPauserTypes = {
    Events: {
        ApprovalForAll: {
            outputParams: {
                account: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [account: TAddress, operator: TAddress, approved: boolean];
        };
        Paused: {
            outputParams: {
                account: TAddress;
            };
            outputArgs: [account: TAddress];
        };
        RoleAdminChanged: {
            outputParams: {
                role: TEth.Hex;
                previousAdminRole: TEth.Hex;
                newAdminRole: TEth.Hex;
            };
            outputArgs: [role: TEth.Hex, previousAdminRole: TEth.Hex, newAdminRole: TEth.Hex];
        };
        RoleGranted: {
            outputParams: {
                role: TEth.Hex;
                account: TAddress;
                _sender: TAddress;
            };
            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
        };
        RoleRevoked: {
            outputParams: {
                role: TEth.Hex;
                account: TAddress;
                _sender: TAddress;
            };
            outputArgs: [role: TEth.Hex, account: TAddress, _sender: TAddress];
        };
        TransferBatch: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                to: TAddress;
                ids: bigint[];
                values: bigint[];
            };
            outputArgs: [operator: TAddress, from: TAddress, to: TAddress, ids: bigint[], values: bigint[]];
        };
        TransferSingle: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                to: TAddress;
                id: bigint;
                value: bigint;
            };
            outputArgs: [operator: TAddress, from: TAddress, to: TAddress, id: bigint, value: bigint];
        };
        URI: {
            outputParams: {
                value: string;
                id: bigint;
            };
            outputArgs: [value: string, id: bigint];
        };
        Unpaused: {
            outputParams: {
                account: TAddress;
            };
            outputArgs: [account: TAddress];
        };
    };
    Methods: {
        DEFAULT_ADMIN_ROLE: {
            method: "DEFAULT_ADMIN_ROLE";
            arguments: [];
        };
        MINTER_ROLE: {
            method: "MINTER_ROLE";
            arguments: [];
        };
        PAUSER_ROLE: {
            method: "PAUSER_ROLE";
            arguments: [];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [account: TAddress, id: bigint];
        };
        balanceOfBatch: {
            method: "balanceOfBatch";
            arguments: [accounts: TAddress[], ids: bigint[]];
        };
        burn: {
            method: "burn";
            arguments: [account: TAddress, id: bigint, value: bigint];
        };
        burnBatch: {
            method: "burnBatch";
            arguments: [account: TAddress, ids: bigint[], values: bigint[]];
        };
        getRoleAdmin: {
            method: "getRoleAdmin";
            arguments: [role: TEth.Hex];
        };
        getRoleMember: {
            method: "getRoleMember";
            arguments: [role: TEth.Hex, index: bigint];
        };
        getRoleMemberCount: {
            method: "getRoleMemberCount";
            arguments: [role: TEth.Hex];
        };
        grantRole: {
            method: "grantRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        hasRole: {
            method: "hasRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [account: TAddress, operator: TAddress];
        };
        mint: {
            method: "mint";
            arguments: [to: TAddress, id: bigint, amount: bigint, data: TEth.Hex];
        };
        mintBatch: {
            method: "mintBatch";
            arguments: [to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex];
        };
        pause: {
            method: "pause";
            arguments: [];
        };
        paused: {
            method: "paused";
            arguments: [];
        };
        renounceRole: {
            method: "renounceRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        revokeRole: {
            method: "revokeRole";
            arguments: [role: TEth.Hex, account: TAddress];
        };
        safeBatchTransferFrom: {
            method: "safeBatchTransferFrom";
            arguments: [from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex];
        };
        safeTransferFrom: {
            method: "safeTransferFrom";
            arguments: [from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [operator: TAddress, approved: boolean];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex];
        };
        unpause: {
            method: "unpause";
            arguments: [];
        };
        uri: {
            method: "uri";
            arguments: [input0: bigint];
        };
    };
};
interface IERC1155PresetMinterPauserTxCaller {
    burn(sender: TSender, account: TAddress, id: bigint, value: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    burnBatch(sender: TSender, account: TAddress, ids: bigint[], values: bigint[]): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    mint(sender: TSender, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    mintBatch(sender: TSender, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    pause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: 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;
    }>;
    unpause(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IERC1155PresetMinterPauserTxData {
    burn(sender: TSender, account: TAddress, id: bigint, value: bigint): Promise<TEth.TxLike>;
    burnBatch(sender: TSender, account: TAddress, ids: bigint[], values: bigint[]): Promise<TEth.TxLike>;
    grantRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    mint(sender: TSender, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    mintBatch(sender: TSender, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TEth.TxLike>;
    pause(sender: TSender): Promise<TEth.TxLike>;
    renounceRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    revokeRole(sender: TSender, role: TEth.Hex, account: TAddress): Promise<TEth.TxLike>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TEth.TxLike>;
    unpause(sender: TSender): Promise<TEth.TxLike>;
}
type TEvents = TERC1155PresetMinterPauserTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};