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

import {
  EthereumCall,
  EthereumEvent,
  SmartContract,
  EthereumValue,
  JSONValue,
  TypedMap,
  Entity,
  EthereumTuple,
  Bytes,
  Address,
  BigInt,
  CallResult
} from "@graphprotocol/graph-ts";

export class AllocationStrategyChanged extends EthereumEvent {
  get params(): AllocationStrategyChanged__Params {
    return new AllocationStrategyChanged__Params(this);
  }
}

export class AllocationStrategyChanged__Params {
  _event: AllocationStrategyChanged;

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

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

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

export class Approval extends EthereumEvent {
  get params(): Approval__Params {
    return new Approval__Params(this);
  }
}

export class Approval__Params {
  _event: Approval;

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

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

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

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

export class CodeUpdated extends EthereumEvent {
  get params(): CodeUpdated__Params {
    return new CodeUpdated__Params(this);
  }
}

export class CodeUpdated__Params {
  _event: CodeUpdated;

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

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

export class HatChanged extends EthereumEvent {
  get params(): HatChanged__Params {
    return new HatChanged__Params(this);
  }
}

export class HatChanged__Params {
  _event: HatChanged;

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

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

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

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

export class HatCreated extends EthereumEvent {
  get params(): HatCreated__Params {
    return new HatCreated__Params(this);
  }
}

export class HatCreated__Params {
  _event: HatCreated;

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

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

export class InterestPaid extends EthereumEvent {
  get params(): InterestPaid__Params {
    return new InterestPaid__Params(this);
  }
}

export class InterestPaid__Params {
  _event: InterestPaid;

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

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

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

export class LoansTransferred extends EthereumEvent {
  get params(): LoansTransferred__Params {
    return new LoansTransferred__Params(this);
  }
}

export class LoansTransferred__Params {
  _event: LoansTransferred;

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

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

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

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

  get isDistribution(): boolean {
    return this._event.parameters[3].value.toBoolean();
  }

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

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

export class OwnershipTransferred extends EthereumEvent {
  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 Transfer extends EthereumEvent {
  get params(): Transfer__Params {
    return new Transfer__Params(this);
  }
}

export class Transfer__Params {
  _event: Transfer;

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

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

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

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

export class RToken__accountsResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;
  value3: BigInt;
  value4: BigInt;

  constructor(
    value0: BigInt,
    value1: BigInt,
    value2: BigInt,
    value3: BigInt,
    value4: BigInt
  ) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
    this.value3 = value3;
    this.value4 = value4;
  }

  toMap(): TypedMap<string, EthereumValue> {
    let map = new TypedMap<string, EthereumValue>();
    map.set("value0", EthereumValue.fromUnsignedBigInt(this.value0));
    map.set("value1", EthereumValue.fromUnsignedBigInt(this.value1));
    map.set("value2", EthereumValue.fromUnsignedBigInt(this.value2));
    map.set("value3", EthereumValue.fromUnsignedBigInt(this.value3));
    map.set("value4", EthereumValue.fromUnsignedBigInt(this.value4));
    return map;
  }
}

export class RToken__getAccountStatsResultStatsStruct extends EthereumTuple {
  get hatID(): BigInt {
    return this[0].toBigInt();
  }

  get rAmount(): BigInt {
    return this[1].toBigInt();
  }

  get rInterest(): BigInt {
    return this[2].toBigInt();
  }

  get lDebt(): BigInt {
    return this[3].toBigInt();
  }

  get sInternalAmount(): BigInt {
    return this[4].toBigInt();
  }

  get rInterestPayable(): BigInt {
    return this[5].toBigInt();
  }

  get cumulativeInterest(): BigInt {
    return this[6].toBigInt();
  }
}

export class RToken__getGlobalStatsResultValue0Struct extends EthereumTuple {
  get totalSupply(): BigInt {
    return this[0].toBigInt();
  }

  get totalSavingsAmount(): BigInt {
    return this[1].toBigInt();
  }
}

export class RToken__getHatByAddressResult {
  value0: BigInt;
  value1: Array<Address>;
  value2: Array<BigInt>;

