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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
  BaseContract,
  ContractTransaction,
  Overrides,
  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 IClusterRuleAreaInterface extends ethers.utils.Interface {
  functions: {
    "cname()": FunctionFragment;
    "getClusterArea()": FunctionFragment;
    "getEngine()": FunctionFragment;
    "getGroupSlot(uint32,uint16,uint8)": FunctionFragment;
    "getGroupSlotBound(uint32,uint16)": FunctionFragment;
    "getGroupSlotBoundList(uint32)": FunctionFragment;
    "getGroupSlotBranchList(uint32,uint16)": FunctionFragment;
    "getGroupSlotHandlerArgs(uint32,uint16,uint8,address)": FunctionFragment;
    "getGroupSlotLength(uint32,uint16)": FunctionFragment;
    "getPoolContract()": FunctionFragment;
    "getPoolFee()": FunctionFragment;
    "getRuleDelayBlockNumber(uint32,uint16,uint16)": FunctionFragment;
    "getRuleDelayTimestamp(uint32,uint16,uint16)": FunctionFragment;
    "getRuleDurationType(uint32,uint16,uint16)": FunctionFragment;
    "getRuleLeftCount(uint32,uint16,uint16)": FunctionFragment;
    "getRuleSlotIndexList(uint32)": FunctionFragment;
    "getRuleSlotIndexRule(uint32,uint16)": FunctionFragment;
    "getRuleSlotLength(uint32)": FunctionFragment;
    "getRuleState(uint32,uint16,uint16)": FunctionFragment;
    "getRuleTotalCount(uint32,uint16,uint16)": FunctionFragment;
    "registerRule(address,uint32,(tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "setRuleState(uint32,uint16,uint16,uint8)": FunctionFragment;
    "updateGroupSlotList(uint32,tuple[])": FunctionFragment;
    "updateGroupSlotTokenHandler(uint32,uint16,uint8,uint8,(uint256,uint256,uint256))": FunctionFragment;
    "updateRuleLeftCount(uint32,uint16,uint16,uint32)": FunctionFragment;
    "updateRuleList(uint32,tuple[])": FunctionFragment;
    "version()": FunctionFragment;
  };

  encodeFunctionData(functionFragment: "cname", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getClusterArea",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getEngine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getGroupSlot",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGroupSlotBound",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGroupSlotBoundList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGroupSlotBranchList",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getGroupSlotHandlerArgs",
    values: [BigNumberish, BigNumberish, BigNumberish, string]
  ): string;
  encodeFunctionData(
    functionFragment: "getGroupSlotLength",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleDelayBlockNumber",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleDelayTimestamp",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleDurationType",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleLeftCount",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleSlotIndexList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleSlotIndexRule",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleSlotLength",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleState",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleTotalCount",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "registerRule",
    values: [
      string,
      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: "setRuleState",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateGroupSlotList",
    values: [
      BigNumberish,
      {
        ruleSlotIndex: BigNumberish;
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        groupSlotOptList: BigNumberish[];
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "updateGroupSlotTokenHandler",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      { id: BigNumberish; amount: BigNumberish; idIndex: BigNumberish }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "updateRuleLeftCount",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "updateRuleList",
    values: [
      BigNumberish,
      {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[]
    ]
  ): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;

  decodeFunctionResult(functionFragment: "cname", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getClusterArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getEngine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlot",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlotBound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlotBoundList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlotBranchList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlotHandlerArgs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGroupSlotLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getPoolFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getRuleDelayBlockNumber",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleDelayTimestamp",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleDurationType",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleLeftCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleSlotIndexList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleSlotIndexRule",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleSlotLength",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleTotalCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "registerRule",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setRuleState",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateGroupSlotList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateGroupSlotTokenHandler",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateRuleLeftCount",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateRuleList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;

  events: {
    "EventClusterRule(address,uint8,uint32,uint8,uint8)": EventFragment;
    "SetRuleState(uint32,uint16,uint16,uint8,uint8)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "EventClusterRule"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "SetRuleState"): EventFragment;
}

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

export type SetRuleStateEvent = TypedEvent<
  [number, number, number, number, number] & {
    clusterId: number;
    ruleSlotIndexInput: number;
    ruleSlotIndexOutput: number;
    state: number;
    newState: number;
  }
>;

export class IClusterRuleArea 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: IClusterRuleAreaInterface;

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

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

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

    getGroupSlot(
      clusterId: BigNumberish,
      ruleSlotIndex: 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[];
        }
      ] & { found: boolean }
    >;

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

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

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

    getGroupSlotHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      handler: string,
      overrides?: CallOverrides
    ): Promise<[string]>;

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

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

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

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

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

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

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

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

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

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

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

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

    registerRule(
      caller: string,
      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?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    updateGroupSlotList(
      clusterId: BigNumberish,
      ruleSlotList: {
        ruleSlotIndex: BigNumberish;
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        groupSlotOptList: 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>;

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

    updateRuleList(
      clusterId: BigNumberish,
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

  getGroupSlot(
    clusterId: BigNumberish,
    ruleSlotIndex: 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[];
      }
    ] & { found: boolean }
  >;

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

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

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

  getGroupSlotHandlerArgs(
    clusterId: BigNumberish,
    ruleSlotIndex: BigNumberish,
    branch: BigNumberish,
    handler: string,
    overrides?: CallOverrides
  ): Promise<string>;

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

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

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

  getRuleDelayBlockNumber(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getRuleDelayTimestamp(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getRuleDurationType(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getRuleLeftCount(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

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

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

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

  getRuleState(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  getRuleTotalCount(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<number>;

  registerRule(
    caller: string,
    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?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  updateGroupSlotList(
    clusterId: BigNumberish,
    ruleSlotList: {
      ruleSlotIndex: BigNumberish;
      groupSlotList: {
        tokenSlotList: {
          tokenTemplate: {
            erc: BigNumberish;
            token: string;
            valueList: BigNumberish[];
          };
          rule: BigNumberish;
          ioAddressList: string[];
          valueList: BigNumberish[];
        }[];
        branch: BigNumberish;
        poolToken: string;
        handlerList: string[];
        argsList: BytesLike[];
      }[];
      groupSlotOptList: 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>;

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

  updateRuleList(
    clusterId: BigNumberish,
    ruleList: {
      ruleSlotIndexInput: BigNumberish;
      ruleSlotIndexOutput: BigNumberish;
      state: BigNumberish;
      totalCount: BigNumberish;
      durationType: BigNumberish;
      delayTimestamp: BigNumberish;
      delayBlockNumber: BigNumberish;
      handlerCount: BigNumberish;
      handlerList: string[];
      handlerArgsList: BytesLike[];
      snippet: string;
    }[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

    getGroupSlot(
      clusterId: BigNumberish,
      ruleSlotIndex: 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[];
        }
      ] & { found: boolean }
    >;

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

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

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

    getGroupSlotHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      handler: string,
      overrides?: CallOverrides
    ): Promise<string>;

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

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

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

    getRuleDelayBlockNumber(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getRuleDelayTimestamp(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getRuleDurationType(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getRuleLeftCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

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

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

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

    getRuleState(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    getRuleTotalCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<number>;

    registerRule(
      caller: string,
      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>;

    setRuleState(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      state: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    updateGroupSlotList(
      clusterId: BigNumberish,
      ruleSlotList: {
        ruleSlotIndex: BigNumberish;
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        groupSlotOptList: 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>;

    updateRuleLeftCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      decreaseCount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    updateRuleList(
      clusterId: BigNumberish,
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

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

  filters: {
    "EventClusterRule(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;
      }
    >;

    EventClusterRule(
      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;
      }
    >;

    "SetRuleState(uint32,uint16,uint16,uint8,uint8)"(
      clusterId?: null,
      ruleSlotIndexInput?: null,
      ruleSlotIndexOutput?: null,
      state?: null,
      newState?: null
    ): TypedEventFilter<
      [number, number, number, number, number],
      {
        clusterId: number;
        ruleSlotIndexInput: number;
        ruleSlotIndexOutput: number;
        state: number;
        newState: number;
      }
    >;

    SetRuleState(
      clusterId?: null,
      ruleSlotIndexInput?: null,
      ruleSlotIndexOutput?: null,
      state?: null,
      newState?: null
    ): TypedEventFilter<
      [number, number, number, number, number],
      {
        clusterId: number;
        ruleSlotIndexInput: number;
        ruleSlotIndexOutput: number;
        state: number;
        newState: number;
      }
    >;
  };

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

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

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

    getGroupSlot(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    getGroupSlotHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      handler: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    getRuleDelayBlockNumber(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRuleDelayTimestamp(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRuleDurationType(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRuleLeftCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

    getRuleState(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getRuleTotalCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    registerRule(
      caller: string,
      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?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    updateGroupSlotList(
      clusterId: BigNumberish,
      ruleSlotList: {
        ruleSlotIndex: BigNumberish;
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        groupSlotOptList: 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>;

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

    updateRuleList(
      clusterId: BigNumberish,
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

    getGroupSlot(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    getGroupSlotHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      handler: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    getRuleDelayBlockNumber(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRuleDelayTimestamp(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRuleDurationType(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRuleLeftCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

    getRuleState(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getRuleTotalCount(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    registerRule(
      caller: string,
      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?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    updateGroupSlotList(
      clusterId: BigNumberish,
      ruleSlotList: {
        ruleSlotIndex: BigNumberish;
        groupSlotList: {
          tokenSlotList: {
            tokenTemplate: {
              erc: BigNumberish;
              token: string;
              valueList: BigNumberish[];
            };
            rule: BigNumberish;
            ioAddressList: string[];
            valueList: BigNumberish[];
          }[];
          branch: BigNumberish;
          poolToken: string;
          handlerList: string[];
          argsList: BytesLike[];
        }[];
        groupSlotOptList: 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>;

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

    updateRuleList(
      clusterId: BigNumberish,
      ruleList: {
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        state: BigNumberish;
        totalCount: BigNumberish;
        durationType: BigNumberish;
        delayTimestamp: BigNumberish;
        delayBlockNumber: BigNumberish;
        handlerCount: BigNumberish;
        handlerList: string[];
        handlerArgsList: BytesLike[];
        snippet: string;
      }[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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