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

import {
  ethers,
  EventFilter,
  Signer,
  BigNumber,
  BigNumberish,
  PopulatedTransaction,
} from "ethers";
import {
  Contract,
  ContractTransaction,
  Overrides,
  CallOverrides,
} from "@ethersproject/contracts";
import { BytesLike } from "@ethersproject/bytes";
import { Listener, Provider } from "@ethersproject/providers";
import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";

interface OracleTestInterface extends ethers.utils.Interface {
  functions: {
    "advanceTime(uint32)": FunctionFragment;
    "batchUpdate(tuple[])": FunctionFragment;
    "cardinality()": FunctionFragment;
    "cardinalityNext()": FunctionFragment;
    "getGasCostOfObserve(uint32[])": FunctionFragment;
    "grow(uint16)": FunctionFragment;
    "index()": FunctionFragment;
    "initialize(tuple)": FunctionFragment;
    "liquidity()": FunctionFragment;
    "observations(uint256)": FunctionFragment;
    "observe(uint32[])": FunctionFragment;
    "tick()": FunctionFragment;
    "time()": FunctionFragment;
    "update(tuple)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "advanceTime",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "batchUpdate",
    values: [
      {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "cardinality",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "cardinalityNext",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "getGasCostOfObserve",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "grow", values: [BigNumberish]): string;
  encodeFunctionData(functionFragment: "index", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "initialize",
    values: [
      { time: BigNumberish; tick: BigNumberish; liquidity: BigNumberish }
    ]
  ): string;
  encodeFunctionData(functionFragment: "liquidity", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "observations",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "observe",
    values: [BigNumberish[]]
  ): string;
  encodeFunctionData(functionFragment: "tick", values?: undefined): string;
  encodeFunctionData(functionFragment: "time", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "update",
    values: [
      {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }
    ]
  ): string;

  decodeFunctionResult(
    functionFragment: "advanceTime",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "batchUpdate",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cardinality",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "cardinalityNext",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getGasCostOfObserve",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "grow", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "index", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "liquidity", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "observations",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "observe", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "tick", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "time", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "update", data: BytesLike): Result;

  events: {};
}

export class OracleTest extends Contract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  on(event: EventFilter | string, listener: Listener): this;
  once(event: EventFilter | string, listener: Listener): this;
  addListener(eventName: EventFilter | string, listener: Listener): this;
  removeAllListeners(eventName: EventFilter | string): this;
  removeListener(eventName: any, listener: Listener): this;

  interface: OracleTestInterface;

  functions: {
    advanceTime(
      by: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "advanceTime(uint32)"(
      by: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    batchUpdate(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "batchUpdate(tuple[])"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    cardinality(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    "cardinality()"(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    cardinalityNext(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    "cardinalityNext()"(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    getGasCostOfObserve(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    "getGasCostOfObserve(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      0: BigNumber;
    }>;

    grow(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "grow(uint16)"(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    index(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    "index()"(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    initialize(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "initialize((uint32,int24,uint128))"(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    liquidity(overrides?: CallOverrides): Promise<{
      0: BigNumber;
    }>;

    "liquidity()"(overrides?: CallOverrides): Promise<{
      0: BigNumber;
    }>;

    observations(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      blockTimestamp: number;
      tickCumulative: BigNumber;
      secondsPerLiquidityCumulativeX128: BigNumber;
      initialized: boolean;
      0: number;
      1: BigNumber;
      2: BigNumber;
      3: boolean;
    }>;

    "observations(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      blockTimestamp: number;
      tickCumulative: BigNumber;
      secondsPerLiquidityCumulativeX128: BigNumber;
      initialized: boolean;
      0: number;
      1: BigNumber;
      2: BigNumber;
      3: boolean;
    }>;

    observe(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      tickCumulatives: BigNumber[];
      secondsPerLiquidityCumulativeX128s: BigNumber[];
      0: BigNumber[];
      1: BigNumber[];
    }>;

    "observe(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      tickCumulatives: BigNumber[];
      secondsPerLiquidityCumulativeX128s: BigNumber[];
      0: BigNumber[];
      1: BigNumber[];
    }>;

    tick(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    "tick()"(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    time(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    "time()"(overrides?: CallOverrides): Promise<{
      0: number;
    }>;

    update(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;

    "update((uint32,int24,uint128))"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<ContractTransaction>;
  };

  advanceTime(
    by: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "advanceTime(uint32)"(
    by: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  batchUpdate(
    params: {
      advanceTimeBy: BigNumberish;
      tick: BigNumberish;
      liquidity: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "batchUpdate(tuple[])"(
    params: {
      advanceTimeBy: BigNumberish;
      tick: BigNumberish;
      liquidity: BigNumberish;
    }[],
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  cardinality(overrides?: CallOverrides): Promise<number>;

  "cardinality()"(overrides?: CallOverrides): Promise<number>;

  cardinalityNext(overrides?: CallOverrides): Promise<number>;

  "cardinalityNext()"(overrides?: CallOverrides): Promise<number>;

  getGasCostOfObserve(
    secondsAgos: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  "getGasCostOfObserve(uint32[])"(
    secondsAgos: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  grow(
    _cardinalityNext: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "grow(uint16)"(
    _cardinalityNext: BigNumberish,
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  index(overrides?: CallOverrides): Promise<number>;

  "index()"(overrides?: CallOverrides): Promise<number>;

  initialize(
    params: { time: BigNumberish; tick: BigNumberish; liquidity: BigNumberish },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "initialize((uint32,int24,uint128))"(
    params: { time: BigNumberish; tick: BigNumberish; liquidity: BigNumberish },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

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

  "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

  observations(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<{
    blockTimestamp: number;
    tickCumulative: BigNumber;
    secondsPerLiquidityCumulativeX128: BigNumber;
    initialized: boolean;
    0: number;
    1: BigNumber;
    2: BigNumber;
    3: boolean;
  }>;

  "observations(uint256)"(
    arg0: BigNumberish,
    overrides?: CallOverrides
  ): Promise<{
    blockTimestamp: number;
    tickCumulative: BigNumber;
    secondsPerLiquidityCumulativeX128: BigNumber;
    initialized: boolean;
    0: number;
    1: BigNumber;
    2: BigNumber;
    3: boolean;
  }>;

  observe(
    secondsAgos: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<{
    tickCumulatives: BigNumber[];
    secondsPerLiquidityCumulativeX128s: BigNumber[];
    0: BigNumber[];
    1: BigNumber[];
  }>;

  "observe(uint32[])"(
    secondsAgos: BigNumberish[],
    overrides?: CallOverrides
  ): Promise<{
    tickCumulatives: BigNumber[];
    secondsPerLiquidityCumulativeX128s: BigNumber[];
    0: BigNumber[];
    1: BigNumber[];
  }>;

  tick(overrides?: CallOverrides): Promise<number>;

  "tick()"(overrides?: CallOverrides): Promise<number>;

  time(overrides?: CallOverrides): Promise<number>;

  "time()"(overrides?: CallOverrides): Promise<number>;

  update(
    params: {
      advanceTimeBy: BigNumberish;
      tick: BigNumberish;
      liquidity: BigNumberish;
    },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  "update((uint32,int24,uint128))"(
    params: {
      advanceTimeBy: BigNumberish;
      tick: BigNumberish;
      liquidity: BigNumberish;
    },
    overrides?: Overrides
  ): Promise<ContractTransaction>;

  callStatic: {
    advanceTime(by: BigNumberish, overrides?: CallOverrides): Promise<void>;

    "advanceTime(uint32)"(
      by: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    batchUpdate(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    "batchUpdate(tuple[])"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: CallOverrides
    ): Promise<void>;

    cardinality(overrides?: CallOverrides): Promise<number>;

    "cardinality()"(overrides?: CallOverrides): Promise<number>;

    cardinalityNext(overrides?: CallOverrides): Promise<number>;

    "cardinalityNext()"(overrides?: CallOverrides): Promise<number>;

    getGasCostOfObserve(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getGasCostOfObserve(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grow(
      _cardinalityNext: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    "grow(uint16)"(
      _cardinalityNext: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    index(overrides?: CallOverrides): Promise<number>;

    "index()"(overrides?: CallOverrides): Promise<number>;

    initialize(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    "initialize((uint32,int24,uint128))"(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

    observations(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      blockTimestamp: number;
      tickCumulative: BigNumber;
      secondsPerLiquidityCumulativeX128: BigNumber;
      initialized: boolean;
      0: number;
      1: BigNumber;
      2: BigNumber;
      3: boolean;
    }>;

    "observations(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<{
      blockTimestamp: number;
      tickCumulative: BigNumber;
      secondsPerLiquidityCumulativeX128: BigNumber;
      initialized: boolean;
      0: number;
      1: BigNumber;
      2: BigNumber;
      3: boolean;
    }>;

    observe(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      tickCumulatives: BigNumber[];
      secondsPerLiquidityCumulativeX128s: BigNumber[];
      0: BigNumber[];
      1: BigNumber[];
    }>;

    "observe(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<{
      tickCumulatives: BigNumber[];
      secondsPerLiquidityCumulativeX128s: BigNumber[];
      0: BigNumber[];
      1: BigNumber[];
    }>;

    tick(overrides?: CallOverrides): Promise<number>;

    "tick()"(overrides?: CallOverrides): Promise<number>;

    time(overrides?: CallOverrides): Promise<number>;

    "time()"(overrides?: CallOverrides): Promise<number>;

    update(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;

    "update((uint32,int24,uint128))"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {};

  estimateGas: {
    advanceTime(by: BigNumberish, overrides?: Overrides): Promise<BigNumber>;

    "advanceTime(uint32)"(
      by: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    batchUpdate(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

    "batchUpdate(tuple[])"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "cardinality()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "cardinalityNext()"(overrides?: CallOverrides): Promise<BigNumber>;

    getGasCostOfObserve(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "getGasCostOfObserve(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    grow(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

    "grow(uint16)"(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "index()"(overrides?: CallOverrides): Promise<BigNumber>;

    initialize(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<BigNumber>;

    "initialize((uint32,int24,uint128))"(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<BigNumber>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "observations(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    observe(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    "observe(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

    "tick()"(overrides?: CallOverrides): Promise<BigNumber>;

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

    "time()"(overrides?: CallOverrides): Promise<BigNumber>;

    update(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<BigNumber>;

    "update((uint32,int24,uint128))"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    advanceTime(
      by: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "advanceTime(uint32)"(
      by: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    batchUpdate(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "batchUpdate(tuple[])"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      }[],
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "cardinality()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "cardinalityNext()"(
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getGasCostOfObserve(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "getGasCostOfObserve(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    grow(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "grow(uint16)"(
      _cardinalityNext: BigNumberish,
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "index()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    initialize(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "initialize((uint32,int24,uint128))"(
      params: {
        time: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

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

    "liquidity()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "observations(uint256)"(
      arg0: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    observe(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    "observe(uint32[])"(
      secondsAgos: BigNumberish[],
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    "tick()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

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

    "time()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    update(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;

    "update((uint32,int24,uint128))"(
      params: {
        advanceTimeBy: BigNumberish;
        tick: BigNumberish;
        liquidity: BigNumberish;
      },
      overrides?: Overrides
    ): Promise<PopulatedTransaction>;
  };
}