import { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, PopulatedTransaction, Signer, utils, Event, EventFilter } from 'ethers';
import { FunctionFragment, Result, EventFragment } from '@ethersproject/abi';
import { Listener, Provider } from '@ethersproject/providers';
export declare type MeemPermissionStruct = {
    permission: PromiseOrValue<BigNumberish>;
    addresses: PromiseOrValue<string>[];
    numTokens: PromiseOrValue<BigNumberish>;
    costWei: PromiseOrValue<BigNumberish>;
    mintStartTimestamp: PromiseOrValue<BigNumberish>;
    mintEndTimestamp: PromiseOrValue<BigNumberish>;
    merkleRoot: PromiseOrValue<BytesLike>;
};
export declare type MeemPermissionStructOutput = [
    number,
    string[],
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    string
] & {
    permission: number;
    addresses: string[];
    numTokens: BigNumber;
    costWei: BigNumber;
    mintStartTimestamp: BigNumber;
    mintEndTimestamp: BigNumber;
    merkleRoot: string;
};
export declare type SplitStruct = {
    toAddress: PromiseOrValue<string>;
    amount: PromiseOrValue<BigNumberish>;
    lockedBy: PromiseOrValue<string>;
};
export declare type SplitStructOutput = [string, BigNumber, string] & {
    toAddress: string;
    amount: BigNumber;
    lockedBy: string;
};
export declare type ContractInfoStruct = {
    symbol: PromiseOrValue<string>;
    name: PromiseOrValue<string>;
    contractURI: PromiseOrValue<string>;
    maxSupply: PromiseOrValue<BigNumberish>;
    mintPermissions: MeemPermissionStruct[];
    splits: SplitStruct[];
    isTransferLocked: PromiseOrValue<boolean>;
};
export declare type ContractInfoStructOutput = [
    string,
    string,
    string,
    BigNumber,
    MeemPermissionStructOutput[],
    SplitStructOutput[],
    boolean
] & {
    symbol: string;
    name: string;
    contractURI: string;
    maxSupply: BigNumber;
    mintPermissions: MeemPermissionStructOutput[];
    splits: SplitStructOutput[];
    isTransferLocked: boolean;
};
export declare type SetRoleItemStruct = {
    user: PromiseOrValue<string>;
    role: PromiseOrValue<BytesLike>;
    hasRole: PromiseOrValue<boolean>;
};
export declare type SetRoleItemStructOutput = [string, string, boolean] & {
    user: string;
    role: string;
    hasRole: boolean;
};
export declare type InitParamsStruct = {
    symbol: PromiseOrValue<string>;
    name: PromiseOrValue<string>;
    contractURI: PromiseOrValue<string>;
    roles: SetRoleItemStruct[];
    maxSupply: PromiseOrValue<BigNumberish>;
    mintPermissions: MeemPermissionStruct[];
    splits: SplitStruct[];
    isTransferLocked: PromiseOrValue<boolean>;
};
export declare type InitParamsStructOutput = [
    string,
    string,
    string,
    SetRoleItemStructOutput[],
    BigNumber,
    MeemPermissionStructOutput[],
    SplitStructOutput[],
    boolean
] & {
    symbol: string;
    name: string;
    contractURI: string;
    roles: SetRoleItemStructOutput[];
    maxSupply: BigNumber;
    mintPermissions: MeemPermissionStructOutput[];
    splits: SplitStructOutput[];
    isTransferLocked: boolean;
};
export declare type MintParametersStruct = {
    to: PromiseOrValue<string>;
    tokenURI: PromiseOrValue<string>;
    tokenType: PromiseOrValue<BigNumberish>;
};
export declare type MintParametersStructOutput = [string, string, number] & {
    to: string;
    tokenURI: string;
    tokenType: number;
};
export declare type MeemStruct = {
    owner: PromiseOrValue<string>;
    tokenType: PromiseOrValue<BigNumberish>;
    mintedBy: PromiseOrValue<string>;
    mintedAt: PromiseOrValue<BigNumberish>;
};
export declare type MeemStructOutput = [string, number, string, BigNumber] & {
    owner: string;
    tokenType: number;
    mintedBy: string;
    mintedAt: BigNumber;
};
export declare type MintWithProofParametersStruct = {
    to: PromiseOrValue<string>;
    tokenURI: PromiseOrValue<string>;
    tokenType: PromiseOrValue<BigNumberish>;
    proof: PromiseOrValue<BytesLike>[];
};
export declare type MintWithProofParametersStructOutput = [
    string,
    string,
    number,
    string[]
] & {
    to: string;
    tokenURI: string;
    tokenType: number;
    proof: string[];
};
export declare type RequireCanMintParamsStruct = {
    minter: PromiseOrValue<string>;
    to: PromiseOrValue<string>;
    proof: PromiseOrValue<BytesLike>[];
};
export declare type RequireCanMintParamsStructOutput = [string, string, string[]] & {
    minter: string;
    to: string;
    proof: string[];
};
export declare type PartStruct = {
    account: PromiseOrValue<string>;
    value: PromiseOrValue<BigNumberish>;
};
export declare type PartStructOutput = [string, BigNumber] & {
    account: string;
    value: BigNumber;
};
export interface AgreementInterface extends utils.Interface {
    functions: {
        "contractURI()": FunctionFragment;
        "getContractInfo()": FunctionFragment;
        "initialize((string,string,string,(address,bytes32,bool)[],uint256,(uint8,address[],uint256,uint256,uint256,uint256,bytes32)[],(address,uint256,address)[],bool))": FunctionFragment;
        "reinitialize((string,string,string,(address,bytes32,bool)[],uint256,(uint8,address[],uint256,uint256,uint256,uint256,bytes32)[],(address,uint256,address)[],bool))": FunctionFragment;
        "setContractInfo(string,string)": FunctionFragment;
        "setContractInfo(string,string,string,uint256)": FunctionFragment;
        "setContractInfo(string,string,string)": FunctionFragment;
        "setContractURI(string)": FunctionFragment;
        "ADMIN_ROLE()": FunctionFragment;
        "UPGRADER_ROLE()": FunctionFragment;
        "adminContract()": FunctionFragment;
        "bulkSetRoles((address,bytes32,bool)[])": FunctionFragment;
        "canUpgradeContract(address)": FunctionFragment;
        "getRoles(bytes32)": FunctionFragment;
        "grantRole(bytes32,address)": FunctionFragment;
        "hasAssignedRole(bytes32,address)": FunctionFragment;
        "hasRole(bytes32,address)": FunctionFragment;
        "requireRole(bytes32,address)": FunctionFragment;
        "revokeRole(bytes32,address)": FunctionFragment;
        "setAdminContract(address)": FunctionFragment;
        "approve(address,uint256)": FunctionFragment;
        "balanceOf(address)": FunctionFragment;
        "bulkBurn(uint256[])": FunctionFragment;
        "bulkMint((address,string,uint8)[])": FunctionFragment;
        "burn(uint256)": FunctionFragment;
        "getApproved(uint256)": FunctionFragment;
        "getMeem(uint256)": FunctionFragment;
        "handleSaleDistribution(uint256,address)": FunctionFragment;
        "isApprovedForAll(address,address)": FunctionFragment;
        "mint((address,string,uint8))": FunctionFragment;
        "mintWithProof((address,string,uint8,bytes32[]))": FunctionFragment;
        "name()": FunctionFragment;
        "ownerOf(uint256)": FunctionFragment;
        "requireCanMint((address,address,bytes32[]))": FunctionFragment;
        "requireCanTransfer(address,address,address,uint256)": FunctionFragment;
        "requireTokenAdmin(uint256,address)": FunctionFragment;
        "safeTransferFrom(address,address,uint256)": FunctionFragment;
        "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment;
        "setApprovalForAll(address,bool)": FunctionFragment;
        "supportsInterface(bytes4)": FunctionFragment;
        "symbol()": FunctionFragment;
        "tokenByIndex(uint256)": FunctionFragment;
        "tokenOfOwnerByIndex(address,uint256)": FunctionFragment;
        "tokenURI(uint256)": FunctionFragment;
        "totalSupply()": FunctionFragment;
        "transferFrom(address,address,uint256)": FunctionFragment;
        "MINTER_ROLE()": FunctionFragment;
        "maxSupply()": FunctionFragment;
        "setIsTransferrable(bool)": FunctionFragment;
        "setMaxSupply(uint256)": FunctionFragment;
        "setMintingPermissions((uint8,address[],uint256,uint256,uint256,uint256,bytes32)[])": FunctionFragment;
        "validatePermissions((uint8,address[],uint256,uint256,uint256,uint256,bytes32)[],(uint8,address[],uint256,uint256,uint256,uint256,bytes32)[])": FunctionFragment;
        "getRaribleV2Royalties(uint256)": FunctionFragment;
        "lockSplits(uint256)": FunctionFragment;
        "setSplits(uint256,(address,uint256,address)[])": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "contractURI" | "getContractInfo" | "initialize" | "reinitialize" | "setContractInfo(string,string)" | "setContractInfo(string,string,string,uint256)" | "setContractInfo(string,string,string)" | "setContractURI" | "ADMIN_ROLE" | "UPGRADER_ROLE" | "adminContract" | "bulkSetRoles" | "canUpgradeContract" | "getRoles" | "grantRole" | "hasAssignedRole" | "hasRole" | "requireRole" | "revokeRole" | "setAdminContract" | "approve" | "balanceOf" | "bulkBurn" | "bulkMint" | "burn" | "getApproved" | "getMeem" | "handleSaleDistribution" | "isApprovedForAll" | "mint" | "mintWithProof" | "name" | "ownerOf" | "requireCanMint" | "requireCanTransfer" | "requireTokenAdmin" | "safeTransferFrom(address,address,uint256)" | "safeTransferFrom(address,address,uint256,bytes)" | "setApprovalForAll" | "supportsInterface" | "symbol" | "tokenByIndex" | "tokenOfOwnerByIndex" | "tokenURI" | "totalSupply" | "transferFrom" | "MINTER_ROLE" | "maxSupply" | "setIsTransferrable" | "setMaxSupply" | "setMintingPermissions" | "validatePermissions" | "getRaribleV2Royalties" | "lockSplits" | "setSplits"): FunctionFragment;
    encodeFunctionData(functionFragment: "contractURI", values?: undefined): string;
    encodeFunctionData(functionFragment: "getContractInfo", values?: undefined): string;
    encodeFunctionData(functionFragment: "initialize", values: [InitParamsStruct]): string;
    encodeFunctionData(functionFragment: "reinitialize", values: [InitParamsStruct]): string;
    encodeFunctionData(functionFragment: "setContractInfo(string,string)", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setContractInfo(string,string,string,uint256)", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "setContractInfo(string,string,string)", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "setContractURI", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "ADMIN_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "UPGRADER_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "adminContract", values?: undefined): string;
    encodeFunctionData(functionFragment: "bulkSetRoles", values: [SetRoleItemStruct[]]): string;
    encodeFunctionData(functionFragment: "canUpgradeContract", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getRoles", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "grantRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "hasAssignedRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "hasRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "requireRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "revokeRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "setAdminContract", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "approve", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "balanceOf", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "bulkBurn", values: [PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: "bulkMint", values: [MintParametersStruct[]]): string;
    encodeFunctionData(functionFragment: "burn", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "getApproved", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "getMeem", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "handleSaleDistribution", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isApprovedForAll", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "mint", values: [MintParametersStruct]): string;
    encodeFunctionData(functionFragment: "mintWithProof", values: [MintWithProofParametersStruct]): string;
    encodeFunctionData(functionFragment: "name", values?: undefined): string;
    encodeFunctionData(functionFragment: "ownerOf", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "requireCanMint", values: [RequireCanMintParamsStruct]): string;
    encodeFunctionData(functionFragment: "requireCanTransfer", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "requireTokenAdmin", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256)", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>
    ]): string;
    encodeFunctionData(functionFragment: "setApprovalForAll", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "symbol", values?: undefined): string;
    encodeFunctionData(functionFragment: "tokenByIndex", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "tokenOfOwnerByIndex", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "tokenURI", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "totalSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "transferFrom", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "MINTER_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "maxSupply", values?: undefined): string;
    encodeFunctionData(functionFragment: "setIsTransferrable", values: [PromiseOrValue<boolean>]): string;
    encodeFunctionData(functionFragment: "setMaxSupply", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setMintingPermissions", values: [MeemPermissionStruct[]]): string;
    encodeFunctionData(functionFragment: "validatePermissions", values: [MeemPermissionStruct[], MeemPermissionStruct[]]): string;
    encodeFunctionData(functionFragment: "getRaribleV2Royalties", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "lockSplits", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "setSplits", values: [PromiseOrValue<BigNumberish>, SplitStruct[]]): string;
    decodeFunctionResult(functionFragment: "contractURI", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getContractInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "reinitialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setContractInfo(string,string)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setContractInfo(string,string,string,uint256)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setContractInfo(string,string,string)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setContractURI", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ADMIN_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "UPGRADER_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "adminContract", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bulkSetRoles", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "canUpgradeContract", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRoles", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hasAssignedRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requireRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAdminContract", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bulkBurn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bulkMint", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getApproved", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getMeem", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "handleSaleDistribution", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "mintWithProof", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requireCanMint", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requireCanTransfer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requireTokenAdmin", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "safeTransferFrom(address,address,uint256,bytes)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokenByIndex", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokenOfOwnerByIndex", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "totalSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferFrom", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "MINTER_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setIsTransferrable", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMaxSupply", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setMintingPermissions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "validatePermissions", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRaribleV2Royalties", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "lockSplits", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setSplits", data: BytesLike): Result;
    events: {
        "MeemContractInfoSet(address)": EventFragment;
        "MeemContractInitialized(address)": EventFragment;
        "MeemContractURISet(address)": EventFragment;
        "MeemAdminContractSet(address)": EventFragment;
        "MeemRoleGranted(bytes32,address)": EventFragment;
        "MeemRoleRevoked(bytes32,address)": EventFragment;
        "Approval(address,address,uint256)": EventFragment;
        "ApprovalForAll(address,address,bool)": EventFragment;
        "MeemTransfer(address,address,uint256)": EventFragment;
        "Transfer(address,address,uint256)": EventFragment;
        "MeemMaxSupplyLocked()": EventFragment;
        "MeemMaxSupplySet(uint256)": EventFragment;
        "MeemMintPermissionsSet(tuple[])": EventFragment;
        "MeemSplitsSet(uint256,tuple[])": EventFragment;
        "RoyaltiesSet(uint256,tuple[])": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "MeemContractInfoSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemContractInitialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemContractURISet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemAdminContractSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemRoleGranted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemRoleRevoked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemTransfer"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemMaxSupplyLocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemMaxSupplySet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemMintPermissionsSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MeemSplitsSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RoyaltiesSet"): EventFragment;
}
export interface MeemContractInfoSetEventObject {
    contractAddress: string;
}
export declare type MeemContractInfoSetEvent = TypedEvent<[
    string
], MeemContractInfoSetEventObject>;
export declare type MeemContractInfoSetEventFilter = TypedEventFilter<MeemContractInfoSetEvent>;
export interface MeemContractInitializedEventObject {
    contractAddress: string;
}
export declare type MeemContractInitializedEvent = TypedEvent<[
    string
], MeemContractInitializedEventObject>;
export declare type MeemContractInitializedEventFilter = TypedEventFilter<MeemContractInitializedEvent>;
export interface MeemContractURISetEventObject {
    contractAddress: string;
}
export declare type MeemContractURISetEvent = TypedEvent<[
    string
], MeemContractURISetEventObject>;
export declare type MeemContractURISetEventFilter = TypedEventFilter<MeemContractURISetEvent>;
export interface MeemAdminContractSetEventObject {
    adminContract: string;
}
export declare type MeemAdminContractSetEvent = TypedEvent<[
    string
], MeemAdminContractSetEventObject>;
export declare type MeemAdminContractSetEventFilter = TypedEventFilter<MeemAdminContractSetEvent>;
export interface MeemRoleGrantedEventObject {
    role: string;
    user: string;
}
export declare type MeemRoleGrantedEvent = TypedEvent<[
    string,
    string
], MeemRoleGrantedEventObject>;
export declare type MeemRoleGrantedEventFilter = TypedEventFilter<MeemRoleGrantedEvent>;
export interface MeemRoleRevokedEventObject {
    role: string;
    user: string;
}
export declare type MeemRoleRevokedEvent = TypedEvent<[
    string,
    string
], MeemRoleRevokedEventObject>;
export declare type MeemRoleRevokedEventFilter = TypedEventFilter<MeemRoleRevokedEvent>;
export interface ApprovalEventObject {
    owner: string;
    operator: string;
    tokenId: BigNumber;
}
export declare type ApprovalEvent = TypedEvent<[
    string,
    string,
    BigNumber
], ApprovalEventObject>;
export declare type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;
export interface ApprovalForAllEventObject {
    owner: string;
    operator: string;
    approved: boolean;
}
export declare type ApprovalForAllEvent = TypedEvent<[
    string,
    string,
    boolean
], ApprovalForAllEventObject>;
export declare type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
export interface MeemTransferEventObject {
    from: string;
    to: string;
    tokenId: BigNumber;
}
export declare type MeemTransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], MeemTransferEventObject>;
export declare type MeemTransferEventFilter = TypedEventFilter<MeemTransferEvent>;
export interface TransferEventObject {
    from: string;
    to: string;
    tokenId: BigNumber;
}
export declare type TransferEvent = TypedEvent<[
    string,
    string,
    BigNumber
], TransferEventObject>;
export declare type TransferEventFilter = TypedEventFilter<TransferEvent>;
export interface MeemMaxSupplyLockedEventObject {
}
export declare type MeemMaxSupplyLockedEvent = TypedEvent<[
], MeemMaxSupplyLockedEventObject>;
export declare type MeemMaxSupplyLockedEventFilter = TypedEventFilter<MeemMaxSupplyLockedEvent>;
export interface MeemMaxSupplySetEventObject {
    maxSupply: BigNumber;
}
export declare type MeemMaxSupplySetEvent = TypedEvent<[
    BigNumber
], MeemMaxSupplySetEventObject>;
export declare type MeemMaxSupplySetEventFilter = TypedEventFilter<MeemMaxSupplySetEvent>;
export interface MeemMintPermissionsSetEventObject {
    mintPermissions: MeemPermissionStructOutput[];
}
export declare type MeemMintPermissionsSetEvent = TypedEvent<[
    MeemPermissionStructOutput[]
], MeemMintPermissionsSetEventObject>;
export declare type MeemMintPermissionsSetEventFilter = TypedEventFilter<MeemMintPermissionsSetEvent>;
export interface MeemSplitsSetEventObject {
    tokenId: BigNumber;
    splits: SplitStructOutput[];
}
export declare type MeemSplitsSetEvent = TypedEvent<[
    BigNumber,
    SplitStructOutput[]
], MeemSplitsSetEventObject>;
export declare type MeemSplitsSetEventFilter = TypedEventFilter<MeemSplitsSetEvent>;
export interface RoyaltiesSetEventObject {
    tokenId: BigNumber;
    royalties: PartStructOutput[];
}
export declare type RoyaltiesSetEvent = TypedEvent<[
    BigNumber,
    PartStructOutput[]
], RoyaltiesSetEventObject>;
export declare type RoyaltiesSetEventFilter = TypedEventFilter<RoyaltiesSetEvent>;
export interface Agreement extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: AgreementInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        contractURI(overrides?: CallOverrides): Promise<[string]>;
        getContractInfo(overrides?: CallOverrides): Promise<[ContractInfoStructOutput]>;
        initialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        reinitialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        "setContractInfo(string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        "setContractInfo(string,string,string,uint256)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, maxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        "setContractInfo(string,string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setContractURI(newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
        UPGRADER_ROLE(overrides?: CallOverrides): Promise<[string]>;
        adminContract(overrides?: CallOverrides): Promise<[string]>;
        bulkSetRoles(items: SetRoleItemStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        canUpgradeContract(upgrader: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        getRoles(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string[]]>;
        grantRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        hasAssignedRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        hasRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        requireRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[void]>;
        revokeRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAdminContract(newAdminContract: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        approve(operator: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        bulkBurn(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        bulkMint(bulkParams: MintParametersStruct[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        burn(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getApproved(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        getMeem(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[MeemStructOutput]>;
        handleSaleDistribution(tokenId: PromiseOrValue<BigNumberish>, msgSender: PromiseOrValue<string>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        mint(params: MintParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        mintWithProof(params: MintWithProofParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        name(overrides?: CallOverrides): Promise<[string]>;
        ownerOf(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        requireCanMint(params: RequireCanMintParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        requireCanTransfer(msgSender: PromiseOrValue<string>, from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        requireTokenAdmin(tokenId: PromiseOrValue<BigNumberish>, addy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[void]>;
        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setApprovalForAll(operator: PromiseOrValue<string>, status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
        symbol(overrides?: CallOverrides): Promise<[string]>;
        tokenByIndex(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        tokenOfOwnerByIndex(owner: PromiseOrValue<string>, index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        tokenURI(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;
        totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        MINTER_ROLE(overrides?: CallOverrides): Promise<[string]>;
        maxSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        setIsTransferrable(isTransferrable: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMaxSupply(newMaxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMintingPermissions(newPermissions: MeemPermissionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        validatePermissions(basePermissions: MeemPermissionStruct[], overridePermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<[void]>;
        getRaribleV2Royalties(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[PartStructOutput[]]>;
        lockSplits(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setSplits(tokenId: PromiseOrValue<BigNumberish>, splits: SplitStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    contractURI(overrides?: CallOverrides): Promise<string>;
    getContractInfo(overrides?: CallOverrides): Promise<ContractInfoStructOutput>;
    initialize(params: InitParamsStruct, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    reinitialize(params: InitParamsStruct, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    "setContractInfo(string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    "setContractInfo(string,string,string,uint256)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, maxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    "setContractInfo(string,string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setContractURI(newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
    UPGRADER_ROLE(overrides?: CallOverrides): Promise<string>;
    adminContract(overrides?: CallOverrides): Promise<string>;
    bulkSetRoles(items: SetRoleItemStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    canUpgradeContract(upgrader: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    getRoles(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string[]>;
    grantRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    hasAssignedRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    hasRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    requireRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    revokeRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAdminContract(newAdminContract: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    approve(operator: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    bulkBurn(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    bulkMint(bulkParams: MintParametersStruct[], overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    burn(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getApproved(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    getMeem(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<MeemStructOutput>;
    handleSaleDistribution(tokenId: PromiseOrValue<BigNumberish>, msgSender: PromiseOrValue<string>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    mint(params: MintParametersStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    mintWithProof(params: MintWithProofParametersStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    name(overrides?: CallOverrides): Promise<string>;
    ownerOf(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    requireCanMint(params: RequireCanMintParamsStruct, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    requireCanTransfer(msgSender: PromiseOrValue<string>, from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    requireTokenAdmin(tokenId: PromiseOrValue<BigNumberish>, addy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
    "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setApprovalForAll(operator: PromiseOrValue<string>, status: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
    symbol(overrides?: CallOverrides): Promise<string>;
    tokenByIndex(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    tokenOfOwnerByIndex(owner: PromiseOrValue<string>, index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    tokenURI(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
    totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    MINTER_ROLE(overrides?: CallOverrides): Promise<string>;
    maxSupply(overrides?: CallOverrides): Promise<BigNumber>;
    setIsTransferrable(isTransferrable: PromiseOrValue<boolean>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMaxSupply(newMaxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMintingPermissions(newPermissions: MeemPermissionStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    validatePermissions(basePermissions: MeemPermissionStruct[], overridePermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<void>;
    getRaribleV2Royalties(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PartStructOutput[]>;
    lockSplits(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setSplits(tokenId: PromiseOrValue<BigNumberish>, splits: SplitStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        contractURI(overrides?: CallOverrides): Promise<string>;
        getContractInfo(overrides?: CallOverrides): Promise<ContractInfoStructOutput>;
        initialize(params: InitParamsStruct, overrides?: CallOverrides): Promise<void>;
        reinitialize(params: InitParamsStruct, overrides?: CallOverrides): Promise<void>;
        "setContractInfo(string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        "setContractInfo(string,string,string,uint256)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, maxSupply: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        "setContractInfo(string,string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setContractURI(newContractURI: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
        UPGRADER_ROLE(overrides?: CallOverrides): Promise<string>;
        adminContract(overrides?: CallOverrides): Promise<string>;
        bulkSetRoles(items: SetRoleItemStruct[], overrides?: CallOverrides): Promise<void>;
        canUpgradeContract(upgrader: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        getRoles(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string[]>;
        grantRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        hasAssignedRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        hasRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        requireRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        revokeRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setAdminContract(newAdminContract: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        approve(operator: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        bulkBurn(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        bulkMint(bulkParams: MintParametersStruct[], overrides?: CallOverrides): Promise<void>;
        burn(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        getApproved(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        getMeem(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<MeemStructOutput>;
        handleSaleDistribution(tokenId: PromiseOrValue<BigNumberish>, msgSender: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        mint(params: MintParametersStruct, overrides?: CallOverrides): Promise<void>;
        mintWithProof(params: MintWithProofParametersStruct, overrides?: CallOverrides): Promise<void>;
        name(overrides?: CallOverrides): Promise<string>;
        ownerOf(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        requireCanMint(params: RequireCanMintParamsStruct, overrides?: CallOverrides): Promise<void>;
        requireCanTransfer(msgSender: PromiseOrValue<string>, from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        requireTokenAdmin(tokenId: PromiseOrValue<BigNumberish>, addy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        setApprovalForAll(operator: PromiseOrValue<string>, status: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
        symbol(overrides?: CallOverrides): Promise<string>;
        tokenByIndex(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        tokenOfOwnerByIndex(owner: PromiseOrValue<string>, index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        tokenURI(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        MINTER_ROLE(overrides?: CallOverrides): Promise<string>;
        maxSupply(overrides?: CallOverrides): Promise<BigNumber>;
        setIsTransferrable(isTransferrable: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
        setMaxSupply(newMaxSupply: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setMintingPermissions(newPermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<void>;
        validatePermissions(basePermissions: MeemPermissionStruct[], overridePermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<void>;
        getRaribleV2Royalties(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PartStructOutput[]>;
        lockSplits(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setSplits(tokenId: PromiseOrValue<BigNumberish>, splits: SplitStruct[], overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "MeemContractInfoSet(address)"(contractAddress?: PromiseOrValue<string> | null): MeemContractInfoSetEventFilter;
        MeemContractInfoSet(contractAddress?: PromiseOrValue<string> | null): MeemContractInfoSetEventFilter;
        "MeemContractInitialized(address)"(contractAddress?: PromiseOrValue<string> | null): MeemContractInitializedEventFilter;
        MeemContractInitialized(contractAddress?: PromiseOrValue<string> | null): MeemContractInitializedEventFilter;
        "MeemContractURISet(address)"(contractAddress?: PromiseOrValue<string> | null): MeemContractURISetEventFilter;
        MeemContractURISet(contractAddress?: PromiseOrValue<string> | null): MeemContractURISetEventFilter;
        "MeemAdminContractSet(address)"(adminContract?: PromiseOrValue<string> | null): MeemAdminContractSetEventFilter;
        MeemAdminContractSet(adminContract?: PromiseOrValue<string> | null): MeemAdminContractSetEventFilter;
        "MeemRoleGranted(bytes32,address)"(role?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): MeemRoleGrantedEventFilter;
        MeemRoleGranted(role?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): MeemRoleGrantedEventFilter;
        "MeemRoleRevoked(bytes32,address)"(role?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): MeemRoleRevokedEventFilter;
        MeemRoleRevoked(role?: PromiseOrValue<BytesLike> | null, user?: PromiseOrValue<string> | null): MeemRoleRevokedEventFilter;
        "Approval(address,address,uint256)"(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): ApprovalEventFilter;
        Approval(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): ApprovalEventFilter;
        "ApprovalForAll(address,address,bool)"(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, approved?: null): ApprovalForAllEventFilter;
        ApprovalForAll(owner?: PromiseOrValue<string> | null, operator?: PromiseOrValue<string> | null, approved?: null): ApprovalForAllEventFilter;
        "MeemTransfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): MeemTransferEventFilter;
        MeemTransfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): MeemTransferEventFilter;
        "Transfer(address,address,uint256)"(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): TransferEventFilter;
        Transfer(from?: PromiseOrValue<string> | null, to?: PromiseOrValue<string> | null, tokenId?: PromiseOrValue<BigNumberish> | null): TransferEventFilter;
        "MeemMaxSupplyLocked()"(): MeemMaxSupplyLockedEventFilter;
        MeemMaxSupplyLocked(): MeemMaxSupplyLockedEventFilter;
        "MeemMaxSupplySet(uint256)"(maxSupply?: null): MeemMaxSupplySetEventFilter;
        MeemMaxSupplySet(maxSupply?: null): MeemMaxSupplySetEventFilter;
        "MeemMintPermissionsSet(tuple[])"(mintPermissions?: null): MeemMintPermissionsSetEventFilter;
        MeemMintPermissionsSet(mintPermissions?: null): MeemMintPermissionsSetEventFilter;
        "MeemSplitsSet(uint256,tuple[])"(tokenId?: null, splits?: null): MeemSplitsSetEventFilter;
        MeemSplitsSet(tokenId?: null, splits?: null): MeemSplitsSetEventFilter;
        "RoyaltiesSet(uint256,tuple[])"(tokenId?: null, royalties?: null): RoyaltiesSetEventFilter;
        RoyaltiesSet(tokenId?: null, royalties?: null): RoyaltiesSetEventFilter;
    };
    estimateGas: {
        contractURI(overrides?: CallOverrides): Promise<BigNumber>;
        getContractInfo(overrides?: CallOverrides): Promise<BigNumber>;
        initialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        reinitialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        "setContractInfo(string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        "setContractInfo(string,string,string,uint256)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, maxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        "setContractInfo(string,string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setContractURI(newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
        UPGRADER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
        adminContract(overrides?: CallOverrides): Promise<BigNumber>;
        bulkSetRoles(items: SetRoleItemStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        canUpgradeContract(upgrader: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getRoles(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        grantRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        hasAssignedRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        hasRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        requireRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        revokeRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAdminContract(newAdminContract: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        approve(operator: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        bulkBurn(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        bulkMint(bulkParams: MintParametersStruct[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        burn(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getApproved(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        getMeem(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        handleSaleDistribution(tokenId: PromiseOrValue<BigNumberish>, msgSender: PromiseOrValue<string>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        mint(params: MintParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        mintWithProof(params: MintWithProofParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<BigNumber>;
        ownerOf(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        requireCanMint(params: RequireCanMintParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        requireCanTransfer(msgSender: PromiseOrValue<string>, from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        requireTokenAdmin(tokenId: PromiseOrValue<BigNumberish>, addy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setApprovalForAll(operator: PromiseOrValue<string>, status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<BigNumber>;
        symbol(overrides?: CallOverrides): Promise<BigNumber>;
        tokenByIndex(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        tokenOfOwnerByIndex(owner: PromiseOrValue<string>, index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        tokenURI(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        totalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        MINTER_ROLE(overrides?: CallOverrides): Promise<BigNumber>;
        maxSupply(overrides?: CallOverrides): Promise<BigNumber>;
        setIsTransferrable(isTransferrable: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMaxSupply(newMaxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMintingPermissions(newPermissions: MeemPermissionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        validatePermissions(basePermissions: MeemPermissionStruct[], overridePermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<BigNumber>;
        getRaribleV2Royalties(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        lockSplits(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setSplits(tokenId: PromiseOrValue<BigNumberish>, splits: SplitStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        contractURI(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getContractInfo(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        initialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        reinitialize(params: InitParamsStruct, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        "setContractInfo(string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        "setContractInfo(string,string,string,uint256)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, maxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        "setContractInfo(string,string,string)"(name: PromiseOrValue<string>, symbol: PromiseOrValue<string>, newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setContractURI(newContractURI: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        ADMIN_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        UPGRADER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        adminContract(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bulkSetRoles(items: SetRoleItemStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        canUpgradeContract(upgrader: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRoles(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        grantRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        hasAssignedRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        hasRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        requireRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revokeRole(role: PromiseOrValue<BytesLike>, user: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setAdminContract(newAdminContract: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        approve(operator: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        balanceOf(account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bulkBurn(tokenIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        bulkMint(bulkParams: MintParametersStruct[], overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        burn(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getApproved(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getMeem(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        handleSaleDistribution(tokenId: PromiseOrValue<BigNumberish>, msgSender: PromiseOrValue<string>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        isApprovedForAll(account: PromiseOrValue<string>, operator: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        mint(params: MintParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        mintWithProof(params: MintWithProofParametersStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ownerOf(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        requireCanMint(params: RequireCanMintParamsStruct, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        requireCanTransfer(msgSender: PromiseOrValue<string>, from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        requireTokenAdmin(tokenId: PromiseOrValue<BigNumberish>, addy: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        "safeTransferFrom(address,address,uint256)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        "safeTransferFrom(address,address,uint256,bytes)"(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, data: PromiseOrValue<BytesLike>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setApprovalForAll(operator: PromiseOrValue<string>, status: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        symbol(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        tokenByIndex(index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        tokenOfOwnerByIndex(owner: PromiseOrValue<string>, index: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        tokenURI(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferFrom(from: PromiseOrValue<string>, to: PromiseOrValue<string>, tokenId: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        MINTER_ROLE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        setIsTransferrable(isTransferrable: PromiseOrValue<boolean>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMaxSupply(newMaxSupply: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMintingPermissions(newPermissions: MeemPermissionStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        validatePermissions(basePermissions: MeemPermissionStruct[], overridePermissions: MeemPermissionStruct[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRaribleV2Royalties(tokenId: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        lockSplits(tokenId: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setSplits(tokenId: PromiseOrValue<BigNumberish>, splits: SplitStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
    };
}
export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
    args: TArgsArray & TArgsObject;
}
export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {
}
export interface TypedListener<TEvent extends TypedEvent> {
    (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
}
declare type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
export interface OnEvent<TRes> {
    <TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>, listener: TypedListener<TEvent>): TRes;
    (eventName: string, listener: Listener): TRes;
}
export declare type MinEthersFactory<C, ARGS> = {
    deploy(...a: ARGS[]): Promise<C>;
};
export declare type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
export declare type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
export declare type PromiseOrValue<T> = T | Promise<T>;
export declare class Agreement__factory {
    static readonly abi: ({
        name: string;
        type: string;
        inputs: never[];
        outputs: {
            name: string;
            type: string;
            components: ({
                name: string;
                type: string;
                internalType: string;
                components?: undefined;
            } | {
                name: string;
                type: string;
                components: {
                    name: string;
                    type: string;
                    internalType: string;
                }[];
                internalType: string;
            })[];
            internalType: string;
        }[];
        stateMutability: string;
        anonymous?: undefined;
    } | {
        name: string;
        type: string;
        inputs: {
            name: string;
            type: string;
            components: ({
                name: string;
                type: string;
                internalType: string;
                components?: undefined;
            } | {
                name: string;
                type: string;
                components: {
                    name: string;
                    type: string;
                    internalType: string;
                }[];
                internalType: string;
            })[];
            internalType: string;
        }[];
        outputs: never[];
        stateMutability: string;
        anonymous?: undefined;
    } | {
        name: string;
        type: string;
        inputs: {
            name: string;
            type: string;
            internalType: string;
        }[];
        outputs: {
            name: string;
            type: string;
            internalType: string;
        }[];
        stateMutability: string;
        anonymous?: undefined;
    } | {
        name: string;
        type: string;
        inputs: {
            name: string;
            type: string;
            internalType: string;
        }[];
        outputs: {
            name: string;
            type: string;
            components: {
                name: string;
                type: string;
                internalType: string;
            }[];
            internalType: string;
        }[];
        stateMutability: string;
        anonymous?: undefined;
    } | {
        name: string;
        type: string;
        inputs: ({
            name: string;
            type: string;
            indexed: boolean;
            internalType: string;
            components?: undefined;
        } | {
            name: string;
            type: string;
            indexed: boolean;
            components: {
                name: string;
                type: string;
                internalType: string;
            }[];
            internalType: string;
        })[];
        anonymous: boolean;
        outputs?: undefined;
        stateMutability?: undefined;
    } | {
        name: string;
        type: string;
        inputs: ({
            name: string;
            type: string;
            internalType: string;
            components?: undefined;
        } | {
            name: string;
            type: string;
            components: {
                name: string;
                type: string;
                internalType: string;
            }[];
            internalType: string;
        })[];
        outputs: never[];
        stateMutability: string;
        anonymous?: undefined;
    })[];
    static createInterface(): AgreementInterface;
    static connect(address: string, signerOrProvider: Signer | Provider): Agreement;
}
export {};