/* 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 BaseHandlerInterface extends ethers.utils.Interface {
  functions: {
    "claimIOAddressBranchToken((address,address,address,uint32,uint32,address,uint8,uint16,uint8,uint8))": FunctionFragment;
    "cname()": FunctionFragment;
    "getClaimIOAddressBranchToken((address,address,address,uint32,uint32,address,uint8,uint16,uint8,uint8))": FunctionFragment;
    "getEngineAreaList(string[])": FunctionFragment;
    "getIOBranches()": FunctionFragment;
    "getInputAddressRound(address,address,uint32,address,uint32,uint16)": FunctionFragment;
    "getOutputAddressRound(address,address,uint32,address,uint32,uint16)": FunctionFragment;
    "getRuleGroupSlotArgs(uint32,uint16,uint8)": FunctionFragment;
    "getState((address,address,uint32,uint16,uint16,uint8,address,uint32,address,uint8,bytes))": FunctionFragment;
    "getTokenBranch(address,address,address,uint32,address,uint32,bytes,uint16)": FunctionFragment;
    "owner()": FunctionFragment;
    "process((address,address,address,(address,address,address,address,uint256,uint256,uint32,uint32,uint32,uint8,tuple[],bytes),uint8),(address,uint8,string,bytes))": FunctionFragment;
    "randomGenerator()": FunctionFragment;
    "regRule(uint32,(tuple[],uint8[],tuple[],tuple[],uint8[],address[],address[],uint32,uint32,uint8,string))": FunctionFragment;
    "regRuleGroupSlotArgs(uint32,uint16,uint8,bytes)": FunctionFragment;
    "renounceOwnership()": FunctionFragment;
    "setEngineAreaList(address[])": FunctionFragment;
    "transferOwnership(address)": FunctionFragment;
    "updateArgs(uint32,uint16,uint16,uint8,bytes)": FunctionFragment;
    "version()": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "claimIOAddressBranchToken",
    values: [
      {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(functionFragment: "cname", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getClaimIOAddressBranchToken",
    values: [
      {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getEngineAreaList",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "getIOBranches",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getInputAddressRound",
    values: [string, string, BigNumberish, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getOutputAddressRound",
    values: [string, string, BigNumberish, string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getRuleGroupSlotArgs",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "getState",
    values: [
      {
        engine: string;
        clusterArea: string;
        clusterId: BigNumberish;
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        branch: BigNumberish;
        stateCounter: string;
        taskId: BigNumberish;
        caller: string;
        cmd: BigNumberish;
        args: BytesLike;
      }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "getTokenBranch",
    values: [
      string,
      string,
      string,
      BigNumberish,
      string,
      BigNumberish,
      BytesLike,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "process",
    values: [
      {
        caller: string;
        stateCounter: string;
        poolFee: string;
        task: {
          caller: string;
          clusterArea: string;
          lastHandler: string;
          snippet: string;
          valueTime: BigNumberish;
          value: BigNumberish;
          taskId: BigNumberish;
          parentTaskId: BigNumberish;
          clusterId: BigNumberish;
          state: BigNumberish;
          inTokenList: {
            erc: BigNumberish;
            token: string;
            id: BigNumberish;
            amount: BigNumberish;
            attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
          }[];
          args: BytesLike;
        };
        state: BigNumberish;
      },
      { handler: string; code: BigNumberish; msg: string; args: BytesLike }
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "randomGenerator",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "regRule",
    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: "regRuleGroupSlotArgs",
    values: [BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "renounceOwnership",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "setEngineAreaList",
    values: [string[]]
  ): string;
  encodeFunctionData(
    functionFragment: "transferOwnership",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "updateArgs",
    values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "version", values?: undefined): string;

  decodeFunctionResult(
    functionFragment: "claimIOAddressBranchToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "cname", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getClaimIOAddressBranchToken",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getEngineAreaList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getIOBranches",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getInputAddressRound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOutputAddressRound",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getRuleGroupSlotArgs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getState", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getTokenBranch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "process", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "randomGenerator",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "regRule", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "regRuleGroupSlotArgs",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "renounceOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "setEngineAreaList",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "transferOwnership",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "updateArgs", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "version", data: BytesLike): Result;

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

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

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

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

export class BaseHandler 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: BaseHandlerInterface;

  functions: {
    claimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    getClaimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<[boolean]>;

    getEngineAreaList(
      areaNameList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getIOBranches(
      overrides?: CallOverrides
    ): Promise<
      [([number[], number[]] & { inBranch: number[]; outBranch: number[] })[]]
    >;

    getInputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    getOutputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[string[]]>;

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

    getState(
      params: {
        engine: string;
        clusterArea: string;
        clusterId: BigNumberish;
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        branch: BigNumberish;
        stateCounter: string;
        taskId: BigNumberish;
        caller: string;
        cmd: BigNumberish;
        args: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<[string[]]>;

    getTokenBranch(
      engine: string,
      outAddress: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      args: BytesLike,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[[BigNumber[]] & { valueList: BigNumber[] }]>;

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

    process(
      param: {
        caller: string;
        stateCounter: string;
        poolFee: string;
        task: {
          caller: string;
          clusterArea: string;
          lastHandler: string;
          snippet: string;
          valueTime: BigNumberish;
          value: BigNumberish;
          taskId: BigNumberish;
          parentTaskId: BigNumberish;
          clusterId: BigNumberish;
          state: BigNumberish;
          inTokenList: {
            erc: BigNumberish;
            token: string;
            id: BigNumberish;
            amount: BigNumberish;
            attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
          }[];
          args: BytesLike;
        };
        state: BigNumberish;
      },
      preResult: {
        handler: string;
        code: BigNumberish;
        msg: string;
        args: BytesLike;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

    regRuleGroupSlotArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    setEngineAreaList(
      engineAreaList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

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

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

  claimIOAddressBranchToken(
    claim: {
      engine: string;
      clusterArea: string;
      stateCounter: string;
      clusterId: BigNumberish;
      taskId: BigNumberish;
      claimer: string;
      io: BigNumberish;
      round: BigNumberish;
      branch: BigNumberish;
      tokenSlotIndex: BigNumberish;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  getClaimIOAddressBranchToken(
    claim: {
      engine: string;
      clusterArea: string;
      stateCounter: string;
      clusterId: BigNumberish;
      taskId: BigNumberish;
      claimer: string;
      io: BigNumberish;
      round: BigNumberish;
      branch: BigNumberish;
      tokenSlotIndex: BigNumberish;
    },
    overrides?: CallOverrides
  ): Promise<boolean>;

  getEngineAreaList(
    areaNameList: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getIOBranches(
    overrides?: CallOverrides
  ): Promise<
    ([number[], number[]] & { inBranch: number[]; outBranch: number[] })[]
  >;

  getInputAddressRound(
    engine: string,
    clusterArea: string,
    clusterId: BigNumberish,
    stateCounter: string,
    taskId: BigNumberish,
    round: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

  getOutputAddressRound(
    engine: string,
    clusterArea: string,
    clusterId: BigNumberish,
    stateCounter: string,
    taskId: BigNumberish,
    round: BigNumberish,
    overrides?: CallOverrides
  ): Promise<string[]>;

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

  getState(
    params: {
      engine: string;
      clusterArea: string;
      clusterId: BigNumberish;
      ruleSlotIndexInput: BigNumberish;
      ruleSlotIndexOutput: BigNumberish;
      branch: BigNumberish;
      stateCounter: string;
      taskId: BigNumberish;
      caller: string;
      cmd: BigNumberish;
      args: BytesLike;
    },
    overrides?: CallOverrides
  ): Promise<string[]>;

  getTokenBranch(
    engine: string,
    outAddress: string,
    clusterArea: string,
    clusterId: BigNumberish,
    stateCounter: string,
    taskId: BigNumberish,
    args: BytesLike,
    round: BigNumberish,
    overrides?: CallOverrides
  ): Promise<[BigNumber[]] & { valueList: BigNumber[] }>;

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

  process(
    param: {
      caller: string;
      stateCounter: string;
      poolFee: string;
      task: {
        caller: string;
        clusterArea: string;
        lastHandler: string;
        snippet: string;
        valueTime: BigNumberish;
        value: BigNumberish;
        taskId: BigNumberish;
        parentTaskId: BigNumberish;
        clusterId: BigNumberish;
        state: BigNumberish;
        inTokenList: {
          erc: BigNumberish;
          token: string;
          id: BigNumberish;
          amount: BigNumberish;
          attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
        }[];
        args: BytesLike;
      };
      state: BigNumberish;
    },
    preResult: {
      handler: string;
      code: BigNumberish;
      msg: string;
      args: BytesLike;
    },
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

  regRuleGroupSlotArgs(
    clusterId: BigNumberish,
    ruleSlotIndex: BigNumberish,
    branch: BigNumberish,
    args: BytesLike,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  setEngineAreaList(
    engineAreaList: string[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

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

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

  callStatic: {
    claimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<boolean>;

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

    getClaimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<boolean>;

    getEngineAreaList(
      areaNameList: string[],
      overrides?: CallOverrides
    ): Promise<string[]>;

    getIOBranches(
      overrides?: CallOverrides
    ): Promise<
      ([number[], number[]] & { inBranch: number[]; outBranch: number[] })[]
    >;

    getInputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

    getOutputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<string[]>;

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

    getState(
      params: {
        engine: string;
        clusterArea: string;
        clusterId: BigNumberish;
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        branch: BigNumberish;
        stateCounter: string;
        taskId: BigNumberish;
        caller: string;
        cmd: BigNumberish;
        args: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<string[]>;

    getTokenBranch(
      engine: string,
      outAddress: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      args: BytesLike,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { valueList: BigNumber[] }>;

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

    process(
      param: {
        caller: string;
        stateCounter: string;
        poolFee: string;
        task: {
          caller: string;
          clusterArea: string;
          lastHandler: string;
          snippet: string;
          valueTime: BigNumberish;
          value: BigNumberish;
          taskId: BigNumberish;
          parentTaskId: BigNumberish;
          clusterId: BigNumberish;
          state: BigNumberish;
          inTokenList: {
            erc: BigNumberish;
            token: string;
            id: BigNumberish;
            amount: BigNumberish;
            attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
          }[];
          args: BytesLike;
        };
        state: BigNumberish;
      },
      preResult: {
        handler: string;
        code: BigNumberish;
        msg: string;
        args: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<
      [string, number, string, string] & {
        handler: string;
        code: number;
        msg: string;
        args: string;
      }
    >;

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

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

    regRuleGroupSlotArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      args: BytesLike,
      overrides?: CallOverrides
    ): Promise<void>;

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

    setEngineAreaList(
      engineAreaList: string[],
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

  filters: {
    "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: {
    claimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    getClaimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getEngineAreaList(
      areaNameList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    getInputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getOutputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    getState(
      params: {
        engine: string;
        clusterArea: string;
        clusterId: BigNumberish;
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        branch: BigNumberish;
        stateCounter: string;
        taskId: BigNumberish;
        caller: string;
        cmd: BigNumberish;
        args: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getTokenBranch(
      engine: string,
      outAddress: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      args: BytesLike,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    process(
      param: {
        caller: string;
        stateCounter: string;
        poolFee: string;
        task: {
          caller: string;
          clusterArea: string;
          lastHandler: string;
          snippet: string;
          valueTime: BigNumberish;
          value: BigNumberish;
          taskId: BigNumberish;
          parentTaskId: BigNumberish;
          clusterId: BigNumberish;
          state: BigNumberish;
          inTokenList: {
            erc: BigNumberish;
            token: string;
            id: BigNumberish;
            amount: BigNumberish;
            attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
          }[];
          args: BytesLike;
        };
        state: BigNumberish;
      },
      preResult: {
        handler: string;
        code: BigNumberish;
        msg: string;
        args: BytesLike;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

    regRuleGroupSlotArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    setEngineAreaList(
      engineAreaList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

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

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

  populateTransaction: {
    claimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    getClaimIOAddressBranchToken(
      claim: {
        engine: string;
        clusterArea: string;
        stateCounter: string;
        clusterId: BigNumberish;
        taskId: BigNumberish;
        claimer: string;
        io: BigNumberish;
        round: BigNumberish;
        branch: BigNumberish;
        tokenSlotIndex: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getEngineAreaList(
      areaNameList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    getInputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getOutputAddressRound(
      engine: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    getState(
      params: {
        engine: string;
        clusterArea: string;
        clusterId: BigNumberish;
        ruleSlotIndexInput: BigNumberish;
        ruleSlotIndexOutput: BigNumberish;
        branch: BigNumberish;
        stateCounter: string;
        taskId: BigNumberish;
        caller: string;
        cmd: BigNumberish;
        args: BytesLike;
      },
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getTokenBranch(
      engine: string,
      outAddress: string,
      clusterArea: string,
      clusterId: BigNumberish,
      stateCounter: string,
      taskId: BigNumberish,
      args: BytesLike,
      round: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    process(
      param: {
        caller: string;
        stateCounter: string;
        poolFee: string;
        task: {
          caller: string;
          clusterArea: string;
          lastHandler: string;
          snippet: string;
          valueTime: BigNumberish;
          value: BigNumberish;
          taskId: BigNumberish;
          parentTaskId: BigNumberish;
          clusterId: BigNumberish;
          state: BigNumberish;
          inTokenList: {
            erc: BigNumberish;
            token: string;
            id: BigNumberish;
            amount: BigNumberish;
            attrInList: { attrId: BigNumberish; attrAmount: BigNumberish }[];
          }[];
          args: BytesLike;
        };
        state: BigNumberish;
      },
      preResult: {
        handler: string;
        code: BigNumberish;
        msg: string;
        args: BytesLike;
      },
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

    regRuleGroupSlotArgs(
      clusterId: BigNumberish,
      ruleSlotIndex: BigNumberish,
      branch: BigNumberish,
      args: BytesLike,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    setEngineAreaList(
      engineAreaList: string[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

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

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