  constructor(value0: BigInt, value1: Array<Address>, value2: Array<BigInt>) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
  }

  toMap(): TypedMap<string, EthereumValue> {
    let map = new TypedMap<string, EthereumValue>();
    map.set("value0", EthereumValue.fromUnsignedBigInt(this.value0));
    map.set("value1", EthereumValue.fromAddressArray(this.value1));
    map.set("value2", EthereumValue.fromUnsignedBigIntArray(this.value2));
    return map;
  }
}

export class RToken__getHatByIDResult {
  value0: Array<Address>;
  value1: Array<BigInt>;

  constructor(value0: Array<Address>, value1: Array<BigInt>) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, EthereumValue> {
    let map = new TypedMap<string, EthereumValue>();
    map.set("value0", EthereumValue.fromAddressArray(this.value0));
    map.set("value1", EthereumValue.fromUnsignedBigIntArray(this.value1));
    return map;
  }
}

export class RToken__getHatStatsResultStatsStruct extends EthereumTuple {
  get useCount(): BigInt {
    return this[0].toBigInt();
  }

  get totalLoans(): BigInt {
    return this[1].toBigInt();
  }

  get totalSavings(): BigInt {
    return this[2].toBigInt();
  }
}

export class RToken__getSavingAssetBalanceResult {
  value0: BigInt;
  value1: BigInt;

  constructor(value0: BigInt, value1: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
  }

  toMap(): TypedMap<string, EthereumValue> {
    let map = new TypedMap<string, EthereumValue>();
    map.set("value0", EthereumValue.fromUnsignedBigInt(this.value0));
    map.set("value1", EthereumValue.fromUnsignedBigInt(this.value1));
    return map;
  }
}

export class RToken__hatStatsResult {
  value0: BigInt;
  value1: BigInt;
  value2: BigInt;

  constructor(value0: BigInt, value1: BigInt, value2: BigInt) {
    this.value0 = value0;
    this.value1 = value1;
    this.value2 = value2;
  }

  toMap(): TypedMap<string, EthereumValue> {
    let map = new TypedMap<string, EthereumValue>();
    map.set("value0", EthereumValue.fromUnsignedBigInt(this.value0));
    map.set("value1", EthereumValue.fromUnsignedBigInt(this.value1));
    map.set("value2", EthereumValue.fromUnsignedBigInt(this.value2));
    return map;
  }
}

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

  ALLOCATION_STRATEGY_EXCHANGE_RATE_SCALE(): BigInt {
    let result = super.call("ALLOCATION_STRATEGY_EXCHANGE_RATE_SCALE", []);

    return result[0].toBigInt();
  }

