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

import {
  Address,
  Contract,
  ContractState,
  TestContractResult,
  HexString,
  ContractFactory,
  EventSubscribeOptions,
  EventSubscription,
  CallContractParams,
  CallContractResult,
  TestContractParams,
  ContractEvent,
  subscribeContractEvent,
  subscribeContractEvents,
  testMethod,
  callMethod,
  multicallMethods,
  fetchContractState,
  Asset,
  ContractInstance,
  getContractEventsCurrentCount,
  TestContractParamsWithoutMaps,
  TestContractResultWithoutMaps,
  SignExecuteContractMethodParams,
  SignExecuteScriptTxResult,
  signExecuteMethod,
  addStdIdToFields,
  encodeContractFields,
  Narrow,
} from "@alephium/web3";
import { default as PositionManagerContractJson } from "../PositionManager.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";
import * as types from "./types";

// Custom types for the contract
export namespace PositionManagerTypes {
  export type Fields = {
    parent: HexString;
  };

  export type State = ContractState<Fields>;

  export interface CallMethodTable {
    addLiquidity: {
      params: CallContractParams<{
        payer: Address;
        p: types.ModifyLiquidityParams;
      }>;
      result: CallContractResult<[bigint, bigint, bigint, HexString]>;
    };
    getLiquidityForAmount0: {
      params: CallContractParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount0: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    getLiquidityForAmount1: {
      params: CallContractParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount1: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    getLiquidityForAmounts: {
      params: CallContractParams<{
        sqrtRatioX96: bigint;
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount0: bigint;
        amount1: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    getAmount0ForLiquidity: {
      params: CallContractParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        liquidity: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    mulDiv: {
      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
      result: CallContractResult<bigint>;
    };
    mulDivRoundingUp: {
      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
      result: CallContractResult<bigint>;
    };
    configPath: {
      params: CallContractParams<{ configIndex_: bigint }>;
      result: CallContractResult<HexString>;
    };
    poolPath: {
      params: CallContractParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    poolContractId: {
      params: CallContractParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    positionPath: {
      params: CallContractParams<{
        o: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    positionContractId: {
      params: CallContractParams<{
        pool: HexString;
        o: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    increaseLiquidity: {
      params: CallContractParams<{
        payer: Address;
        p: types.ModifyLiquidityParams;
      }>;
      result: CallContractResult<null>;
    };
    decreaseLiquidity: {
      params: CallContractParams<{
        operator: Address;
        liquidity: bigint;
        p: types.DecreaseLiquidityParams;
      }>;
      result: CallContractResult<null>;
    };
    collect: {
      params: CallContractParams<{
        operator: Address;
        liquidity: bigint;
        p: types.CollectParams;
      }>;
      result: CallContractResult<null>;
    };
    getSqrtPricesX96: {
      params: CallContractParams<{
        pool: HexString;
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: CallContractResult<[bigint, bigint, bigint, bigint]>;
    };
  }
  export type CallMethodParams<T extends keyof CallMethodTable> =
    CallMethodTable[T]["params"];
  export type CallMethodResult<T extends keyof CallMethodTable> =
    CallMethodTable[T]["result"];
  export type MultiCallParams = Partial<{
    [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
  }>;
  export type MultiCallResults<T extends MultiCallParams> = {
    [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable
      ? CallMethodTable[MaybeName]["result"]
      : undefined;
  };
  export type MulticallReturnType<Callss extends MultiCallParams[]> = {
    [index in keyof Callss]: MultiCallResults<Callss[index]>;
  };

  export interface SignExecuteMethodTable {
    addLiquidity: {
      params: SignExecuteContractMethodParams<{
        payer: Address;
        p: types.ModifyLiquidityParams;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getLiquidityForAmount0: {
      params: SignExecuteContractMethodParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount0: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getLiquidityForAmount1: {
      params: SignExecuteContractMethodParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount1: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getLiquidityForAmounts: {
      params: SignExecuteContractMethodParams<{
        sqrtRatioX96: bigint;
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        amount0: bigint;
        amount1: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getAmount0ForLiquidity: {
      params: SignExecuteContractMethodParams<{
        sqrtRatioAX96: bigint;
        sqrtRatioBX96: bigint;
        liquidity: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    mulDiv: {
      params: SignExecuteContractMethodParams<{
        a: bigint;
        b: bigint;
        denominator: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    mulDivRoundingUp: {
      params: SignExecuteContractMethodParams<{
        a: bigint;
        b: bigint;
        denominator: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    configPath: {
      params: SignExecuteContractMethodParams<{ configIndex_: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    poolPath: {
      params: SignExecuteContractMethodParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    poolContractId: {
      params: SignExecuteContractMethodParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    positionPath: {
      params: SignExecuteContractMethodParams<{
        o: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    positionContractId: {
      params: SignExecuteContractMethodParams<{
        pool: HexString;
        o: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    increaseLiquidity: {
      params: SignExecuteContractMethodParams<{
        payer: Address;
        p: types.ModifyLiquidityParams;
      }>;
      result: SignExecuteScriptTxResult;
    };
    decreaseLiquidity: {
      params: SignExecuteContractMethodParams<{
        operator: Address;
        liquidity: bigint;
        p: types.DecreaseLiquidityParams;
      }>;
      result: SignExecuteScriptTxResult;
    };
    collect: {
      params: SignExecuteContractMethodParams<{
        operator: Address;
        liquidity: bigint;
        p: types.CollectParams;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getSqrtPricesX96: {
      params: SignExecuteContractMethodParams<{
        pool: HexString;
        owner: Address;
        tickLower: bigint;
        tickUpper: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
  }
  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["params"];
  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["result"];
}

class Factory extends ContractFactory<
  PositionManagerInstance,
  PositionManagerTypes.Fields
> {
  encodeFields(fields: PositionManagerTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      types.AllStructs
    );
  }

  consts = {
    LiquidityManagmentError: {
      MintSlippage: BigInt("850"),
      BurnSlippage: BigInt("851"),
    },
    FullMathError: { MulDivOverflow: BigInt("351") },
    PathPrefixes: {
      Tick: BigInt("0"),
      Position: BigInt("1"),
      Word: BigInt("2"),
    },
  };

  at(address: string): PositionManagerInstance {
    return new PositionManagerInstance(address);
  }

  tests = {
    addLiquidity: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { payer: Address; p: types.ModifyLiquidityParams }
      >
    ): Promise<
      TestContractResultWithoutMaps<[bigint, bigint, bigint, HexString]>
    > => {
      return testMethod(this, "addLiquidity", params, getContractByCodeHash);
    },
    getLiquidityForAmount0: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { sqrtRatioAX96: bigint; sqrtRatioBX96: bigint; amount0: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getLiquidityForAmount0",
        params,
        getContractByCodeHash
      );
    },
    getLiquidityForAmount1: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { sqrtRatioAX96: bigint; sqrtRatioBX96: bigint; amount1: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getLiquidityForAmount1",
        params,
        getContractByCodeHash
      );
    },
    getLiquidityForAmounts: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        {
          sqrtRatioX96: bigint;
          sqrtRatioAX96: bigint;
          sqrtRatioBX96: bigint;
          amount0: bigint;
          amount1: bigint;
        }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getLiquidityForAmounts",
        params,
        getContractByCodeHash
      );
    },
    getAmount0ForLiquidity: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { sqrtRatioAX96: bigint; sqrtRatioBX96: bigint; liquidity: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getAmount0ForLiquidity",
        params,
        getContractByCodeHash
      );
    },
    mulDiv: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { a: bigint; b: bigint; denominator: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "mulDiv", params, getContractByCodeHash);
    },
    mulDivRoundingUp: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { a: bigint; b: bigint; denominator: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "mulDivRoundingUp",
        params,
        getContractByCodeHash
      );
    },
    configPath: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "configPath", params, getContractByCodeHash);
    },
    poolPath: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { factory: HexString; tokens: HexString; configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "poolPath", params, getContractByCodeHash);
    },
    poolContractId: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { factory: HexString; tokens: HexString; configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "poolContractId", params, getContractByCodeHash);
    },
    positionPath: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { o: Address; tickLower: bigint; tickUpper: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "positionPath", params, getContractByCodeHash);
    },
    positionContractId: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { pool: HexString; o: Address; tickLower: bigint; tickUpper: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(
        this,
        "positionContractId",
        params,
        getContractByCodeHash
      );
    },
    increaseLiquidity: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { payer: Address; p: types.ModifyLiquidityParams }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "increaseLiquidity",
        params,
        getContractByCodeHash
      );
    },
    decreaseLiquidity: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        {
          operator: Address;
          liquidity: bigint;
          p: types.DecreaseLiquidityParams;
        }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "decreaseLiquidity",
        params,
        getContractByCodeHash
      );
    },
    collect: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        { operator: Address; liquidity: bigint; p: types.CollectParams }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "collect", params, getContractByCodeHash);
    },
    getSqrtPricesX96: async (
      params: TestContractParamsWithoutMaps<
        PositionManagerTypes.Fields,
        {
          pool: HexString;
          owner: Address;
          tickLower: bigint;
          tickUpper: bigint;
        }
      >
    ): Promise<
      TestContractResultWithoutMaps<[bigint, bigint, bigint, bigint]>
    > => {
      return testMethod(
        this,
        "getSqrtPricesX96",
        params,
        getContractByCodeHash
      );
    },
  };

  stateForTest(
    initFields: PositionManagerTypes.Fields,
    asset?: Asset,
    address?: string
  ) {
    return this.stateForTest_(initFields, asset, address, undefined);
  }
}

// Use this object to test and deploy the contract
export const PositionManager = new Factory(
  Contract.fromJson(
    PositionManagerContractJson,
    "",
    "ab39514b7b087164d46e689fc18e1793c9aa0c677ece80b18439df6526c09698",
    types.AllStructs
  )
);
registerContract(PositionManager);

// Use this class to interact with the blockchain
export class PositionManagerInstance extends ContractInstance {
  constructor(address: Address) {
    super(address);
  }

  async fetchState(): Promise<PositionManagerTypes.State> {
    return fetchContractState(PositionManager, this);
  }

  view = {
    addLiquidity: async (
      params: PositionManagerTypes.CallMethodParams<"addLiquidity">
    ): Promise<PositionManagerTypes.CallMethodResult<"addLiquidity">> => {
      return callMethod(
        PositionManager,
        this,
        "addLiquidity",
        params,
        getContractByCodeHash
      );
    },
    getLiquidityForAmount0: async (
      params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmount0">
    ): Promise<
      PositionManagerTypes.CallMethodResult<"getLiquidityForAmount0">
    > => {
      return callMethod(
        PositionManager,
        this,
        "getLiquidityForAmount0",
        params,
        getContractByCodeHash
      );
    },
    getLiquidityForAmount1: async (
      params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmount1">
    ): Promise<
      PositionManagerTypes.CallMethodResult<"getLiquidityForAmount1">
    > => {
      return callMethod(
        PositionManager,
        this,
        "getLiquidityForAmount1",
        params,
        getContractByCodeHash
      );
    },
    getLiquidityForAmounts: async (
      params: PositionManagerTypes.CallMethodParams<"getLiquidityForAmounts">
    ): Promise<
      PositionManagerTypes.CallMethodResult<"getLiquidityForAmounts">
    > => {
      return callMethod(
        PositionManager,
        this,
        "getLiquidityForAmounts",
        params,
        getContractByCodeHash
      );
    },
    getAmount0ForLiquidity: async (
      params: PositionManagerTypes.CallMethodParams<"getAmount0ForLiquidity">
    ): Promise<
      PositionManagerTypes.CallMethodResult<"getAmount0ForLiquidity">
    > => {
      return callMethod(
        PositionManager,
        this,
        "getAmount0ForLiquidity",
        params,
        getContractByCodeHash
      );
    },
    mulDiv: async (
      params: PositionManagerTypes.CallMethodParams<"mulDiv">
    ): Promise<PositionManagerTypes.CallMethodResult<"mulDiv">> => {
      return callMethod(
        PositionManager,
        this,
        "mulDiv",
        params,
        getContractByCodeHash
      );
    },
    mulDivRoundingUp: async (
      params: PositionManagerTypes.CallMethodParams<"mulDivRoundingUp">
    ): Promise<PositionManagerTypes.CallMethodResult<"mulDivRoundingUp">> => {
      return callMethod(
        PositionManager,
        this,
        "mulDivRoundingUp",
        params,
        getContractByCodeHash
      );
    },
    configPath: async (
      params: PositionManagerTypes.CallMethodParams<"configPath">
    ): Promise<PositionManagerTypes.CallMethodResult<"configPath">> => {
      return callMethod(
        PositionManager,
        this,
        "configPath",
        params,
        getContractByCodeHash
      );
    },
    poolPath: async (
      params: PositionManagerTypes.CallMethodParams<"poolPath">
    ): Promise<PositionManagerTypes.CallMethodResult<"poolPath">> => {
      return callMethod(
        PositionManager,
        this,
        "poolPath",
        params,
        getContractByCodeHash
      );
    },
    poolContractId: async (
      params: PositionManagerTypes.CallMethodParams<"poolContractId">
    ): Promise<PositionManagerTypes.CallMethodResult<"poolContractId">> => {
      return callMethod(
        PositionManager,
        this,
        "poolContractId",
        params,
        getContractByCodeHash
      );
    },
    positionPath: async (
      params: PositionManagerTypes.CallMethodParams<"positionPath">
    ): Promise<PositionManagerTypes.CallMethodResult<"positionPath">> => {
      return callMethod(
        PositionManager,
        this,
        "positionPath",
        params,
        getContractByCodeHash
      );
    },
    positionContractId: async (
      params: PositionManagerTypes.CallMethodParams<"positionContractId">
    ): Promise<PositionManagerTypes.CallMethodResult<"positionContractId">> => {
      return callMethod(
        PositionManager,
        this,
        "positionContractId",
        params,
        getContractByCodeHash
      );
    },
    increaseLiquidity: async (
      params: PositionManagerTypes.CallMethodParams<"increaseLiquidity">
    ): Promise<PositionManagerTypes.CallMethodResult<"increaseLiquidity">> => {
      return callMethod(
        PositionManager,
        this,
        "increaseLiquidity",
        params,
        getContractByCodeHash
      );
    },
    decreaseLiquidity: async (
      params: PositionManagerTypes.CallMethodParams<"decreaseLiquidity">
    ): Promise<PositionManagerTypes.CallMethodResult<"decreaseLiquidity">> => {
      return callMethod(
        PositionManager,
        this,
        "decreaseLiquidity",
        params,
        getContractByCodeHash
      );
    },
    collect: async (
      params: PositionManagerTypes.CallMethodParams<"collect">
    ): Promise<PositionManagerTypes.CallMethodResult<"collect">> => {
      return callMethod(
        PositionManager,
        this,
        "collect",
        params,
        getContractByCodeHash
      );
    },
    getSqrtPricesX96: async (
      params: PositionManagerTypes.CallMethodParams<"getSqrtPricesX96">
    ): Promise<PositionManagerTypes.CallMethodResult<"getSqrtPricesX96">> => {
      return callMethod(
        PositionManager,
        this,
        "getSqrtPricesX96",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    addLiquidity: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"addLiquidity">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"addLiquidity">
    > => {
      return signExecuteMethod(PositionManager, this, "addLiquidity", params);
    },
    getLiquidityForAmount0: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmount0">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmount0">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "getLiquidityForAmount0",
        params
      );
    },
    getLiquidityForAmount1: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmount1">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmount1">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "getLiquidityForAmount1",
        params
      );
    },
    getLiquidityForAmounts: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"getLiquidityForAmounts">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"getLiquidityForAmounts">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "getLiquidityForAmounts",
        params
      );
    },
    getAmount0ForLiquidity: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"getAmount0ForLiquidity">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"getAmount0ForLiquidity">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "getAmount0ForLiquidity",
        params
      );
    },
    mulDiv: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"mulDiv">
    ): Promise<PositionManagerTypes.SignExecuteMethodResult<"mulDiv">> => {
      return signExecuteMethod(PositionManager, this, "mulDiv", params);
    },
    mulDivRoundingUp: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"mulDivRoundingUp">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"mulDivRoundingUp">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "mulDivRoundingUp",
        params
      );
    },
    configPath: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"configPath">
    ): Promise<PositionManagerTypes.SignExecuteMethodResult<"configPath">> => {
      return signExecuteMethod(PositionManager, this, "configPath", params);
    },
    poolPath: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"poolPath">
    ): Promise<PositionManagerTypes.SignExecuteMethodResult<"poolPath">> => {
      return signExecuteMethod(PositionManager, this, "poolPath", params);
    },
    poolContractId: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"poolContractId">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"poolContractId">
    > => {
      return signExecuteMethod(PositionManager, this, "poolContractId", params);
    },
    positionPath: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"positionPath">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"positionPath">
    > => {
      return signExecuteMethod(PositionManager, this, "positionPath", params);
    },
    positionContractId: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"positionContractId">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"positionContractId">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "positionContractId",
        params
      );
    },
    increaseLiquidity: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"increaseLiquidity">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"increaseLiquidity">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "increaseLiquidity",
        params
      );
    },
    decreaseLiquidity: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"decreaseLiquidity">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"decreaseLiquidity">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "decreaseLiquidity",
        params
      );
    },
    collect: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"collect">
    ): Promise<PositionManagerTypes.SignExecuteMethodResult<"collect">> => {
      return signExecuteMethod(PositionManager, this, "collect", params);
    },
    getSqrtPricesX96: async (
      params: PositionManagerTypes.SignExecuteMethodParams<"getSqrtPricesX96">
    ): Promise<
      PositionManagerTypes.SignExecuteMethodResult<"getSqrtPricesX96">
    > => {
      return signExecuteMethod(
        PositionManager,
        this,
        "getSqrtPricesX96",
        params
      );
    },
  };

  async multicall<Calls extends PositionManagerTypes.MultiCallParams>(
    calls: Calls
  ): Promise<PositionManagerTypes.MultiCallResults<Calls>>;
  async multicall<Callss extends PositionManagerTypes.MultiCallParams[]>(
    callss: Narrow<Callss>
  ): Promise<PositionManagerTypes.MulticallReturnType<Callss>>;
  async multicall<
    Callss extends
      | PositionManagerTypes.MultiCallParams
      | PositionManagerTypes.MultiCallParams[]
  >(callss: Callss): Promise<unknown> {
    return await multicallMethods(
      PositionManager,
      this,
      callss,
      getContractByCodeHash
    );
  }
}