// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.

import {
  ethereum,
  JSONValue,
  TypedMap,
  Entity,
  Bytes,
  Address,
  BigInt
} from "@graphprotocol/graph-ts";

export class BasketManagerRegistered extends ethereum.Event {
  get params(): BasketManagerRegistered__Params {
    return new BasketManagerRegistered__Params(this);
  }
}

export class BasketManagerRegistered__Params {
  _event: BasketManagerRegistered;

  constructor(event: BasketManagerRegistered) {
    this._event = event;
  }

  get basketId(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get basketManager(): Address {
    return this._event.parameters[1].value.toAddress();
  }
}

export class ControllerSet extends ethereum.Event {
  get params(): ControllerSet__Params {
    return new ControllerSet__Params(this);
  }
}

export class ControllerSet__Params {
  _event: ControllerSet;

  constructor(event: ControllerSet) {
    this._event = event;
  }

  get controllerAddress(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get controllerId(): string {
    return this._event.parameters[1].value.toString();
  }
}

export class Initialized extends ethereum.Event {
  get params(): Initialized__Params {
    return new Initialized__Params(this);
  }
}

export class Initialized__Params {
  _event: Initialized;

  constructor(event: Initialized) {
    this._event = event;
  }

  get initiator(): Address {
    return this._event.parameters[0].value.toAddress();
  }
}

export class OwnershipTransferred extends ethereum.Event {
  get params(): OwnershipTransferred__Params {
    return new OwnershipTransferred__Params(this);
  }
}

export class OwnershipTransferred__Params {
  _event: OwnershipTransferred;

  constructor(event: OwnershipTransferred) {
    this._event = event;
  }

  get previousOwner(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get newOwner(): Address {
    return this._event.parameters[1].value.toAddress();
  }
}

export class WalletManagerRegistered extends ethereum.Event {
  get params(): WalletManagerRegistered__Params {
    return new WalletManagerRegistered__Params(this);
  }
}

export class WalletManagerRegistered__Params {
  _event: WalletManagerRegistered;

  constructor(event: WalletManagerRegistered) {
    this._event = event;
  }

  get walletManagerId(): Bytes {
    return this._event.parameters[0].value.toBytes();
  }

  get walletManager(): Address {
    return this._event.parameters[1].value.toAddress();
  }
}

export class WithdrawStuckERC1155 extends ethereum.Event {
  get params(): WithdrawStuckERC1155__Params {
    return new WithdrawStuckERC1155__Params(this);
  }
}

export class WithdrawStuckERC1155__Params {
  _event: WithdrawStuckERC1155;

  constructor(event: WithdrawStuckERC1155) {
    this._event = event;
  }

  get receiver(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }

  get amount(): BigInt {
    return this._event.parameters[3].value.toBigInt();
  }
}

export class WithdrawStuckERC20 extends ethereum.Event {
  get params(): WithdrawStuckERC20__Params {
    return new WithdrawStuckERC20__Params(this);
  }
}

export class WithdrawStuckERC20__Params {
  _event: WithdrawStuckERC20;

  constructor(event: WithdrawStuckERC20) {
    this._event = event;
  }

  get receiver(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get amount(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }
}

export class WithdrawStuckERC721 extends ethereum.Event {
  get params(): WithdrawStuckERC721__Params {
    return new WithdrawStuckERC721__Params(this);
  }
}

export class WithdrawStuckERC721__Params {
  _event: WithdrawStuckERC721;

  constructor(event: WithdrawStuckERC721) {
    this._event = event;
  }

  get receiver(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._event.parameters[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }
}

export class WithdrawStuckEther extends ethereum.Event {
  get params(): WithdrawStuckEther__Params {
    return new WithdrawStuckEther__Params(this);
  }
}

export class WithdrawStuckEther__Params {
  _event: WithdrawStuckEther;

  constructor(event: WithdrawStuckEther) {
    this._event = event;
  }

  get receiver(): Address {
    return this._event.parameters[0].value.toAddress();
  }

  get amount(): BigInt {
    return this._event.parameters[1].value.toBigInt();
  }
}

export class ChargedManagers extends ethereum.SmartContract {
  static bind(address: Address): ChargedManagers {
    return new ChargedManagers("ChargedManagers", address);
  }

  getBasketManager(basketId: string): Address {
    let result = super.call(
      "getBasketManager",
      "getBasketManager(string):(address)",
      [ethereum.Value.fromString(basketId)]
    );

    return result[0].toAddress();
  }