  try_ALLOCATION_STRATEGY_EXCHANGE_RATE_SCALE(): CallResult<BigInt> {
    let result = super.tryCall("ALLOCATION_STRATEGY_EXCHANGE_RATE_SCALE", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  INITIAL_SAVING_ASSET_CONVERSION_RATE(): BigInt {
    let result = super.call("INITIAL_SAVING_ASSET_CONVERSION_RATE", []);

    return result[0].toBigInt();
  }

  try_INITIAL_SAVING_ASSET_CONVERSION_RATE(): CallResult<BigInt> {
    let result = super.tryCall("INITIAL_SAVING_ASSET_CONVERSION_RATE", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  MAX_NUM_HAT_RECIPIENTS(): BigInt {
    let result = super.call("MAX_NUM_HAT_RECIPIENTS", []);

    return result[0].toBigInt();
  }

  try_MAX_NUM_HAT_RECIPIENTS(): CallResult<BigInt> {
    let result = super.tryCall("MAX_NUM_HAT_RECIPIENTS", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  MAX_UINT256(): BigInt {
    let result = super.call("MAX_UINT256", []);

    return result[0].toBigInt();
  }

  try_MAX_UINT256(): CallResult<BigInt> {
    let result = super.tryCall("MAX_UINT256", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  PROPORTION_BASE(): BigInt {
    let result = super.call("PROPORTION_BASE", []);

    return result[0].toBigInt();
  }

  try_PROPORTION_BASE(): CallResult<BigInt> {
    let result = super.tryCall("PROPORTION_BASE", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  SELF_HAT_ID(): BigInt {
    let result = super.call("SELF_HAT_ID", []);

    return result[0].toBigInt();
  }

  try_SELF_HAT_ID(): CallResult<BigInt> {
    let result = super.tryCall("SELF_HAT_ID", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  _guardCounter(): BigInt {
    let result = super.call("_guardCounter", []);

    return result[0].toBigInt();
  }

  try__guardCounter(): CallResult<BigInt> {
    let result = super.tryCall("_guardCounter", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

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

    return result[0].toAddress();
  }

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

  accountStats(param0: Address): BigInt {
    let result = super.call("accountStats", [
      EthereumValue.fromAddress(param0)
    ]);

    return result[0].toBigInt();
  }

  try_accountStats(param0: Address): CallResult<BigInt> {
    let result = super.tryCall("accountStats", [
      EthereumValue.fromAddress(param0)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  accounts(param0: Address): RToken__accountsResult {
    let result = super.call("accounts", [EthereumValue.fromAddress(param0)]);

    return new RToken__accountsResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt(),
      result[3].toBigInt(),
      result[4].toBigInt()
    );
  }

  try_accounts(param0: Address): CallResult<RToken__accountsResult> {
    let result = super.tryCall("accounts", [EthereumValue.fromAddress(param0)]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      new RToken__accountsResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt(),
        value[3].toBigInt(),
        value[4].toBigInt()
      )
    );
  }

  allowance(owner: Address, spender: Address): BigInt {
    let result = super.call("allowance", [
      EthereumValue.fromAddress(owner),
      EthereumValue.fromAddress(spender)
    ]);

    return result[0].toBigInt();
  }

  try_allowance(owner: Address, spender: Address): CallResult<BigInt> {
    let result = super.tryCall("allowance", [
      EthereumValue.fromAddress(owner),
      EthereumValue.fromAddress(spender)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  approve(spender: Address, amount: BigInt): boolean {
    let result = super.call("approve", [
      EthereumValue.fromAddress(spender),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);

    return result[0].toBoolean();
  }

  try_approve(spender: Address, amount: BigInt): CallResult<boolean> {
    let result = super.tryCall("approve", [
      EthereumValue.fromAddress(spender),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  balanceOf(owner: Address): BigInt {
    let result = super.call("balanceOf", [EthereumValue.fromAddress(owner)]);

    return result[0].toBigInt();
  }

  try_balanceOf(owner: Address): CallResult<BigInt> {
    let result = super.tryCall("balanceOf", [EthereumValue.fromAddress(owner)]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  changeHat(hatID: BigInt): boolean {
    let result = super.call("changeHat", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);

    return result[0].toBoolean();
  }

  try_changeHat(hatID: BigInt): CallResult<boolean> {
    let result = super.tryCall("changeHat", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  createHat(
    recipients: Array<Address>,
    proportions: Array<BigInt>,
    doChangeHat: boolean
  ): BigInt {
    let result = super.call("createHat", [
      EthereumValue.fromAddressArray(recipients),
      EthereumValue.fromUnsignedBigIntArray(proportions),
      EthereumValue.fromBoolean(doChangeHat)
    ]);

    return result[0].toBigInt();
  }

  try_createHat(
    recipients: Array<Address>,
    proportions: Array<BigInt>,
    doChangeHat: boolean
  ): CallResult<BigInt> {
    let result = super.tryCall("createHat", [
      EthereumValue.fromAddressArray(recipients),
      EthereumValue.fromUnsignedBigIntArray(proportions),
      EthereumValue.fromBoolean(doChangeHat)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  decimals(): BigInt {
    let result = super.call("decimals", []);

    return result[0].toBigInt();
  }

  try_decimals(): CallResult<BigInt> {
    let result = super.tryCall("decimals", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  getAccountStats(owner: Address): RToken__getAccountStatsResultStatsStruct {
    let result = super.call("getAccountStats", [
      EthereumValue.fromAddress(owner)
    ]);

    return result[0].toTuple() as RToken__getAccountStatsResultStatsStruct;
  }

  try_getAccountStats(
    owner: Address
  ): CallResult<RToken__getAccountStatsResultStatsStruct> {
    let result = super.tryCall("getAccountStats", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      value[0].toTuple() as RToken__getAccountStatsResultStatsStruct
    );
  }

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

    return result[0].toAddress();
  }

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

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

    return result[0].toAddress();
  }

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

  getGlobalStats(): RToken__getGlobalStatsResultValue0Struct {
    let result = super.call("getGlobalStats", []);

    return result[0].toTuple() as RToken__getGlobalStatsResultValue0Struct;
  }

  try_getGlobalStats(): CallResult<RToken__getGlobalStatsResultValue0Struct> {
    let result = super.tryCall("getGlobalStats", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      value[0].toTuple() as RToken__getGlobalStatsResultValue0Struct
    );
  }

  getHatByAddress(owner: Address): RToken__getHatByAddressResult {
    let result = super.call("getHatByAddress", [
      EthereumValue.fromAddress(owner)
    ]);

    return new RToken__getHatByAddressResult(
      result[0].toBigInt(),
      result[1].toAddressArray(),
      result[2].toBigIntArray()
    );
  }

  try_getHatByAddress(
    owner: Address
  ): CallResult<RToken__getHatByAddressResult> {
    let result = super.tryCall("getHatByAddress", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      new RToken__getHatByAddressResult(
        value[0].toBigInt(),
        value[1].toAddressArray(),
        value[2].toBigIntArray()
      )
    );
  }

  getHatByID(hatID: BigInt): RToken__getHatByIDResult {
    let result = super.call("getHatByID", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);

    return new RToken__getHatByIDResult(
      result[0].toAddressArray(),
      result[1].toBigIntArray()
    );
  }

  try_getHatByID(hatID: BigInt): CallResult<RToken__getHatByIDResult> {
    let result = super.tryCall("getHatByID", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      new RToken__getHatByIDResult(
        value[0].toAddressArray(),
        value[1].toBigIntArray()
      )
    );
  }

  getHatStats(hatID: BigInt): RToken__getHatStatsResultStatsStruct {
    let result = super.call("getHatStats", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);

    return result[0].toTuple() as RToken__getHatStatsResultStatsStruct;
  }

  try_getHatStats(
    hatID: BigInt
  ): CallResult<RToken__getHatStatsResultStatsStruct> {
    let result = super.tryCall("getHatStats", [
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      value[0].toTuple() as RToken__getHatStatsResultStatsStruct
    );
  }

  getMaximumHatID(): BigInt {
    let result = super.call("getMaximumHatID", []);

    return result[0].toBigInt();
  }

  try_getMaximumHatID(): CallResult<BigInt> {
    let result = super.tryCall("getMaximumHatID", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  getSavingAssetBalance(): RToken__getSavingAssetBalanceResult {
    let result = super.call("getSavingAssetBalance", []);

    return new RToken__getSavingAssetBalanceResult(
      result[0].toBigInt(),
      result[1].toBigInt()
    );
  }

  try_getSavingAssetBalance(): CallResult<RToken__getSavingAssetBalanceResult> {
    let result = super.tryCall("getSavingAssetBalance", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      new RToken__getSavingAssetBalanceResult(
        value[0].toBigInt(),
        value[1].toBigInt()
      )
    );
  }

  hatStats(param0: BigInt): RToken__hatStatsResult {
    let result = super.call("hatStats", [
      EthereumValue.fromUnsignedBigInt(param0)
    ]);

    return new RToken__hatStatsResult(
      result[0].toBigInt(),
      result[1].toBigInt(),
      result[2].toBigInt()
    );
  }

  try_hatStats(param0: BigInt): CallResult<RToken__hatStatsResult> {
    let result = super.tryCall("hatStats", [
      EthereumValue.fromUnsignedBigInt(param0)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(
      new RToken__hatStatsResult(
        value[0].toBigInt(),
        value[1].toBigInt(),
        value[2].toBigInt()
      )
    );
  }

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

    return result[0].toAddress();
  }

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

  initialized(): boolean {
    let result = super.call("initialized", []);

    return result[0].toBoolean();
  }

  try_initialized(): CallResult<boolean> {
    let result = super.tryCall("initialized", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  interestPayableOf(owner: Address): BigInt {
    let result = super.call("interestPayableOf", [
      EthereumValue.fromAddress(owner)
    ]);

    return result[0].toBigInt();
  }

  try_interestPayableOf(owner: Address): CallResult<BigInt> {
    let result = super.tryCall("interestPayableOf", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  isOwner(): boolean {
    let result = super.call("isOwner", []);

    return result[0].toBoolean();
  }

  try_isOwner(): CallResult<boolean> {
    let result = super.tryCall("isOwner", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  mint(mintAmount: BigInt): boolean {
    let result = super.call("mint", [
      EthereumValue.fromUnsignedBigInt(mintAmount)
    ]);

    return result[0].toBoolean();
  }

  try_mint(mintAmount: BigInt): CallResult<boolean> {
    let result = super.tryCall("mint", [
      EthereumValue.fromUnsignedBigInt(mintAmount)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  mintWithNewHat(
    mintAmount: BigInt,
    recipients: Array<Address>,
    proportions: Array<BigInt>
  ): boolean {
    let result = super.call("mintWithNewHat", [
      EthereumValue.fromUnsignedBigInt(mintAmount),
      EthereumValue.fromAddressArray(recipients),
      EthereumValue.fromUnsignedBigIntArray(proportions)
    ]);

    return result[0].toBoolean();
  }

  try_mintWithNewHat(
    mintAmount: BigInt,
    recipients: Array<Address>,
    proportions: Array<BigInt>
  ): CallResult<boolean> {
    let result = super.tryCall("mintWithNewHat", [
      EthereumValue.fromUnsignedBigInt(mintAmount),
      EthereumValue.fromAddressArray(recipients),
      EthereumValue.fromUnsignedBigIntArray(proportions)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  mintWithSelectedHat(mintAmount: BigInt, hatID: BigInt): boolean {
    let result = super.call("mintWithSelectedHat", [
      EthereumValue.fromUnsignedBigInt(mintAmount),
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);

    return result[0].toBoolean();
  }

  try_mintWithSelectedHat(
    mintAmount: BigInt,
    hatID: BigInt
  ): CallResult<boolean> {
    let result = super.tryCall("mintWithSelectedHat", [
      EthereumValue.fromUnsignedBigInt(mintAmount),
      EthereumValue.fromUnsignedBigInt(hatID)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  name(): string {
    let result = super.call("name", []);

    return result[0].toString();
  }

  try_name(): CallResult<string> {
    let result = super.tryCall("name", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toString());
  }

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

    return result[0].toAddress();
  }

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

  payInterest(owner: Address): boolean {
    let result = super.call("payInterest", [EthereumValue.fromAddress(owner)]);

    return result[0].toBoolean();
  }

  try_payInterest(owner: Address): CallResult<boolean> {
    let result = super.tryCall("payInterest", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  proxiableUUID(): Bytes {
    let result = super.call("proxiableUUID", []);

    return result[0].toBytes();
  }

  try_proxiableUUID(): CallResult<Bytes> {
    let result = super.tryCall("proxiableUUID", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBytes());
  }

  receivedLoanOf(owner: Address): BigInt {
    let result = super.call("receivedLoanOf", [
      EthereumValue.fromAddress(owner)
    ]);

    return result[0].toBigInt();
  }

  try_receivedLoanOf(owner: Address): CallResult<BigInt> {
    let result = super.tryCall("receivedLoanOf", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  receivedSavingsOf(owner: Address): BigInt {
    let result = super.call("receivedSavingsOf", [
      EthereumValue.fromAddress(owner)
    ]);

    return result[0].toBigInt();
  }

  try_receivedSavingsOf(owner: Address): CallResult<BigInt> {
    let result = super.tryCall("receivedSavingsOf", [
      EthereumValue.fromAddress(owner)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  redeem(redeemTokens: BigInt): boolean {
    let result = super.call("redeem", [
      EthereumValue.fromUnsignedBigInt(redeemTokens)
    ]);

    return result[0].toBoolean();
  }

  try_redeem(redeemTokens: BigInt): CallResult<boolean> {
    let result = super.tryCall("redeem", [
      EthereumValue.fromUnsignedBigInt(redeemTokens)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  redeemAll(): boolean {
    let result = super.call("redeemAll", []);

    return result[0].toBoolean();
  }

  try_redeemAll(): CallResult<boolean> {
    let result = super.tryCall("redeemAll", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  redeemAndTransfer(redeemTo: Address, redeemTokens: BigInt): boolean {
    let result = super.call("redeemAndTransfer", [
      EthereumValue.fromAddress(redeemTo),
      EthereumValue.fromUnsignedBigInt(redeemTokens)
    ]);

    return result[0].toBoolean();
  }

  try_redeemAndTransfer(
    redeemTo: Address,
    redeemTokens: BigInt
  ): CallResult<boolean> {
    let result = super.tryCall("redeemAndTransfer", [
      EthereumValue.fromAddress(redeemTo),
      EthereumValue.fromUnsignedBigInt(redeemTokens)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  redeemAndTransferAll(redeemTo: Address): boolean {
    let result = super.call("redeemAndTransferAll", [
      EthereumValue.fromAddress(redeemTo)
    ]);

    return result[0].toBoolean();
  }

  try_redeemAndTransferAll(redeemTo: Address): CallResult<boolean> {
    let result = super.tryCall("redeemAndTransferAll", [
      EthereumValue.fromAddress(redeemTo)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  savingAssetConversionRate(): BigInt {
    let result = super.call("savingAssetConversionRate", []);

    return result[0].toBigInt();
  }

  try_savingAssetConversionRate(): CallResult<BigInt> {
    let result = super.tryCall("savingAssetConversionRate", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  savingAssetOrignalAmount(): BigInt {
    let result = super.call("savingAssetOrignalAmount", []);

    return result[0].toBigInt();
  }

  try_savingAssetOrignalAmount(): CallResult<BigInt> {
    let result = super.tryCall("savingAssetOrignalAmount", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  symbol(): string {
    let result = super.call("symbol", []);

    return result[0].toString();
  }

  try_symbol(): CallResult<string> {
    let result = super.tryCall("symbol", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toString());
  }

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

    return result[0].toAddress();
  }

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

  totalSupply(): BigInt {
    let result = super.call("totalSupply", []);

    return result[0].toBigInt();
  }

  try_totalSupply(): CallResult<BigInt> {
    let result = super.tryCall("totalSupply", []);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  transfer(dst: Address, amount: BigInt): boolean {
    let result = super.call("transfer", [
      EthereumValue.fromAddress(dst),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);

    return result[0].toBoolean();
  }

  try_transfer(dst: Address, amount: BigInt): CallResult<boolean> {
    let result = super.tryCall("transfer", [
      EthereumValue.fromAddress(dst),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  transferAll(dst: Address): boolean {
    let result = super.call("transferAll", [EthereumValue.fromAddress(dst)]);

    return result[0].toBoolean();
  }

  try_transferAll(dst: Address): CallResult<boolean> {
    let result = super.tryCall("transferAll", [EthereumValue.fromAddress(dst)]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  transferAllFrom(src: Address, dst: Address): boolean {
    let result = super.call("transferAllFrom", [
      EthereumValue.fromAddress(src),
      EthereumValue.fromAddress(dst)
    ]);

    return result[0].toBoolean();
  }

  try_transferAllFrom(src: Address, dst: Address): CallResult<boolean> {
    let result = super.tryCall("transferAllFrom", [
      EthereumValue.fromAddress(src),
      EthereumValue.fromAddress(dst)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }

  transferAllowances(param0: Address, param1: Address): BigInt {
    let result = super.call("transferAllowances", [
      EthereumValue.fromAddress(param0),
      EthereumValue.fromAddress(param1)
    ]);

    return result[0].toBigInt();
  }

  try_transferAllowances(param0: Address, param1: Address): CallResult<BigInt> {
    let result = super.tryCall("transferAllowances", [
      EthereumValue.fromAddress(param0),
      EthereumValue.fromAddress(param1)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBigInt());
  }

  transferFrom(src: Address, dst: Address, amount: BigInt): boolean {
    let result = super.call("transferFrom", [
      EthereumValue.fromAddress(src),
      EthereumValue.fromAddress(dst),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);

    return result[0].toBoolean();
  }

  try_transferFrom(
    src: Address,
    dst: Address,
    amount: BigInt
  ): CallResult<boolean> {
    let result = super.tryCall("transferFrom", [
      EthereumValue.fromAddress(src),
      EthereumValue.fromAddress(dst),
      EthereumValue.fromUnsignedBigInt(amount)
    ]);
    if (result.reverted) {
      return new CallResult();
    }
    let value = result.value;
    return CallResult.fromValue(value[0].toBoolean());
  }
}

export class ApproveCall extends EthereumCall {
  get inputs(): ApproveCall__Inputs {
    return new ApproveCall__Inputs(this);
  }

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

export class ApproveCall__Inputs {
  _call: ApproveCall;

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

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

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

export class ApproveCall__Outputs {
  _call: ApproveCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class ChangeAllocationStrategyCall extends EthereumCall {
  get inputs(): ChangeAllocationStrategyCall__Inputs {
    return new ChangeAllocationStrategyCall__Inputs(this);
  }

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

export class ChangeAllocationStrategyCall__Inputs {
  _call: ChangeAllocationStrategyCall;

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

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

export class ChangeAllocationStrategyCall__Outputs {
  _call: ChangeAllocationStrategyCall;

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

export class ChangeHatCall extends EthereumCall {
  get inputs(): ChangeHatCall__Inputs {
    return new ChangeHatCall__Inputs(this);
  }

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

export class ChangeHatCall__Inputs {
  _call: ChangeHatCall;

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

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

export class ChangeHatCall__Outputs {
  _call: ChangeHatCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class ChangeHatForCall extends EthereumCall {
  get inputs(): ChangeHatForCall__Inputs {
    return new ChangeHatForCall__Inputs(this);
  }

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

export class ChangeHatForCall__Inputs {
  _call: ChangeHatForCall;

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

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

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

export class ChangeHatForCall__Outputs {
  _call: ChangeHatForCall;

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

export class CreateHatCall extends EthereumCall {
  get inputs(): CreateHatCall__Inputs {
    return new CreateHatCall__Inputs(this);
  }

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

export class CreateHatCall__Inputs {
  _call: CreateHatCall;

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

  get recipients(): Array<Address> {
    return this._call.inputValues[0].value.toAddressArray();
  }

  get proportions(): Array<BigInt> {
    return this._call.inputValues[1].value.toBigIntArray();
  }

  get doChangeHat(): boolean {
    return this._call.inputValues[2].value.toBoolean();
  }
}

export class CreateHatCall__Outputs {
  _call: CreateHatCall;

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

  get hatID(): BigInt {
    return this._call.outputValues[0].value.toBigInt();
  }
}

export class InitializeCall extends EthereumCall {
  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 allocationStrategy(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

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

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

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

export class InitializeCall__Outputs {
  _call: InitializeCall;

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

export class MintCall extends EthereumCall {
  get inputs(): MintCall__Inputs {
    return new MintCall__Inputs(this);
  }

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

export class MintCall__Inputs {
  _call: MintCall;

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

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

export class MintCall__Outputs {
  _call: MintCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class MintWithNewHatCall extends EthereumCall {
  get inputs(): MintWithNewHatCall__Inputs {
    return new MintWithNewHatCall__Inputs(this);
  }

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

export class MintWithNewHatCall__Inputs {
  _call: MintWithNewHatCall;

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

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

  get recipients(): Array<Address> {
    return this._call.inputValues[1].value.toAddressArray();
  }

  get proportions(): Array<BigInt> {
    return this._call.inputValues[2].value.toBigIntArray();
  }
}

export class MintWithNewHatCall__Outputs {
  _call: MintWithNewHatCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class MintWithSelectedHatCall extends EthereumCall {
  get inputs(): MintWithSelectedHatCall__Inputs {
    return new MintWithSelectedHatCall__Inputs(this);
  }

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

export class MintWithSelectedHatCall__Inputs {
  _call: MintWithSelectedHatCall;

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

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

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

export class MintWithSelectedHatCall__Outputs {
  _call: MintWithSelectedHatCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class PayInterestCall extends EthereumCall {
  get inputs(): PayInterestCall__Inputs {
    return new PayInterestCall__Inputs(this);
  }

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

export class PayInterestCall__Inputs {
  _call: PayInterestCall;

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

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

export class PayInterestCall__Outputs {
  _call: PayInterestCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class RedeemCall extends EthereumCall {
  get inputs(): RedeemCall__Inputs {
    return new RedeemCall__Inputs(this);
  }

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

export class RedeemCall__Inputs {
  _call: RedeemCall;

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

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

export class RedeemCall__Outputs {
  _call: RedeemCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class RedeemAllCall extends EthereumCall {
  get inputs(): RedeemAllCall__Inputs {
    return new RedeemAllCall__Inputs(this);
  }

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

export class RedeemAllCall__Inputs {
  _call: RedeemAllCall;

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

export class RedeemAllCall__Outputs {
  _call: RedeemAllCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class RedeemAndTransferCall extends EthereumCall {
  get inputs(): RedeemAndTransferCall__Inputs {
    return new RedeemAndTransferCall__Inputs(this);
  }

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

export class RedeemAndTransferCall__Inputs {
  _call: RedeemAndTransferCall;

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

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

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

export class RedeemAndTransferCall__Outputs {
  _call: RedeemAndTransferCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class RedeemAndTransferAllCall extends EthereumCall {
  get inputs(): RedeemAndTransferAllCall__Inputs {
    return new RedeemAndTransferAllCall__Inputs(this);
  }

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

export class RedeemAndTransferAllCall__Inputs {
  _call: RedeemAndTransferAllCall;

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

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

export class RedeemAndTransferAllCall__Outputs {
  _call: RedeemAndTransferAllCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class RenounceOwnershipCall extends EthereumCall {
  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 TransferCall extends EthereumCall {
  get inputs(): TransferCall__Inputs {
    return new TransferCall__Inputs(this);
  }

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

export class TransferCall__Inputs {
  _call: TransferCall;

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

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

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

export class TransferCall__Outputs {
  _call: TransferCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class TransferAllCall extends EthereumCall {
  get inputs(): TransferAllCall__Inputs {
    return new TransferAllCall__Inputs(this);
  }

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

export class TransferAllCall__Inputs {
  _call: TransferAllCall;

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

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

export class TransferAllCall__Outputs {
  _call: TransferAllCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class TransferAllFromCall extends EthereumCall {
  get inputs(): TransferAllFromCall__Inputs {
    return new TransferAllFromCall__Inputs(this);
  }

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

export class TransferAllFromCall__Inputs {
  _call: TransferAllFromCall;

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

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

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

export class TransferAllFromCall__Outputs {
  _call: TransferAllFromCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class TransferFromCall extends EthereumCall {
  get inputs(): TransferFromCall__Inputs {
    return new TransferFromCall__Inputs(this);
  }

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

export class TransferFromCall__Inputs {
  _call: TransferFromCall;

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

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

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

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

export class TransferFromCall__Outputs {
  _call: TransferFromCall;

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

  get value0(): boolean {
    return this._call.outputValues[0].value.toBoolean();
  }
}

export class TransferOwnershipCall extends EthereumCall {
  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 UpdateCodeCall extends EthereumCall {
  get inputs(): UpdateCodeCall__Inputs {
    return new UpdateCodeCall__Inputs(this);
  }

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

export class UpdateCodeCall__Inputs {
  _call: UpdateCodeCall;

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

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

export class UpdateCodeCall__Outputs {
  _call: UpdateCodeCall;

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