/* 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 ClusterRuleAreaHandlerInterface extends ethers.utils.Interface {
  functions: {
    "clusterArea()": FunctionFragment;
    "cname()": FunctionFragment;
    "engine()": FunctionFragment;
    "getClusterArea()": FunctionFragment;
    "getEngine()": FunctionFragment;
    "getHandlerList(uint32)": FunctionFragment;
    "getHandlerPoolList(uint32)": FunctionFragment;
    "getPoolContract()": FunctionFragment;
    "getPoolFee()": FunctionFragment;
    "getPostHandlerList(uint32,uint16,uint16)": FunctionFragment;
    "getPreHandlerList(uint32,uint16,uint16)": FunctionFragment;
    "getProcessHandlerList(uint32,uint16,uint16)": FunctionFragment;
    "getSnippet(uint32,uint16,uint16)": FunctionFragment;
    "initialize(address,address,address,address)": FunctionFragment;
    "owner()": FunctionFragment;
    "poolContract()": FunctionFragment;
    "poolFee()": FunctionFragment;
    "registerHandlerList(uint32,(tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "ruleHandlerList(uint32,uint256)": FunctionFragment;
    "ruleHandlerPoolList(uint32,uint256)": FunctionFragment;
    "rulePostHandlerList(bytes32,uint256)": FunctionFragment;
    "rulePreHandlerList(bytes32,uint256)": FunctionFragment;
    "ruleProcessHandlerList(bytes32,uint256)": FunctionFragment;
    "ruleSnippet(bytes32)": FunctionFragment;
    "setClusterArea(address)": FunctionFragment;
    "setEngine(address)": FunctionFragment;
    "setPoolContract(address)": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateHandlerArgs(uint32,uint16,uint16,uint8,address,bytes)": FunctionFragment;
    "updateHandlerList(uint32,tuple[])": FunctionFragment;
    "version()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "clusterArea",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "cname", values?: undefined): string;
  encodeFunctionData(functionFragment: "engine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getClusterArea",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "getEngine", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getHandlerList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getHandlerPoolList",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolContract",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPoolFee",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getPostHandlerList",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getPreHandlerList",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getProcessHandlerList",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getSnippet",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [string, string, string, string]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "poolContract",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "poolFee", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "registerHandlerList",
    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: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "ruleHandlerList",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "ruleHandlerPoolList",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "rulePostHandlerList",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "rulePreHandlerList",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "ruleProcessHandlerList",
    values: [BytesLike, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "ruleSnippet",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "setClusterArea",
    values: [string]
  ): string;
  encodeFunctionData(functionFragment: "setEngine", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setPoolContract",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateHandlerArgs",
    values: [
      BigNumberish,
      BigNumberish,
      BigNumberish,
      BigNumberish,
      string,
      BytesLike
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "updateHandlerList",
    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: "clusterArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cname", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "engine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getClusterArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getEngine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getHandlerPoolList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPoolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getPoolFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getPostHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getPreHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getProcessHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getSnippet", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "poolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "poolFee", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "registerHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ruleHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ruleHandlerPoolList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rulePostHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "rulePreHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ruleProcessHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "ruleSnippet",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setClusterArea",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "setEngine", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setPoolContract",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateHandlerArgs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "updateHandlerList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;

  events: {
    "EventClusterHandler(address,uint8,uint32,uint8,uint8)": EventFragment;
    "Initialized(uint8)": EventFragment;
    "OwnershipTransferred(address,address)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "EventClusterHandler"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
}

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

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

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

export class ClusterRuleAreaHandler 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: ClusterRuleAreaHandlerInterface;

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

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

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      clusterArea_: string,
      poolContract_: string,
      poolFee_: string,
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

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

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

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

    ruleSnippet(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;

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

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

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

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

    updateHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      cmd: BigNumberish,
      handler: string,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    updateHandlerList(
      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]>;
  };

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

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

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

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

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

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

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

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

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

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

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

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

  getSnippet(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  initialize(
    clusterArea_: string,
    poolContract_: string,
    poolFee_: string,
    engine_: string,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

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

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

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

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

  rulePostHandlerList(
    arg0: BytesLike,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  rulePreHandlerList(
    arg0: BytesLike,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  ruleProcessHandlerList(
    arg0: BytesLike,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string>;

  ruleSnippet(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;

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

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

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

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

  updateHandlerArgs(
    clusterId: BigNumberish,
    ruleSlotIndexInput: BigNumberish,
    ruleSlotIndexOutput: BigNumberish,
    cmd: BigNumberish,
    handler: string,
    args: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  updateHandlerList(
    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: {
    clusterArea(overrides?: CallOverrides): Promise<string>;

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

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

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

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

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

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

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

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

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

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

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

    getSnippet(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    initialize(
      clusterArea_: string,
      poolContract_: string,
      poolFee_: string,
      engine_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

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

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

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

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

    rulePostHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    rulePreHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    ruleProcessHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string>;

    ruleSnippet(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;

    setClusterArea(
      clusterArea_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    updateHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      cmd: BigNumberish,
      handler: string,
      args: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    updateHandlerList(
      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: {
    "EventClusterHandler(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;
      }
    >;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      clusterArea_: string,
      poolContract_: string,
      poolFee_: string,
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

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

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

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

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

    rulePostHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    rulePreHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    ruleProcessHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    ruleSnippet(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

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

    updateHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      cmd: BigNumberish,
      handler: string,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    updateHandlerList(
      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: {
    clusterArea(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

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

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

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

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

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

    initialize(
      clusterArea_: string,
      poolContract_: string,
      poolFee_: string,
      engine_: string,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

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

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

    rulePostHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    rulePreHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    ruleProcessHandlerList(
      arg0: BytesLike,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    ruleSnippet(
      arg0: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    updateHandlerArgs(
      clusterId: BigNumberish,
      ruleSlotIndexInput: BigNumberish,
      ruleSlotIndexOutput: BigNumberish,
      cmd: BigNumberish,
      handler: string,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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