/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  CallOverrides,
} from "ethers";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
import type { TypedEventFilter, TypedEvent, TypedListener } from "./common";

interface ClusterAreaInterface extends ethers.utils.Interface {
  functions: {
    "DEFAULT_ADMIN_ROLE()": FunctionFragment;
    "addRule(uint32,(tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "clusterAttributeArea()": FunctionFragment;
    "clusterAttributeAreaToken()": FunctionFragment;
    "clusterDescription(uint32)": FunctionFragment;
    "clusterMountingArea()": FunctionFragment;
    "clusterRegBlockNumber(uint32)": FunctionFragment;
    "clusterRegTimestamp(uint32)": FunctionFragment;
    "clusterRuleArea()": FunctionFragment;
    "clusterRuleAreaHandler()": FunctionFragment;
    "clusterRuleDelayBlockNumber(uint32)": FunctionFragment;
    "clusterRuleDelayTimestamp(uint32)": FunctionFragment;
    "clusterState(uint32)": FunctionFragment;
    "cname()": FunctionFragment;
    "engine()": FunctionFragment;
    "getAdminList(uint32)": FunctionFragment;
    "getClusterAttributeArea()": FunctionFragment;
    "getClusterAttributeAreaToken()": FunctionFragment;
    "getClusterMountingArea()": FunctionFragment;
    "getClusterRoleHash(uint32,uint8)": FunctionFragment;
    "getClusterRuleArea()": FunctionFragment;
    "getClusterRuleAreaHandler()": FunctionFragment;
    "getClusterState(uint32)": FunctionFragment;
    "getCurrentClusterId()": FunctionFragment;
    "getDelayBlockNumber(uint32)": FunctionFragment;
    "getDelayTimestamp(uint32)": FunctionFragment;
    "getDeployerList(uint32)": FunctionFragment;
    "getDescription(uint32)": FunctionFragment;
    "getEngine()": FunctionFragment;
    "getPostGroupSlotForEngine(uint32,uint16,uint16)": FunctionFragment;
    "getPreGroupSlotForEngine(uint32,uint16,uint16,uint8)": FunctionFragment;
    "getProcessGroupSlotForEngine(uint32,uint16,uint16)": FunctionFragment;
    "getRoleAdmin(bytes32)": FunctionFragment;
    "getRoleMember(bytes32,uint256)": FunctionFragment;
    "getRoleMemberCount(bytes32)": FunctionFragment;
    "grantRole(bytes32,address)": FunctionFragment;
    "hasRole(bytes32,address)": FunctionFragment;
    "haveRole(uint32,uint8,address)": FunctionFragment;
    "initialize(address,address,address,address,address,address,address,address)": FunctionFragment;
    "owner()": FunctionFragment;
    "pause(uint8,bool)": FunctionFragment;
    "paused(uint8)": FunctionFragment;
    "poolContract()": FunctionFragment;
    "poolFee()": FunctionFragment;
    "regCluster((tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "regRule((tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "renounceRole(bytes32,address)": FunctionFragment;
    "revokeRole(uint32,uint8,address)": FunctionFragment;
    "setClusterAttributeArea(address)": FunctionFragment;
    "setClusterRuleArea(address)": FunctionFragment;
    "setClusterRuleAreaHandler(address)": FunctionFragment;
    "setClusterState(uint32,uint8)": FunctionFragment;
    "setEngine(address)": FunctionFragment;
    "setPoolContract(address)": FunctionFragment;
    "setPoolFee(address)": FunctionFragment;
    "supportsInterface(bytes4)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateGroupSlotTokenHandler(uint32,uint16,uint8,uint8,(uint256,uint256,uint256))": FunctionFragment;
    "version()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "addRule",
    values: [
      BigNumberish,
      {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterAttributeArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "clusterAttributeAreaToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "clusterDescription",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterMountingArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRegBlockNumber",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRegTimestamp",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRuleArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRuleAreaHandler",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRuleDelayBlockNumber",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterRuleDelayTimestamp",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "clusterState",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "cname", values?: undefined): string;
  encodeFunctionData(functionFragment: "engine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getAdminList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterAttributeArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterAttributeAreaToken",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterMountingArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterRoleHash",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterRuleArea",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterRuleAreaHandler",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getClusterState",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getCurrentClusterId",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getDelayBlockNumber",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDelayTimestamp",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDeployerList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getDescription",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "getEngine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getPostGroupSlotForEngine",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPreGroupSlotForEngine",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProcessGroupSlotForEngine",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleAdmin",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleMember",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRoleMemberCount",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "grantRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "hasRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "haveRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, string, string, string, string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "pause",
    values: [BigNumberish, boolean]
  ): string;
  encodeFunctionData(
    functionFragment: "paused",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "poolContract",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "poolFee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "regCluster",
    values: [
      {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "regRule",
    values: [
      {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "renounceRole",
    values: [BytesLike, string]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterAttributeArea",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterRuleArea",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterRuleAreaHandler",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterState",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "setEngine", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setPoolContract",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "setPoolFee", values: [string]): string;
  encodeFunctionData(
    functionFragment: "supportsInterface",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateGroupSlotTokenHandler",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      { id: BigNumberish; amount: BigNumberish; idIndex: BigNumberish }
    ]
  ): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "DEFAULT_ADMIN_ROLE",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "addRule", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "clusterAttributeArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterAttributeAreaToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterDescription",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterMountingArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRegBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRegTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRuleArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRuleAreaHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRuleDelayBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterRuleDelayTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "clusterState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cname", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "engine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getAdminList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterAttributeArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterAttributeAreaToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterMountingArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterRoleHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterRuleArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterRuleAreaHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getClusterState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getCurrentClusterId",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelayBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDelayTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDeployerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDescription",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getEngine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getPostGroupSlotForEngine",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPreGroupSlotForEngine",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProcessGroupSlotForEngine",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleAdmin",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleMember",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRoleMemberCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "haveRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "poolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "poolFee", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "regCluster", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "regRule", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setClusterAttributeArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setClusterRuleArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setClusterRuleAreaHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setClusterState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setEngine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setPoolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setPoolFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "supportsInterface",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateGroupSlotTokenHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;

  events: {
    "EventCluster(address,uint8,uint32,uint8,uint8)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
    "Paused(uint8,address)": EventFragment;
    "Receive(address,uint256)": EventFragment;
    "RoleAdminChanged(bytes32,bytes32,bytes32)": EventFragment;
    "RoleGranted(bytes32,address,address)": EventFragment;
    "RoleRevoked(bytes32,address,address)": EventFragment;
    "Unpaused(uint8,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "EventCluster"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Receive"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleAdminChanged"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleGranted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RoleRevoked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
}

export type EventClusterEvent = TypedEvent<
  [string, number, number, number, number] & {
    caller: string;
    regType: number;
    clusterId: number;
    ruleSlotIndex1: number;
    ruleSlotIndex2: number;
  }
>;

export type InitializedEvent = TypedEvent<[number] & { version: number }>;

export type OwnershipTransferredEvent = TypedEvent<
  [string, string] & { previousOwner: string; newOwner: string }
>;

export type PausedEvent = TypedEvent<
  [number, string] & { channel: number; account: string }
>;

export type ReceiveEvent = TypedEvent<
  [string, BigNumber] & { from: string; value: BigNumber }
>;

export type RoleAdminChangedEvent = TypedEvent<
  [string, string, string] & {
    role: string;
    previousAdminRole: string;
    newAdminRole: string;
  }
>;

export type RoleGrantedEvent = TypedEvent<
  [string, string, string] & { role: string; account: string; sender: string }
>;

export type RoleRevokedEvent = TypedEvent<
  [string, string, string] & { role: string; account: string; sender: string }
>;

export type UnpausedEvent = TypedEvent<
  [number, string] & { channel: number; account: string }
>;

export class ClusterArea extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  listeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter?: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): Array<TypedListener<EventArgsArray, EventArgsObject>>;
  off<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  on<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  once<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeListener<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>,
    listener: TypedListener<EventArgsArray, EventArgsObject>
  ): this;
  removeAllListeners<EventArgsArray extends Array<any>, EventArgsObject>(
    eventFilter: TypedEventFilter<EventArgsArray, EventArgsObject>
  ): this;

  listeners(eventName?: string): Array<Listener>;
  off(eventName: string, listener: Listener): this;
  on(eventName: string, listener: Listener): this;
  once(eventName: string, listener: Listener): this;
  removeListener(eventName: string, listener: Listener): this;
  removeAllListeners(eventName?: string): this;

  queryFilter<EventArgsArray extends Array<any>, EventArgsObject>(
    event: TypedEventFilter<EventArgsArray, EventArgsObject>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TypedEvent<EventArgsArray & EventArgsObject>>>;

  interface: ClusterAreaInterface;

  functions: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;

    addRule(
      clusterId: BigNumberish,
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    clusterAttributeArea(overrides?: CallOverrides): Promise<[string]>;

    clusterAttributeAreaToken(overrides?: CallOverrides): Promise<[string]>;

    clusterDescription(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    clusterMountingArea(overrides?: CallOverrides): Promise<[string]>;

    clusterRegBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    clusterRegTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    clusterRuleArea(overrides?: CallOverrides): Promise<[string]>;

    clusterRuleAreaHandler(overrides?: CallOverrides): Promise<[string]>;

    clusterRuleDelayBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    clusterRuleDelayTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    clusterState(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    cname(overrides?: CallOverrides): Promise<[string]>;

    engine(overrides?: CallOverrides): Promise<[string]>;

    getAdminList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    getClusterAttributeArea(overrides?: CallOverrides): Promise<[string]>;

    getClusterAttributeAreaToken(overrides?: CallOverrides): Promise<[string]>;

    getClusterMountingArea(overrides?: CallOverrides): Promise<[string]>;

    getClusterRoleHash(
      clusterId: BigNumberish,
      role: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getClusterRuleArea(overrides?: CallOverrides): Promise<[string]>;

    getClusterRuleAreaHandler(overrides?: CallOverrides): Promise<[string]>;

    getClusterState(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getCurrentClusterId(overrides?: CallOverrides): Promise<[BigNumber]>;

    getDelayBlockNumber(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getDelayTimestamp(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[number]>;

    getDeployerList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    getDescription(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getEngine(overrides?: CallOverrides): Promise<[string]>;

    getPostGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getPreGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      branch: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getProcessGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<[string]>;

    getRoleMember(
      role: BytesLike,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string]>;

    getRoleMemberCount(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "grantRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    haveRole(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    initialize(
      poolContract_: string,
      engine_: string,
      poolFee_: string,
      clusterRuleArea_: string,
      clusterRuleAreaHandler_: string,
      clusterAttributeArea_: string,
      clusterAttributeAreaToken_: string,
      clusterMountingArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    owner(overrides?: CallOverrides): Promise<[string]>;

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    paused(
      channel: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    poolContract(overrides?: CallOverrides): Promise<[string]>;

    poolFee(overrides?: CallOverrides): Promise<[string]>;

    regCluster(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    regRule(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    renounceOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "renounceRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "revokeRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setClusterAttributeArea(
      clusterAttributeArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setClusterRuleArea(
      clusterRuleArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setClusterRuleAreaHandler(
      clusterRuleAreaHandler_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setEngine(
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPoolContract(
      poolContract_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    setPoolFee(
      poolFee_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateGroupSlotTokenHandler(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      tokenSlotIndex: BigNumberish,
      tokenHandler: {
        id: BigNumberish;
        amount: BigNumberish;
        idIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    version(overrides?: CallOverrides): Promise<[BigNumber]>;
  };

  DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

  addRule(
    clusterId: BigNumberish,
    cluster: {
      groupSlotList: {
        tokenSlotList: {
          tokenTemplate: {
            erc: BigNumberish;
            token: string;
            valueList: BigNumberish[];
          };
          rule: BigNumberish;
          ioAddressList: string[];
          valueList: BigNumberish[];
        }[];
        branch: BigNumberish;
        poolToken: string;
        handlerList: string[];
        argsList: BytesLike[];
      }[];
      ruleSlotBound: BigNumberish[];
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[];
      attrList: {
        attrId: BigNumberish;
        name: string;
        symbol: string;
        uri: string;
        level: BigNumberish;
      }[];
      attrStateList: BigNumberish[];
      deployerList: string[];
      adminList: string[];
      delayTimestamp: BigNumberish;
      delayBlockNumber: BigNumberish;
      state: BigNumberish;
      description: string;
    },
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  clusterAttributeArea(overrides?: CallOverrides): Promise<string>;

  clusterAttributeAreaToken(overrides?: CallOverrides): Promise<string>;

  clusterDescription(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  clusterMountingArea(overrides?: CallOverrides): Promise<string>;

  clusterRegBlockNumber(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  clusterRegTimestamp(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  clusterRuleArea(overrides?: CallOverrides): Promise<string>;

  clusterRuleAreaHandler(overrides?: CallOverrides): Promise<string>;

  clusterRuleDelayBlockNumber(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  clusterRuleDelayTimestamp(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  clusterState(arg0: BigNumberish, overrides?: CallOverrides): Promise<number>;

  cname(overrides?: CallOverrides): Promise<string>;

  engine(overrides?: CallOverrides): Promise<string>;

  getAdminList(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

  getClusterAttributeArea(overrides?: CallOverrides): Promise<string>;

  getClusterAttributeAreaToken(overrides?: CallOverrides): Promise<string>;

  getClusterMountingArea(overrides?: CallOverrides): Promise<string>;

  getClusterRoleHash(
    clusterId: BigNumberish,
    role: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getClusterRuleArea(overrides?: CallOverrides): Promise<string>;

  getClusterRuleAreaHandler(overrides?: CallOverrides): Promise<string>;

  getClusterState(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getCurrentClusterId(overrides?: CallOverrides): Promise<BigNumber>;

  getDelayBlockNumber(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getDelayTimestamp(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getDeployerList(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

  getDescription(
    clusterId: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getEngine(overrides?: CallOverrides): Promise<string>;

  getPostGroupSlotForEngine(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getPreGroupSlotForEngine(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    branch: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getProcessGroupSlotForEngine(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

  getRoleMember(
    role: BytesLike,
    index: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  getRoleMemberCount(
    role: BytesLike,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "grantRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "grantRole(uint32,uint8,address)"(
    clusterId: BigNumberish,
    role: BigNumberish,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  hasRole(
    role: BytesLike,
    account: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  haveRole(
    clusterId: BigNumberish,
    role: BigNumberish,
    account: string,
    overrides?: CallOverrides
  ): Promise<boolean>;

  initialize(
    poolContract_: string,
    engine_: string,
    poolFee_: string,
    clusterRuleArea_: string,
    clusterRuleAreaHandler_: string,
    clusterAttributeArea_: string,
    clusterAttributeAreaToken_: string,
    clusterMountingArea_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  owner(overrides?: CallOverrides): Promise<string>;

  pause(
    channel: BigNumberish,
    _paused: boolean,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  paused(channel: BigNumberish, overrides?: CallOverrides): Promise<boolean>;

  poolContract(overrides?: CallOverrides): Promise<string>;

  poolFee(overrides?: CallOverrides): Promise<string>;

  regCluster(
    cluster: {
      groupSlotList: {
        tokenSlotList: {
          tokenTemplate: {
            erc: BigNumberish;
            token: string;
            valueList: BigNumberish[];
          };
          rule: BigNumberish;
          ioAddressList: string[];
          valueList: BigNumberish[];
        }[];
        branch: BigNumberish;
        poolToken: string;
        handlerList: string[];
        argsList: BytesLike[];
      }[];
      ruleSlotBound: BigNumberish[];
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[];
      attrList: {
        attrId: BigNumberish;
        name: string;
        symbol: string;
        uri: string;
        level: BigNumberish;
      }[];
      attrStateList: BigNumberish[];
      deployerList: string[];
      adminList: string[];
      delayTimestamp: BigNumberish;
      delayBlockNumber: BigNumberish;
      state: BigNumberish;
      description: string;
    },
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  regRule(
    cluster: {
      groupSlotList: {
        tokenSlotList: {
          tokenTemplate: {
            erc: BigNumberish;
            token: string;
            valueList: BigNumberish[];
          };
          rule: BigNumberish;
          ioAddressList: string[];
          valueList: BigNumberish[];
        }[];
        branch: BigNumberish;
        poolToken: string;
        handlerList: string[];
        argsList: BytesLike[];
      }[];
      ruleSlotBound: BigNumberish[];
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[];
      attrList: {
        attrId: BigNumberish;
        name: string;
        symbol: string;
        uri: string;
        level: BigNumberish;
      }[];
      attrStateList: BigNumberish[];
      deployerList: string[];
      adminList: string[];
      delayTimestamp: BigNumberish;
      delayBlockNumber: BigNumberish;
      state: BigNumberish;
      description: string;
    },
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  renounceOwnership(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "renounceRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "renounceRole(uint32,uint8,address)"(
    clusterId: BigNumberish,
    role: BigNumberish,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "revokeRole(uint32,uint8,address)"(
    clusterId: BigNumberish,
    role: BigNumberish,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  "revokeRole(bytes32,address)"(
    role: BytesLike,
    account: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setClusterAttributeArea(
    clusterAttributeArea_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setClusterRuleArea(
    clusterRuleArea_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setClusterRuleAreaHandler(
    clusterRuleAreaHandler_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setClusterState(
    clusterId: BigNumberish,
    state: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setEngine(
    engine_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPoolContract(
    poolContract_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  setPoolFee(
    poolFee_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  supportsInterface(
    interfaceId: BytesLike,
    overrides?: CallOverrides
  ): Promise<boolean>;

  transferOwnership(
    newOwner: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateGroupSlotTokenHandler(
    clusterId: BigNumberish,
    ruleSlotIndex: BigNumberish,
    branch: BigNumberish,
    tokenSlotIndex: BigNumberish,
    tokenHandler: {
      id: BigNumberish;
      amount: BigNumberish;
      idIndex: BigNumberish;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  version(overrides?: CallOverrides): Promise<BigNumber>;

  callStatic: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;

    addRule(
      clusterId: BigNumberish,
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    clusterAttributeArea(overrides?: CallOverrides): Promise<string>;

    clusterAttributeAreaToken(overrides?: CallOverrides): Promise<string>;

    clusterDescription(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    clusterMountingArea(overrides?: CallOverrides): Promise<string>;

    clusterRegBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    clusterRegTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    clusterRuleArea(overrides?: CallOverrides): Promise<string>;

    clusterRuleAreaHandler(overrides?: CallOverrides): Promise<string>;

    clusterRuleDelayBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    clusterRuleDelayTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    clusterState(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    cname(overrides?: CallOverrides): Promise<string>;

    engine(overrides?: CallOverrides): Promise<string>;

    getAdminList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

    getClusterAttributeArea(overrides?: CallOverrides): Promise<string>;

    getClusterAttributeAreaToken(overrides?: CallOverrides): Promise<string>;

    getClusterMountingArea(overrides?: CallOverrides): Promise<string>;

    getClusterRoleHash(
      clusterId: BigNumberish,
      role: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getClusterRuleArea(overrides?: CallOverrides): Promise<string>;

    getClusterRuleAreaHandler(overrides?: CallOverrides): Promise<string>;

    getClusterState(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getCurrentClusterId(overrides?: CallOverrides): Promise<BigNumber>;

    getDelayBlockNumber(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getDelayTimestamp(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getDeployerList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

    getDescription(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getEngine(overrides?: CallOverrides): Promise<string>;

    getPostGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]] & { postHandlerList: string[] }>;

    getPreGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      branch: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [
        boolean,
        [
          ([
            [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            },
            number,
            string[],
            BigNumber[]
          ] & {
            tokenTemplate: [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            };
            rule: number;
            ioAddressList: string[];
            valueList: BigNumber[];
          })[],
          number,
          string,
          string[],
          string[]
        ] & {
          tokenSlotList: ([
            [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            },
            number,
            string[],
            BigNumber[]
          ] & {
            tokenTemplate: [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            };
            rule: number;
            ioAddressList: string[];
            valueList: BigNumber[];
          })[];
          branch: number;
          poolToken: string;
          handlerList: string[];
          argsList: string[];
        },
        string,
        string[],
        number,
        number,
        number,
        number,
        number
      ] & {
        foundGroupSlot: boolean;
        groupSlot: [
          ([
            [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            },
            number,
            string[],
            BigNumber[]
          ] & {
            tokenTemplate: [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            };
            rule: number;
            ioAddressList: string[];
            valueList: BigNumber[];
          })[],
          number,
          string,
          string[],
          string[]
        ] & {
          tokenSlotList: ([
            [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            },
            number,
            string[],
            BigNumber[]
          ] & {
            tokenTemplate: [number, string, BigNumber[]] & {
              erc: number;
              token: string;
              valueList: BigNumber[];
            };
            rule: number;
            ioAddressList: string[];
            valueList: BigNumber[];
          })[];
          branch: number;
          poolToken: string;
          handlerList: string[];
          argsList: string[];
        };
        snippet: string;
        preHandlerList: string[];
        ruleDurationType: number;
        ruleDelayTimestamp: number;
        ruleDelayBlockNumber: number;
        delayTimestamp: number;
        delayBlockNumber: number;
      }
    >;

    getProcessGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]] & { processHandlerList: string[] }>;

    getRoleAdmin(role: BytesLike, overrides?: CallOverrides): Promise<string>;

    getRoleMember(
      role: BytesLike,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    getRoleMemberCount(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "grantRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    haveRole(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<boolean>;

    initialize(
      poolContract_: string,
      engine_: string,
      poolFee_: string,
      clusterRuleArea_: string,
      clusterRuleAreaHandler_: string,
      clusterAttributeArea_: string,
      clusterAttributeAreaToken_: string,
      clusterMountingArea_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    owner(overrides?: CallOverrides): Promise<string>;

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: CallOverrides
    ): Promise<void>;

    paused(channel: BigNumberish, overrides?: CallOverrides): Promise<boolean>;

    poolContract(overrides?: CallOverrides): Promise<string>;

    poolFee(overrides?: CallOverrides): Promise<string>;

    regCluster(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    regRule(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    renounceOwnership(overrides?: CallOverrides): Promise<void>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "renounceRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "revokeRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setClusterAttributeArea(
      clusterAttributeArea_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setClusterRuleArea(
      clusterRuleArea_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setClusterRuleAreaHandler(
      clusterRuleAreaHandler_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    setEngine(engine_: string, overrides?: CallOverrides): Promise<void>;

    setPoolContract(
      poolContract_: string,
      overrides?: CallOverrides
    ): Promise<void>;

    setPoolFee(poolFee_: string, overrides?: CallOverrides): Promise<void>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferOwnership(
      newOwner: string,
      overrides?: CallOverrides
    ): Promise<void>;

    updateGroupSlotTokenHandler(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      tokenSlotIndex: BigNumberish,
      tokenHandler: {
        id: BigNumberish;
        amount: BigNumberish;
        idIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<boolean>;

    version(overrides?: CallOverrides): Promise<BigNumber>;
  };

  filters: {
    "EventCluster(address,uint8,uint32,uint8,uint8)"(
      caller?: string | null,
      regType?: BigNumberish | null,
      clusterId?: BigNumberish | null,
      ruleSlotIndex1?: null,
      ruleSlotIndex2?: null
    ): TypedEventFilter<
      [string, number, number, number, number],
      {
        caller: string;
        regType: number;
        clusterId: number;
        ruleSlotIndex1: number;
        ruleSlotIndex2: number;
      }
    >;

    EventCluster(
      caller?: string | null,
      regType?: BigNumberish | null,
      clusterId?: BigNumberish | null,
      ruleSlotIndex1?: null,
      ruleSlotIndex2?: null
    ): TypedEventFilter<
      [string, number, number, number, number],
      {
        caller: string;
        regType: number;
        clusterId: number;
        ruleSlotIndex1: number;
        ruleSlotIndex2: number;
      }
    >;

    "Initialized(uint8)"(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    Initialized(
      version?: null
    ): TypedEventFilter<[number], { version: number }>;

    "OwnershipTransferred(address,address)"(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    OwnershipTransferred(
      previousOwner?: string | null,
      newOwner?: string | null
    ): TypedEventFilter<
      [string, string],
      { previousOwner: string; newOwner: string }
    >;

    "Paused(uint8,address)"(
      channel?: null,
      account?: null
    ): TypedEventFilter<[number, string], { channel: number; account: string }>;

    Paused(
      channel?: null,
      account?: null
    ): TypedEventFilter<[number, string], { channel: number; account: string }>;

    "Receive(address,uint256)"(
      from?: null,
      value?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { from: string; value: BigNumber }
    >;

    Receive(
      from?: null,
      value?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { from: string; value: BigNumber }
    >;

    "RoleAdminChanged(bytes32,bytes32,bytes32)"(
      role?: BytesLike | null,
      previousAdminRole?: BytesLike | null,
      newAdminRole?: BytesLike | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; previousAdminRole: string; newAdminRole: string }
    >;

    RoleAdminChanged(
      role?: BytesLike | null,
      previousAdminRole?: BytesLike | null,
      newAdminRole?: BytesLike | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; previousAdminRole: string; newAdminRole: string }
    >;

    "RoleGranted(bytes32,address,address)"(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    RoleGranted(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    "RoleRevoked(bytes32,address,address)"(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    RoleRevoked(
      role?: BytesLike | null,
      account?: string | null,
      sender?: string | null
    ): TypedEventFilter<
      [string, string, string],
      { role: string; account: string; sender: string }
    >;

    "Unpaused(uint8,address)"(
      channel?: null,
      account?: null
    ): TypedEventFilter<[number, string], { channel: number; account: string }>;

    Unpaused(
      channel?: null,
      account?: null
    ): TypedEventFilter<[number, string], { channel: number; account: string }>;
  };

  estimateGas: {
    DEFAULT_ADMIN_ROLE(overrides?: CallOverrides): Promise<BigNumber>;

    addRule(
      clusterId: BigNumberish,
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    clusterAttributeArea(overrides?: CallOverrides): Promise<BigNumber>;

    clusterAttributeAreaToken(overrides?: CallOverrides): Promise<BigNumber>;

    clusterDescription(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    clusterMountingArea(overrides?: CallOverrides): Promise<BigNumber>;

    clusterRegBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    clusterRegTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    clusterRuleArea(overrides?: CallOverrides): Promise<BigNumber>;

    clusterRuleAreaHandler(overrides?: CallOverrides): Promise<BigNumber>;

    clusterRuleDelayBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    clusterRuleDelayTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    clusterState(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    cname(overrides?: CallOverrides): Promise<BigNumber>;

    engine(overrides?: CallOverrides): Promise<BigNumber>;

    getAdminList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getClusterAttributeArea(overrides?: CallOverrides): Promise<BigNumber>;

    getClusterAttributeAreaToken(overrides?: CallOverrides): Promise<BigNumber>;

    getClusterMountingArea(overrides?: CallOverrides): Promise<BigNumber>;

    getClusterRoleHash(
      clusterId: BigNumberish,
      role: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getClusterRuleArea(overrides?: CallOverrides): Promise<BigNumber>;

    getClusterRuleAreaHandler(overrides?: CallOverrides): Promise<BigNumber>;

    getClusterState(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getCurrentClusterId(overrides?: CallOverrides): Promise<BigNumber>;

    getDelayBlockNumber(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDelayTimestamp(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDeployerList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDescription(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEngine(overrides?: CallOverrides): Promise<BigNumber>;

    getPostGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getPreGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      branch: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getProcessGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRoleMember(
      role: BytesLike,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRoleMemberCount(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "grantRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    haveRole(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    initialize(
      poolContract_: string,
      engine_: string,
      poolFee_: string,
      clusterRuleArea_: string,
      clusterRuleAreaHandler_: string,
      clusterAttributeArea_: string,
      clusterAttributeAreaToken_: string,
      clusterMountingArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    owner(overrides?: CallOverrides): Promise<BigNumber>;

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    paused(
      channel: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    poolContract(overrides?: CallOverrides): Promise<BigNumber>;

    poolFee(overrides?: CallOverrides): Promise<BigNumber>;

    regCluster(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    regRule(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    renounceOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "renounceRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "revokeRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setClusterAttributeArea(
      clusterAttributeArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setClusterRuleArea(
      clusterRuleArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setClusterRuleAreaHandler(
      clusterRuleAreaHandler_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setEngine(
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPoolContract(
      poolContract_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    setPoolFee(
      poolFee_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateGroupSlotTokenHandler(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      tokenSlotIndex: BigNumberish,
      tokenHandler: {
        id: BigNumberish;
        amount: BigNumberish;
        idIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    version(overrides?: CallOverrides): Promise<BigNumber>;
  };

  populateTransaction: {
    DEFAULT_ADMIN_ROLE(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    addRule(
      clusterId: BigNumberish,
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    clusterAttributeArea(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterAttributeAreaToken(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterDescription(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterMountingArea(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterRegBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterRegTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterRuleArea(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    clusterRuleAreaHandler(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterRuleDelayBlockNumber(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterRuleDelayTimestamp(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    clusterState(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    cname(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    engine(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getAdminList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterAttributeArea(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterAttributeAreaToken(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterMountingArea(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterRoleHash(
      clusterId: BigNumberish,
      role: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterRuleArea(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterRuleAreaHandler(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getClusterState(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getCurrentClusterId(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDelayBlockNumber(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDelayTimestamp(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDeployerList(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDescription(
      clusterId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getEngine(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    getPostGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getPreGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      branch: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getProcessGroupSlotForEngine(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getRoleAdmin(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRoleMember(
      role: BytesLike,
      index: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRoleMemberCount(
      role: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "grantRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "grantRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    hasRole(
      role: BytesLike,
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    haveRole(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    initialize(
      poolContract_: string,
      engine_: string,
      poolFee_: string,
      clusterRuleArea_: string,
      clusterRuleAreaHandler_: string,
      clusterAttributeArea_: string,
      clusterAttributeAreaToken_: string,
      clusterMountingArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    paused(
      channel: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    poolContract(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    poolFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    regCluster(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    regRule(
      cluster: {
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        ruleSlotBound: BigNumberish[];
        ruleList: {
          ruleSlotIndexInput: BigNumberish;
          ruleSlotIndexOutput: BigNumberish;
          state: BigNumberish;
          totalCount: BigNumberish;
          durationType: BigNumberish;
          delayTimestamp: BigNumberish;
          delayBlockNumber: BigNumberish;
          handlerCount: BigNumberish;
          handlerList: string[];
          handlerArgsList: BytesLike[];
          snippet: string;
        }[];
        attrList: {
          attrId: BigNumberish;
          name: string;
          symbol: string;
          uri: string;
          level: BigNumberish;
        }[];
        attrStateList: BigNumberish[];
        deployerList: string[];
        adminList: string[];
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        state: BigNumberish;
        description: string;
      },
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    renounceOwnership(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "renounceRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "renounceRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "revokeRole(uint32,uint8,address)"(
      clusterId: BigNumberish,
      role: BigNumberish,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    "revokeRole(bytes32,address)"(
      role: BytesLike,
      account: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setClusterAttributeArea(
      clusterAttributeArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setClusterRuleArea(
      clusterRuleArea_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setClusterRuleAreaHandler(
      clusterRuleAreaHandler_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setEngine(
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPoolContract(
      poolContract_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    setPoolFee(
      poolFee_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    supportsInterface(
      interfaceId: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    transferOwnership(
      newOwner: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    updateGroupSlotTokenHandler(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      tokenSlotIndex: BigNumberish,
      tokenHandler: {
        id: BigNumberish;
        amount: BigNumberish;
        idIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    version(overrides?: CallOverrides): Promise<PopulatedTransaction>;
  };
}