  try_getBasketManager(basketId: string): ethereum.CallResult<Address> {
    let result = super.tryCall(
      "getBasketManager",
      "getBasketManager(string):(address)",
      [ethereum.Value.fromString(basketId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  getWalletManager(walletManagerId: string): Address {
    let result = super.call(
      "getWalletManager",
      "getWalletManager(string):(address)",
      [ethereum.Value.fromString(walletManagerId)]
    );

    return result[0].toAddress();
  }

  try_getWalletManager(walletManagerId: string): ethereum.CallResult<Address> {
    let result = super.tryCall(
      "getWalletManager",
      "getWalletManager(string):(address)",
      [ethereum.Value.fromString(walletManagerId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }

  isContractOwner(contractAddress: Address, account: Address): boolean {
    let result = super.call(
      "isContractOwner",
      "isContractOwner(address,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromAddress(account)
      ]
    );

    return result[0].toBoolean();
  }

  try_isContractOwner(
    contractAddress: Address,
    account: Address
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isContractOwner",
      "isContractOwner(address,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromAddress(account)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isNftBasketEnabled(basketId: string): boolean {
    let result = super.call(
      "isNftBasketEnabled",
      "isNftBasketEnabled(string):(bool)",
      [ethereum.Value.fromString(basketId)]
    );

    return result[0].toBoolean();
  }

  try_isNftBasketEnabled(basketId: string): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isNftBasketEnabled",
      "isNftBasketEnabled(string):(bool)",
      [ethereum.Value.fromString(basketId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isWalletManagerEnabled(walletManagerId: string): boolean {
    let result = super.call(
      "isWalletManagerEnabled",
      "isWalletManagerEnabled(string):(bool)",
      [ethereum.Value.fromString(walletManagerId)]
    );

    return result[0].toBoolean();
  }

  try_isWalletManagerEnabled(
    walletManagerId: string
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isWalletManagerEnabled",
      "isWalletManagerEnabled(string):(bool)",
      [ethereum.Value.fromString(walletManagerId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  owner(): Address {
    let result = super.call("owner", "owner():(address)", []);

    return result[0].toAddress();
  }

  try_owner(): ethereum.CallResult<Address> {
    let result = super.tryCall("owner", "owner():(address)", []);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toAddress());
  }
}

export class InitializeCall extends ethereum.Call {
  get inputs(): InitializeCall__Inputs {
    return new InitializeCall__Inputs(this);
  }

  get outputs(): InitializeCall__Outputs {
    return new InitializeCall__Outputs(this);
  }
}

export class InitializeCall__Inputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }

  get initiator(): Address {
    return this._call.inputValues[0].value.toAddress();
  }
}

export class InitializeCall__Outputs {
  _call: InitializeCall;

  constructor(call: InitializeCall) {
    this._call = call;
  }
}

export class RegisterBasketManagerCall extends ethereum.Call {
  get inputs(): RegisterBasketManagerCall__Inputs {
    return new RegisterBasketManagerCall__Inputs(this);
  }

  get outputs(): RegisterBasketManagerCall__Outputs {
    return new RegisterBasketManagerCall__Outputs(this);
  }
}

export class RegisterBasketManagerCall__Inputs {
  _call: RegisterBasketManagerCall;

  constructor(call: RegisterBasketManagerCall) {
    this._call = call;
  }

  get basketId(): string {
    return this._call.inputValues[0].value.toString();
  }

  get basketManager(): Address {
    return this._call.inputValues[1].value.toAddress();
  }
}

export class RegisterBasketManagerCall__Outputs {
  _call: RegisterBasketManagerCall;

  constructor(call: RegisterBasketManagerCall) {
    this._call = call;
  }
}

export class RegisterWalletManagerCall extends ethereum.Call {
  get inputs(): RegisterWalletManagerCall__Inputs {
    return new RegisterWalletManagerCall__Inputs(this);
  }

  get outputs(): RegisterWalletManagerCall__Outputs {
    return new RegisterWalletManagerCall__Outputs(this);
  }
}

export class RegisterWalletManagerCall__Inputs {
  _call: RegisterWalletManagerCall;

  constructor(call: RegisterWalletManagerCall) {
    this._call = call;
  }

  get walletManagerId(): string {
    return this._call.inputValues[0].value.toString();
  }

  get walletManager(): Address {
    return this._call.inputValues[1].value.toAddress();
  }
}

export class RegisterWalletManagerCall__Outputs {
  _call: RegisterWalletManagerCall;

  constructor(call: RegisterWalletManagerCall) {
    this._call = call;
  }
}

export class RenounceOwnershipCall extends ethereum.Call {
  get inputs(): RenounceOwnershipCall__Inputs {
    return new RenounceOwnershipCall__Inputs(this);
  }

  get outputs(): RenounceOwnershipCall__Outputs {
    return new RenounceOwnershipCall__Outputs(this);
  }
}

export class RenounceOwnershipCall__Inputs {
  _call: RenounceOwnershipCall;

  constructor(call: RenounceOwnershipCall) {
    this._call = call;
  }
}

export class RenounceOwnershipCall__Outputs {
  _call: RenounceOwnershipCall;

  constructor(call: RenounceOwnershipCall) {
    this._call = call;
  }
}

export class SetControllerCall extends ethereum.Call {
  get inputs(): SetControllerCall__Inputs {
    return new SetControllerCall__Inputs(this);
  }

  get outputs(): SetControllerCall__Outputs {
    return new SetControllerCall__Outputs(this);
  }
}

export class SetControllerCall__Inputs {
  _call: SetControllerCall;

  constructor(call: SetControllerCall) {
    this._call = call;
  }

  get controller(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get controllerId(): string {
    return this._call.inputValues[1].value.toString();
  }
}

export class SetControllerCall__Outputs {
  _call: SetControllerCall;

  constructor(call: SetControllerCall) {
    this._call = call;
  }
}

export class TransferOwnershipCall extends ethereum.Call {
  get inputs(): TransferOwnershipCall__Inputs {
    return new TransferOwnershipCall__Inputs(this);
  }

  get outputs(): TransferOwnershipCall__Outputs {
    return new TransferOwnershipCall__Outputs(this);
  }
}

export class TransferOwnershipCall__Inputs {
  _call: TransferOwnershipCall;

  constructor(call: TransferOwnershipCall) {
    this._call = call;
  }

  get newOwner(): Address {
    return this._call.inputValues[0].value.toAddress();
  }
}

export class TransferOwnershipCall__Outputs {
  _call: TransferOwnershipCall;

  constructor(call: TransferOwnershipCall) {
    this._call = call;
  }
}

export class ValidateBreakBondCall extends ethereum.Call {
  get inputs(): ValidateBreakBondCall__Inputs {
    return new ValidateBreakBondCall__Inputs(this);
  }

  get outputs(): ValidateBreakBondCall__Outputs {
    return new ValidateBreakBondCall__Outputs(this);
  }
}

export class ValidateBreakBondCall__Inputs {
  _call: ValidateBreakBondCall;

  constructor(call: ValidateBreakBondCall) {
    this._call = call;
  }

  get sender(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get contractAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class ValidateBreakBondCall__Outputs {
  _call: ValidateBreakBondCall;

  constructor(call: ValidateBreakBondCall) {
    this._call = call;
  }
}

export class ValidateDepositCall extends ethereum.Call {
  get inputs(): ValidateDepositCall__Inputs {
    return new ValidateDepositCall__Inputs(this);
  }

  get outputs(): ValidateDepositCall__Outputs {
    return new ValidateDepositCall__Outputs(this);
  }
}

export class ValidateDepositCall__Inputs {
  _call: ValidateDepositCall;

  constructor(call: ValidateDepositCall) {
    this._call = call;
  }

  get sender(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get contractAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }

  get walletManagerId(): string {
    return this._call.inputValues[3].value.toString();
  }

  get assetToken(): Address {
    return this._call.inputValues[4].value.toAddress();
  }

  get assetAmount(): BigInt {
    return this._call.inputValues[5].value.toBigInt();
  }
}

export class ValidateDepositCall__Outputs {
  _call: ValidateDepositCall;

  constructor(call: ValidateDepositCall) {
    this._call = call;
  }
}

export class ValidateDischargeCall extends ethereum.Call {
  get inputs(): ValidateDischargeCall__Inputs {
    return new ValidateDischargeCall__Inputs(this);
  }

  get outputs(): ValidateDischargeCall__Outputs {
    return new ValidateDischargeCall__Outputs(this);
  }
}

export class ValidateDischargeCall__Inputs {
  _call: ValidateDischargeCall;

  constructor(call: ValidateDischargeCall) {
    this._call = call;
  }

  get sender(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get contractAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class ValidateDischargeCall__Outputs {
  _call: ValidateDischargeCall;

  constructor(call: ValidateDischargeCall) {
    this._call = call;
  }
}

export class ValidateNftDepositCall extends ethereum.Call {
  get inputs(): ValidateNftDepositCall__Inputs {
    return new ValidateNftDepositCall__Inputs(this);
  }

  get outputs(): ValidateNftDepositCall__Outputs {
    return new ValidateNftDepositCall__Outputs(this);
  }
}

export class ValidateNftDepositCall__Inputs {
  _call: ValidateNftDepositCall;

  constructor(call: ValidateNftDepositCall) {
    this._call = call;
  }

  get sender(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get contractAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }

  get basketManagerId(): string {
    return this._call.inputValues[3].value.toString();
  }

  get nftTokenAddress(): Address {
    return this._call.inputValues[4].value.toAddress();
  }

  get nftTokenId(): BigInt {
    return this._call.inputValues[5].value.toBigInt();
  }

  get nftTokenAmount(): BigInt {
    return this._call.inputValues[6].value.toBigInt();
  }
}

export class ValidateNftDepositCall__Outputs {
  _call: ValidateNftDepositCall;

  constructor(call: ValidateNftDepositCall) {
    this._call = call;
  }
}

export class ValidateReleaseCall extends ethereum.Call {
  get inputs(): ValidateReleaseCall__Inputs {
    return new ValidateReleaseCall__Inputs(this);
  }

  get outputs(): ValidateReleaseCall__Outputs {
    return new ValidateReleaseCall__Outputs(this);
  }
}

export class ValidateReleaseCall__Inputs {
  _call: ValidateReleaseCall;

  constructor(call: ValidateReleaseCall) {
    this._call = call;
  }

  get sender(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get contractAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class ValidateReleaseCall__Outputs {
  _call: ValidateReleaseCall;

  constructor(call: ValidateReleaseCall) {
    this._call = call;
  }
}

export class WithdrawERC1155Call extends ethereum.Call {
  get inputs(): WithdrawERC1155Call__Inputs {
    return new WithdrawERC1155Call__Inputs(this);
  }

  get outputs(): WithdrawERC1155Call__Outputs {
    return new WithdrawERC1155Call__Outputs(this);
  }
}

export class WithdrawERC1155Call__Inputs {
  _call: WithdrawERC1155Call;

  constructor(call: WithdrawERC1155Call) {
    this._call = call;
  }

  get receiver(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }

  get amount(): BigInt {
    return this._call.inputValues[3].value.toBigInt();
  }
}

export class WithdrawERC1155Call__Outputs {
  _call: WithdrawERC1155Call;

  constructor(call: WithdrawERC1155Call) {
    this._call = call;
  }
}

export class WithdrawERC721Call extends ethereum.Call {
  get inputs(): WithdrawERC721Call__Inputs {
    return new WithdrawERC721Call__Inputs(this);
  }

  get outputs(): WithdrawERC721Call__Outputs {
    return new WithdrawERC721Call__Outputs(this);
  }
}

export class WithdrawERC721Call__Inputs {
  _call: WithdrawERC721Call;

  constructor(call: WithdrawERC721Call) {
    this._call = call;
  }

  get receiver(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get tokenId(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class WithdrawERC721Call__Outputs {
  _call: WithdrawERC721Call;

  constructor(call: WithdrawERC721Call) {
    this._call = call;
  }
}

export class WithdrawErc20Call extends ethereum.Call {
  get inputs(): WithdrawErc20Call__Inputs {
    return new WithdrawErc20Call__Inputs(this);
  }

  get outputs(): WithdrawErc20Call__Outputs {
    return new WithdrawErc20Call__Outputs(this);
  }
}

export class WithdrawErc20Call__Inputs {
  _call: WithdrawErc20Call;

  constructor(call: WithdrawErc20Call) {
    this._call = call;
  }

  get receiver(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get tokenAddress(): Address {
    return this._call.inputValues[1].value.toAddress();
  }

  get amount(): BigInt {
    return this._call.inputValues[2].value.toBigInt();
  }
}

export class WithdrawErc20Call__Outputs {
  _call: WithdrawErc20Call;

  constructor(call: WithdrawErc20Call) {
    this._call = call;
  }
}

export class WithdrawEtherCall extends ethereum.Call {
  get inputs(): WithdrawEtherCall__Inputs {
    return new WithdrawEtherCall__Inputs(this);
  }

  get outputs(): WithdrawEtherCall__Outputs {
    return new WithdrawEtherCall__Outputs(this);
  }
}

export class WithdrawEtherCall__Inputs {
  _call: WithdrawEtherCall;

  constructor(call: WithdrawEtherCall) {
    this._call = call;
  }

  get receiver(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

  get amount(): BigInt {
    return this._call.inputValues[1].value.toBigInt();
  }
}

export class WithdrawEtherCall__Outputs {
  _call: WithdrawEtherCall;

  constructor(call: WithdrawEtherCall) {
    this._call = call;
  }
}