/* 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 IClusterAreaInterface extends ethers.utils.Interface {
  functions: {
    "addRule(uint32,(tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "cname()": FunctionFragment;
    "getAdminList(uint32)": FunctionFragment;
    "getClusterAttributeArea()": FunctionFragment;
    "getClusterAttributeAreaToken()": FunctionFragment;
    "getClusterMountingArea()": 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;
    "grantRole(uint32,uint8,address)": FunctionFragment;
    "haveRole(uint32,uint8,address)": FunctionFragment;
    "pause(uint8,bool)": 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;
    "renounceRole(uint32,uint8,address)": FunctionFragment;
    "revokeRole(uint32,uint8,address)": FunctionFragment;
    "setClusterState(uint32,uint8)": FunctionFragment;
    "updateGroupSlotTokenHandler(uint32,uint16,uint8,uint8,(uint256,uint256,uint256))": FunctionFragment;
    "version()": FunctionFragment;
  };

  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: "cname", 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: "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: "grantRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "haveRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "pause",
    values: [BigNumberish, boolean]
  ): 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: "renounceRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "revokeRole",
    values: [BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterState",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateGroupSlotTokenHandler",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      { id: BigNumberish; amount: BigNumberish; idIndex: BigNumberish }
    ]
  ): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;

  decodeFunctionResult(functionFragment: "addRule", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "cname", 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: "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: "grantRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "haveRole", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "regCluster", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "regRule", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "renounceRole",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "revokeRole", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setClusterState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateGroupSlotTokenHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;

  events: {
    "EventCluster(address,uint8,uint32,uint8,uint8)": EventFragment;
    "Receive(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "EventCluster"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Receive"): EventFragment;
}

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

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

export class IClusterArea 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: IClusterAreaInterface;

  functions: {
    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>;

    cname(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]>;

    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>;

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

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

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

    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>;

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

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

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      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]>;
  };

  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>;

  cname(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>;

  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>;

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

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

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

  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>;

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

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

  setClusterState(
    clusterId: BigNumberish,
    state: BigNumberish,
    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: {
    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>;

    cname(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>;

    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[] }>;

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

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

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

    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>;

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

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

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      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;
      }
    >;

    "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 }
    >;
  };

  estimateGas: {
    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>;

    cname(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>;

    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>;

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

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

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      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: {
    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>;

    cname(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>;

    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>;

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

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

    pause(
      channel: BigNumberish,
      _paused: boolean,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): 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>;

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

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

    setClusterState(
      clusterId: BigNumberish,
      state: BigNumberish,
      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>;
  };
}