/* 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 IStabilityPoolInterface extends ethers.utils.Interface {
  functions: {
    "DECIMAL_PRECISION()": FunctionFragment;
    "P()": FunctionFragment;
    "SCALE_FACTOR()": FunctionFragment;
    "SUNSET_DURATION()": FunctionFragment;
    "claimableReward(address)": FunctionFragment;
    "currentEpoch()": FunctionFragment;
    "currentScale()": FunctionFragment;
    "depositSnapshots(address)": FunctionFragment;
    "depositSums(address,uint256)": FunctionFragment;
    "enableCollateral(address)": FunctionFragment;
    "epochToScaleToG(uint128,uint128)": FunctionFragment;
    "epochToScaleToSums(uint128,uint128,uint256)": FunctionFragment;
    "factory()": FunctionFragment;
    "getCompoundedDeposit(address)": FunctionFragment;
    "getDepositorCollateralGain(address)": FunctionFragment;
    "getTotalPropelUSDDeposits()": FunctionFragment;
    "lastDebtLossError_Offset()": FunctionFragment;
    "lastEsPropelError()": FunctionFragment;
    "liquidationManager()": FunctionFragment;
    "offset(address,uint256,uint256)": FunctionFragment;
    "provideToSP(uint256)": FunctionFragment;
    "startCollateralSunset(address)": FunctionFragment;
    "withdrawFromSP(uint256)": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "DECIMAL_PRECISION",
    values?: undefined
  ): string;
  encodeFunctionData(functionFragment: "P", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "SCALE_FACTOR",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "SUNSET_DURATION",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "claimableReward",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "currentEpoch",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "currentScale",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "depositSnapshots",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "depositSums",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "enableCollateral",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "epochToScaleToG",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "epochToScaleToSums",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "factory", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "getCompoundedDeposit",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getDepositorCollateralGain",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "getTotalPropelUSDDeposits",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lastDebtLossError_Offset",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "lastEsPropelError",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "liquidationManager",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "offset",
    values: [string, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "provideToSP",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "startCollateralSunset",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "withdrawFromSP",
    values: [BigNumberish]
  ): string;

  decodeFunctionResult(
    functionFragment: "DECIMAL_PRECISION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "P", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "SCALE_FACTOR",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "SUNSET_DURATION",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "claimableReward",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentEpoch",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "currentScale",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositSnapshots",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "depositSums",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "enableCollateral",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "epochToScaleToG",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "epochToScaleToSums",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "factory", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getCompoundedDeposit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getDepositorCollateralGain",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getTotalPropelUSDDeposits",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastDebtLossError_Offset",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lastEsPropelError",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "liquidationManager",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "offset", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "provideToSP",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "startCollateralSunset",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "withdrawFromSP",
    data: BytesLike
  ): Result;

  events: {
    "CollateralGainWithdrawn(address,uint256[])": EventFragment;
    "CollateralOverwritten(address,address)": EventFragment;
    "DepositSnapshotUpdated(address,uint256,uint256)": EventFragment;
    "EpochUpdated(uint128)": EventFragment;
    "G_Updated(uint256,uint128,uint128)": EventFragment;
    "P_Updated(uint256)": EventFragment;
    "RewardClaimed(address,address,uint256)": EventFragment;
    "S_Updated(uint256,uint256,uint128,uint128)": EventFragment;
    "ScaleUpdated(uint128)": EventFragment;
    "StabilityPoolPropelUSDBalanceUpdated(uint256)": EventFragment;
    "UserDepositChanged(address,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "CollateralGainWithdrawn"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "CollateralOverwritten"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "DepositSnapshotUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EpochUpdated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "G_Updated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "P_Updated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "RewardClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "S_Updated"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "ScaleUpdated"): EventFragment;
  getEvent(
    nameOrSignatureOrTopic: "StabilityPoolPropelUSDBalanceUpdated"
  ): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserDepositChanged"): EventFragment;
}

export type CollateralGainWithdrawnEvent = TypedEvent<
  [string, BigNumber[]] & { _depositor: string; _collateral: BigNumber[] }
>;

export type CollateralOverwrittenEvent = TypedEvent<
  [string, string] & { oldCollateral: string; newCollateral: string }
>;

export type DepositSnapshotUpdatedEvent = TypedEvent<
  [string, BigNumber, BigNumber] & {
    _depositor: string;
    _P: BigNumber;
    _G: BigNumber;
  }
>;

export type EpochUpdatedEvent = TypedEvent<
  [BigNumber] & { _currentEpoch: BigNumber }
>;

export type G_UpdatedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber] & {
    _G: BigNumber;
    _epoch: BigNumber;
    _scale: BigNumber;
  }
>;

export type P_UpdatedEvent = TypedEvent<[BigNumber] & { _P: BigNumber }>;

export type RewardClaimedEvent = TypedEvent<
  [string, string, BigNumber] & {
    account: string;
    recipient: string;
    claimed: BigNumber;
  }
>;

export type S_UpdatedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber, BigNumber] & {
    idx: BigNumber;
    _S: BigNumber;
    _epoch: BigNumber;
    _scale: BigNumber;
  }
>;

export type ScaleUpdatedEvent = TypedEvent<
  [BigNumber] & { _currentScale: BigNumber }
>;

export type StabilityPoolPropelUSDBalanceUpdatedEvent = TypedEvent<
  [BigNumber] & { _newBalance: BigNumber }
>;

export type UserDepositChangedEvent = TypedEvent<
  [string, BigNumber] & { _depositor: string; _newDeposit: BigNumber }
>;

export class IStabilityPool 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: IStabilityPoolInterface;

  functions: {
    DECIMAL_PRECISION(overrides?: CallOverrides): Promise<[BigNumber]>;

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

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

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

    claimableReward(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

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

    depositSnapshots(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        P: BigNumber;
        G: BigNumber;
        scale: BigNumber;
        epoch: BigNumber;
      }
    >;

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

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

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

    epochToScaleToSums(
      arg0: BigNumberish,
      arg1: BigNumberish,
      arg2: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

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

    getCompoundedDeposit(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    getDepositorCollateralGain(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber[]] & { collateralGains: BigNumber[] }>;

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

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

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

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

    offset(
      collateral: string,
      _debtToOffset: BigNumberish,
      _collToAdd: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    provideToSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

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

    withdrawFromSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

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

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

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

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

  claimableReward(
    _depositor: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

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

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

  depositSnapshots(
    arg0: string,
    overrides?: CallOverrides
  ): Promise<
    [BigNumber, BigNumber, BigNumber, BigNumber] & {
      P: BigNumber;
      G: BigNumber;
      scale: BigNumber;
      epoch: BigNumber;
    }
  >;

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

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

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

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

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

  getCompoundedDeposit(
    _depositor: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  getDepositorCollateralGain(
    _depositor: string,
    overrides?: CallOverrides
  ): Promise<BigNumber[]>;

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

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

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

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

  offset(
    collateral: string,
    _debtToOffset: BigNumberish,
    _collToAdd: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  provideToSP(
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

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

  withdrawFromSP(
    _amount: BigNumberish,
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    DECIMAL_PRECISION(overrides?: CallOverrides): Promise<BigNumber>;

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

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

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

    claimableReward(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    depositSnapshots(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<
      [BigNumber, BigNumber, BigNumber, BigNumber] & {
        P: BigNumber;
        G: BigNumber;
        scale: BigNumber;
        epoch: BigNumber;
      }
    >;

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

    enableCollateral(
      _collateral: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

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

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

    getCompoundedDeposit(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDepositorCollateralGain(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber[]>;

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

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

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

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

    offset(
      collateral: string,
      _debtToOffset: BigNumberish,
      _collToAdd: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    provideToSP(
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    startCollateralSunset(
      collateral: string,
      overrides?: CallOverrides
    ): Promise<void>;

    withdrawFromSP(
      _amount: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;
  };

  filters: {
    "CollateralGainWithdrawn(address,uint256[])"(
      _depositor?: string | null,
      _collateral?: null
    ): TypedEventFilter<
      [string, BigNumber[]],
      { _depositor: string; _collateral: BigNumber[] }
    >;

    CollateralGainWithdrawn(
      _depositor?: string | null,
      _collateral?: null
    ): TypedEventFilter<
      [string, BigNumber[]],
      { _depositor: string; _collateral: BigNumber[] }
    >;

    "CollateralOverwritten(address,address)"(
      oldCollateral?: null,
      newCollateral?: null
    ): TypedEventFilter<
      [string, string],
      { oldCollateral: string; newCollateral: string }
    >;

    CollateralOverwritten(
      oldCollateral?: null,
      newCollateral?: null
    ): TypedEventFilter<
      [string, string],
      { oldCollateral: string; newCollateral: string }
    >;

    "DepositSnapshotUpdated(address,uint256,uint256)"(
      _depositor?: string | null,
      _P?: null,
      _G?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { _depositor: string; _P: BigNumber; _G: BigNumber }
    >;

    DepositSnapshotUpdated(
      _depositor?: string | null,
      _P?: null,
      _G?: null
    ): TypedEventFilter<
      [string, BigNumber, BigNumber],
      { _depositor: string; _P: BigNumber; _G: BigNumber }
    >;

    "EpochUpdated(uint128)"(
      _currentEpoch?: null
    ): TypedEventFilter<[BigNumber], { _currentEpoch: BigNumber }>;

    EpochUpdated(
      _currentEpoch?: null
    ): TypedEventFilter<[BigNumber], { _currentEpoch: BigNumber }>;

    "G_Updated(uint256,uint128,uint128)"(
      _G?: null,
      _epoch?: null,
      _scale?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      { _G: BigNumber; _epoch: BigNumber; _scale: BigNumber }
    >;

    G_Updated(
      _G?: null,
      _epoch?: null,
      _scale?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber],
      { _G: BigNumber; _epoch: BigNumber; _scale: BigNumber }
    >;

    "P_Updated(uint256)"(
      _P?: null
    ): TypedEventFilter<[BigNumber], { _P: BigNumber }>;

    P_Updated(_P?: null): TypedEventFilter<[BigNumber], { _P: BigNumber }>;

    "RewardClaimed(address,address,uint256)"(
      account?: string | null,
      recipient?: string | null,
      claimed?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { account: string; recipient: string; claimed: BigNumber }
    >;

    RewardClaimed(
      account?: string | null,
      recipient?: string | null,
      claimed?: null
    ): TypedEventFilter<
      [string, string, BigNumber],
      { account: string; recipient: string; claimed: BigNumber }
    >;

    "S_Updated(uint256,uint256,uint128,uint128)"(
      idx?: null,
      _S?: null,
      _epoch?: null,
      _scale?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      { idx: BigNumber; _S: BigNumber; _epoch: BigNumber; _scale: BigNumber }
    >;

    S_Updated(
      idx?: null,
      _S?: null,
      _epoch?: null,
      _scale?: null
    ): TypedEventFilter<
      [BigNumber, BigNumber, BigNumber, BigNumber],
      { idx: BigNumber; _S: BigNumber; _epoch: BigNumber; _scale: BigNumber }
    >;

    "ScaleUpdated(uint128)"(
      _currentScale?: null
    ): TypedEventFilter<[BigNumber], { _currentScale: BigNumber }>;

    ScaleUpdated(
      _currentScale?: null
    ): TypedEventFilter<[BigNumber], { _currentScale: BigNumber }>;

    "StabilityPoolPropelUSDBalanceUpdated(uint256)"(
      _newBalance?: null
    ): TypedEventFilter<[BigNumber], { _newBalance: BigNumber }>;

    StabilityPoolPropelUSDBalanceUpdated(
      _newBalance?: null
    ): TypedEventFilter<[BigNumber], { _newBalance: BigNumber }>;

    "UserDepositChanged(address,uint256)"(
      _depositor?: string | null,
      _newDeposit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _depositor: string; _newDeposit: BigNumber }
    >;

    UserDepositChanged(
      _depositor?: string | null,
      _newDeposit?: null
    ): TypedEventFilter<
      [string, BigNumber],
      { _depositor: string; _newDeposit: BigNumber }
    >;
  };

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

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

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

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

    claimableReward(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

    depositSnapshots(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

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

    getCompoundedDeposit(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getDepositorCollateralGain(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

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

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

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

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

    offset(
      collateral: string,
      _debtToOffset: BigNumberish,
      _collToAdd: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    provideToSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

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

    withdrawFromSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

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

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

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

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

    claimableReward(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

    depositSnapshots(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

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

    getCompoundedDeposit(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getDepositorCollateralGain(
      _depositor: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

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

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

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

    offset(
      collateral: string,
      _debtToOffset: BigNumberish,
      _collToAdd: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    provideToSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

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

    withdrawFromSP(
      _amount: BigNumberish,
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}