/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import type {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import type {
  FunctionFragment,
  Result,
  EventFragment,
} from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type {
  TypedEventFilter,
  TypedEvent,
  TypedListener,
  OnEvent,
} from "./common";

export type EmergencyWithdrawInputStruct = {
  user: string;
  lockId: BigNumberish;
  withdrawAmount: BigNumberish;
};

export type EmergencyWithdrawInputStructOutput = [
  string,
  BigNumber,
  BigNumber
] & { user: string; lockId: BigNumber; withdrawAmount: BigNumber };

export declare namespace IKSULocking {
  export type LockPeriodDetailsStruct = {
    rKSUMultiplier: BigNumberish;
    ksuBonusMultiplier: BigNumberish;
    isActive: boolean;
  };

  export type LockPeriodDetailsStructOutput = [
    BigNumber,
    BigNumber,
    boolean
  ] & {
    rKSUMultiplier: BigNumber;
    ksuBonusMultiplier: BigNumber;
    isActive: boolean;
  };

  export type ERC20PermitPayloadStruct = {
    value: BigNumberish;
    deadline: BigNumberish;
    v: BigNumberish;
    r: BytesLike;
    s: BytesLike;
  };

  export type ERC20PermitPayloadStructOutput = [
    BigNumber,
    BigNumber,
    number,
    string,
    string
  ] & {
    value: BigNumber;
    deadline: BigNumber;
    v: number;
    r: string;
    s: string;
  };

  export type UserLockStruct = {
    amount: BigNumberish;
    rKSUAmount: BigNumberish;
    rKSUMultiplier: BigNumberish;
    startTime: BigNumberish;
    lockPeriod: BigNumberish;
  };

  export type UserLockStructOutput = [
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
  ] & {
    amount: BigNumber;
    rKSUAmount: BigNumber;
    rKSUMultiplier: BigNumber;
    startTime: BigNumber;
    lockPeriod: BigNumber;
  };
}

export interface IKSULockingAbiInterface extends utils.Interface {
  functions: {
    "addLockPeriod(uint256,uint256,uint256)": FunctionFragment;
    "allowance(address,address)": FunctionFragment;
    "approve(address,uint256)": FunctionFragment;
    "balanceOf(address)": FunctionFragment;
    "claimFees()": FunctionFragment;
    "emergencyWithdraw((address,uint256,uint256)[],address)": FunctionFragment;
    "emitFees(uint256)": FunctionFragment;
    "lock(uint256,uint256)": FunctionFragment;
    "lockDetails(uint256)": FunctionFragment;
    "lockWithPermit(uint256,uint256,(uint256,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    "rewards(address)": FunctionFragment;
    "setKSULockBonus(address)": FunctionFragment;
    "totalSupply()": FunctionFragment;
    "transfer(address,uint256)": FunctionFragment;
    "transferFrom(address,address,uint256)": FunctionFragment;
    "unlock(uint256,uint256)": FunctionFragment;
    "userLock(address,uint256)": FunctionFragment;
    "userTotalDeposits(address)": FunctionFragment;
  };

  getFunction(
    nameOrSignatureOrTopic:
      | "addLockPeriod"
      | "allowance"
      | "approve"
      | "balanceOf"
      | "claimFees"
      | "emergencyWithdraw"
      | "emitFees"
      | "lock"
      | "lockDetails"
      | "lockWithPermit"
      | "rewards"
      | "setKSULockBonus"
      | "totalSupply"
      | "transfer"
      | "transferFrom"
      | "unlock"
      | "userLock"
      | "userTotalDeposits"
  ): FunctionFragment;

  encodeFunctionData(
    functionFragment: "addLockPeriod",
    values: [BigNumberish, BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "allowance",
    values: [string, string]
  ): string;
  encodeFunctionData(
    functionFragment: "approve",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(functionFragment: "balanceOf", values: [string]): string;
  encodeFunctionData(functionFragment: "claimFees", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "emergencyWithdraw",
    values: [EmergencyWithdrawInputStruct[], string]
  ): string;
  encodeFunctionData(
    functionFragment: "emitFees",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "lock",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "lockDetails",
    values: [BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "lockWithPermit",
    values: [BigNumberish, BigNumberish, IKSULocking.ERC20PermitPayloadStruct]
  ): string;
  encodeFunctionData(functionFragment: "rewards", values: [string]): string;
  encodeFunctionData(
    functionFragment: "setKSULockBonus",
    values: [string]
  ): string;
  encodeFunctionData(
    functionFragment: "totalSupply",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "transfer",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "transferFrom",
    values: [string, string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "unlock",
    values: [BigNumberish, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "userLock",
    values: [string, BigNumberish]
  ): string;
  encodeFunctionData(
    functionFragment: "userTotalDeposits",
    values: [string]
  ): string;

  decodeFunctionResult(
    functionFragment: "addLockPeriod",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "claimFees", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "emergencyWithdraw",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "emitFees", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "lock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "lockDetails",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "lockWithPermit",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "rewards", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "setKSULockBonus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "totalSupply",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "transferFrom",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "unlock", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "userLock", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "userTotalDeposits",
    data: BytesLike
  ): Result;

  events: {
    "Approval(address,address,uint256)": EventFragment;
    "EmergencyWithdraw(address,uint256,uint256,uint256,address)": EventFragment;
    "FeesClaimed(address,uint256)": EventFragment;
    "FeesEmitted(address,uint256)": EventFragment;
    "LockPeriodAdded(uint256,uint256,uint256)": EventFragment;
    "Transfer(address,address,uint256)": EventFragment;
    "UserLocked(address,uint256,uint256,uint256,uint256,uint256)": EventFragment;
    "UserUnlocked(address,uint256,uint256,uint256)": EventFragment;
  };

  getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "EmergencyWithdraw"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeesClaimed"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "FeesEmitted"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "LockPeriodAdded"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserLocked"): EventFragment;
  getEvent(nameOrSignatureOrTopic: "UserUnlocked"): EventFragment;
}

export interface ApprovalEventObject {
  owner: string;
  spender: string;
  value: BigNumber;
}
export type ApprovalEvent = TypedEvent<
  [string, string, BigNumber],
  ApprovalEventObject
>;

export type ApprovalEventFilter = TypedEventFilter<ApprovalEvent>;

export interface EmergencyWithdrawEventObject {
  user: string;
  lockId: BigNumber;
  ksuAmount: BigNumber;
  rKSUBurned: BigNumber;
  receiver: string;
}
export type EmergencyWithdrawEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, string],
  EmergencyWithdrawEventObject
>;

export type EmergencyWithdrawEventFilter =
  TypedEventFilter<EmergencyWithdrawEvent>;

export interface FeesClaimedEventObject {
  user: string;
  amount: BigNumber;
}
export type FeesClaimedEvent = TypedEvent<
  [string, BigNumber],
  FeesClaimedEventObject
>;

export type FeesClaimedEventFilter = TypedEventFilter<FeesClaimedEvent>;

export interface FeesEmittedEventObject {
  user: string;
  amount: BigNumber;
}
export type FeesEmittedEvent = TypedEvent<
  [string, BigNumber],
  FeesEmittedEventObject
>;

export type FeesEmittedEventFilter = TypedEventFilter<FeesEmittedEvent>;

export interface LockPeriodAddedEventObject {
  lockPeriod: BigNumber;
  rKSUMultiplier: BigNumber;
  ksuBonusMultiplier: BigNumber;
}
export type LockPeriodAddedEvent = TypedEvent<
  [BigNumber, BigNumber, BigNumber],
  LockPeriodAddedEventObject
>;

export type LockPeriodAddedEventFilter = TypedEventFilter<LockPeriodAddedEvent>;

export interface TransferEventObject {
  from: string;
  to: string;
  value: BigNumber;
}
export type TransferEvent = TypedEvent<
  [string, string, BigNumber],
  TransferEventObject
>;

export type TransferEventFilter = TypedEventFilter<TransferEvent>;

export interface UserLockedEventObject {
  user: string;
  lockId: BigNumber;
  lockPeriod: BigNumber;
  ksuAmount: BigNumber;
  ksuBonusAmount: BigNumber;
  rKSUMinted: BigNumber;
}
export type UserLockedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber, BigNumber, BigNumber],
  UserLockedEventObject
>;

export type UserLockedEventFilter = TypedEventFilter<UserLockedEvent>;

export interface UserUnlockedEventObject {
  user: string;
  lockId: BigNumber;
  ksuAmount: BigNumber;
  rKSUBurned: BigNumber;
}
export type UserUnlockedEvent = TypedEvent<
  [string, BigNumber, BigNumber, BigNumber],
  UserUnlockedEventObject
>;

export type UserUnlockedEventFilter = TypedEventFilter<UserUnlockedEvent>;

export interface IKSULockingAbi extends BaseContract {
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: IKSULockingAbiInterface;

  queryFilter<TEvent extends TypedEvent>(
    event: TypedEventFilter<TEvent>,
    fromBlockOrBlockhash?: string | number | undefined,
    toBlock?: string | number | undefined
  ): Promise<Array<TEvent>>;

  listeners<TEvent extends TypedEvent>(
    eventFilter?: TypedEventFilter<TEvent>
  ): Array<TypedListener<TEvent>>;
  listeners(eventName?: string): Array<Listener>;
  removeAllListeners<TEvent extends TypedEvent>(
    eventFilter: TypedEventFilter<TEvent>
  ): this;
  removeAllListeners(eventName?: string): this;
  off: OnEvent<this>;
  on: OnEvent<this>;
  once: OnEvent<this>;
  removeListener: OnEvent<this>;

  functions: {
    addLockPeriod(
      lockPeriod: BigNumberish,
      rKSUMultiplier: BigNumberish,
      ksuBonusMultiplier: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<[BigNumber]>;

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

    emergencyWithdraw(
      emergencyWithdrawInput: EmergencyWithdrawInputStruct[],
      receiver: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    emitFees(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    lock(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    lockDetails(
      lockPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[IKSULocking.LockPeriodDetailsStructOutput]>;

    lockWithPermit(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      ksuPermit: IKSULocking.ERC20PermitPayloadStruct,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    rewards(user: string, overrides?: CallOverrides): Promise<[BigNumber]>;

    setKSULockBonus(
      ksuBonusTokens_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

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

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    unlock(
      amount: BigNumberish,
      userLockId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<ContractTransaction>;

    userLock(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<[IKSULocking.UserLockStructOutput]>;

    userTotalDeposits(
      arg0: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber]>;
  };

  addLockPeriod(
    lockPeriod: BigNumberish,
    rKSUMultiplier: BigNumberish,
    ksuBonusMultiplier: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  allowance(
    owner: string,
    spender: string,
    overrides?: CallOverrides
  ): Promise<BigNumber>;

  approve(
    spender: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

  emergencyWithdraw(
    emergencyWithdrawInput: EmergencyWithdrawInputStruct[],
    receiver: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  emitFees(
    amount: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  lock(
    amount: BigNumberish,
    lockPeriod: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  lockDetails(
    lockPeriod: BigNumberish,
    overrides?: CallOverrides
  ): Promise<IKSULocking.LockPeriodDetailsStructOutput>;

  lockWithPermit(
    amount: BigNumberish,
    lockPeriod: BigNumberish,
    ksuPermit: IKSULocking.ERC20PermitPayloadStruct,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;

  setKSULockBonus(
    ksuBonusTokens_: string,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

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

  transfer(
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  transferFrom(
    from: string,
    to: string,
    value: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  unlock(
    amount: BigNumberish,
    userLockId: BigNumberish,
    overrides?: Overrides & { from?: string }
  ): Promise<ContractTransaction>;

  userLock(
    arg0: string,
    arg1: BigNumberish,
    overrides?: CallOverrides
  ): Promise<IKSULocking.UserLockStructOutput>;

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

  callStatic: {
    addLockPeriod(
      lockPeriod: BigNumberish,
      rKSUMultiplier: BigNumberish,
      ksuBonusMultiplier: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    emergencyWithdraw(
      emergencyWithdrawInput: EmergencyWithdrawInputStruct[],
      receiver: string,
      overrides?: CallOverrides
    ): Promise<void>;

    emitFees(amount: BigNumberish, overrides?: CallOverrides): Promise<void>;

    lock(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lockDetails(
      lockPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<IKSULocking.LockPeriodDetailsStructOutput>;

    lockWithPermit(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      ksuPermit: IKSULocking.ERC20PermitPayloadStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;

    setKSULockBonus(
      ksuBonusTokens_: string,
      overrides?: CallOverrides
    ): Promise<void>;

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

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: CallOverrides
    ): Promise<boolean>;

    unlock(
      amount: BigNumberish,
      userLockId: BigNumberish,
      overrides?: CallOverrides
    ): Promise<void>;

    userLock(
      arg0: string,
      arg1: BigNumberish,
      overrides?: CallOverrides
    ): Promise<IKSULocking.UserLockStructOutput>;

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

  filters: {
    "Approval(address,address,uint256)"(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;
    Approval(
      owner?: string | null,
      spender?: string | null,
      value?: null
    ): ApprovalEventFilter;

    "EmergencyWithdraw(address,uint256,uint256,uint256,address)"(
      user?: string | null,
      lockId?: BigNumberish | null,
      ksuAmount?: null,
      rKSUBurned?: null,
      receiver?: null
    ): EmergencyWithdrawEventFilter;
    EmergencyWithdraw(
      user?: string | null,
      lockId?: BigNumberish | null,
      ksuAmount?: null,
      rKSUBurned?: null,
      receiver?: null
    ): EmergencyWithdrawEventFilter;

    "FeesClaimed(address,uint256)"(
      user?: string | null,
      amount?: null
    ): FeesClaimedEventFilter;
    FeesClaimed(user?: string | null, amount?: null): FeesClaimedEventFilter;

    "FeesEmitted(address,uint256)"(
      user?: string | null,
      amount?: null
    ): FeesEmittedEventFilter;
    FeesEmitted(user?: string | null, amount?: null): FeesEmittedEventFilter;

    "LockPeriodAdded(uint256,uint256,uint256)"(
      lockPeriod?: BigNumberish | null,
      rKSUMultiplier?: null,
      ksuBonusMultiplier?: null
    ): LockPeriodAddedEventFilter;
    LockPeriodAdded(
      lockPeriod?: BigNumberish | null,
      rKSUMultiplier?: null,
      ksuBonusMultiplier?: null
    ): LockPeriodAddedEventFilter;

    "Transfer(address,address,uint256)"(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;
    Transfer(
      from?: string | null,
      to?: string | null,
      value?: null
    ): TransferEventFilter;

    "UserLocked(address,uint256,uint256,uint256,uint256,uint256)"(
      user?: string | null,
      lockId?: BigNumberish | null,
      lockPeriod?: BigNumberish | null,
      ksuAmount?: null,
      ksuBonusAmount?: null,
      rKSUMinted?: null
    ): UserLockedEventFilter;
    UserLocked(
      user?: string | null,
      lockId?: BigNumberish | null,
      lockPeriod?: BigNumberish | null,
      ksuAmount?: null,
      ksuBonusAmount?: null,
      rKSUMinted?: null
    ): UserLockedEventFilter;

    "UserUnlocked(address,uint256,uint256,uint256)"(
      user?: string | null,
      lockId?: BigNumberish | null,
      ksuAmount?: null,
      rKSUBurned?: null
    ): UserUnlockedEventFilter;
    UserUnlocked(
      user?: string | null,
      lockId?: BigNumberish | null,
      ksuAmount?: null,
      rKSUBurned?: null
    ): UserUnlockedEventFilter;
  };

  estimateGas: {
    addLockPeriod(
      lockPeriod: BigNumberish,
      rKSUMultiplier: BigNumberish,
      ksuBonusMultiplier: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    balanceOf(account: string, overrides?: CallOverrides): Promise<BigNumber>;

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

    emergencyWithdraw(
      emergencyWithdrawInput: EmergencyWithdrawInputStruct[],
      receiver: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    emitFees(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    lock(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    lockDetails(
      lockPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    lockWithPermit(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      ksuPermit: IKSULocking.ERC20PermitPayloadStruct,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    rewards(user: string, overrides?: CallOverrides): Promise<BigNumber>;

    setKSULockBonus(
      ksuBonusTokens_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

    unlock(
      amount: BigNumberish,
      userLockId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<BigNumber>;

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

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

  populateTransaction: {
    addLockPeriod(
      lockPeriod: BigNumberish,
      rKSUMultiplier: BigNumberish,
      ksuBonusMultiplier: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    allowance(
      owner: string,
      spender: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    approve(
      spender: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    balanceOf(
      account: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

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

    emergencyWithdraw(
      emergencyWithdrawInput: EmergencyWithdrawInputStruct[],
      receiver: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    emitFees(
      amount: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    lock(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    lockDetails(
      lockPeriod: BigNumberish,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    lockWithPermit(
      amount: BigNumberish,
      lockPeriod: BigNumberish,
      ksuPermit: IKSULocking.ERC20PermitPayloadStruct,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    rewards(
      user: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    setKSULockBonus(
      ksuBonusTokens_: string,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

    transfer(
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    transferFrom(
      from: string,
      to: string,
      value: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

    unlock(
      amount: BigNumberish,
      userLockId: BigNumberish,
      overrides?: Overrides & { from?: string }
    ): Promise<PopulatedTransaction>;

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

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