// 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 BreakBondApproval extends ethereum.Event {
  get params(): BreakBondApproval__Params {
    return new BreakBondApproval__Params(this);
  }
}

export class BreakBondApproval__Params {
  _event: BreakBondApproval;

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

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

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

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

  get operator(): Address {
    return this._event.parameters[3].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 DischargeApproval extends ethereum.Event {
  get params(): DischargeApproval__Params {
    return new DischargeApproval__Params(this);
  }
}

export class DischargeApproval__Params {
  _event: DischargeApproval;

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

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

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

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

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

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 PermsSetForAllowBreakBond extends ethereum.Event {
  get params(): PermsSetForAllowBreakBond__Params {
    return new PermsSetForAllowBreakBond__Params(this);
  }
}

export class PermsSetForAllowBreakBond__Params {
  _event: PermsSetForAllowBreakBond;

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

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

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

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

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

export class PermsSetForAllowDischarge__Params {
  _event: PermsSetForAllowDischarge;

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

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

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

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

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

export class PermsSetForAllowRelease__Params {
  _event: PermsSetForAllowRelease;

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

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

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

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

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

export class PermsSetForRestrictBond__Params {
  _event: PermsSetForRestrictBond;

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

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

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

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

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

export class PermsSetForRestrictCharge__Params {
  _event: PermsSetForRestrictCharge;

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

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

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

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

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

export class ReleaseApproval__Params {
  _event: ReleaseApproval;

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

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

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

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

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

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

export class TimelockApproval__Params {
  _event: TimelockApproval;

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

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

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

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

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

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

export class TokenBreakBondTimelock__Params {
  _event: TokenBreakBondTimelock;

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

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

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

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

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

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

export class TokenDischargeTimelock__Params {
  _event: TokenDischargeTimelock;

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

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

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

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

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

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

export class TokenReleaseTimelock__Params {
  _event: TokenReleaseTimelock;

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

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

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

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

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

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

export class TokenTempLock__Params {
  _event: TokenTempLock;

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

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

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

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

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 ChargedState__getBreakBondStateResult {
  value0: boolean;
  value1: boolean;
  value2: BigInt;
  value3: BigInt;

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

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

export class ChargedState__getDischargeStateResult {
  value0: boolean;
  value1: boolean;
  value2: BigInt;
  value3: BigInt;

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

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

export class ChargedState__getReleaseStateResult {
  value0: boolean;
  value1: boolean;
  value2: BigInt;
  value3: BigInt;

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

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

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

  getBreakBondState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ChargedState__getBreakBondStateResult {
    let result = super.call(
      "getBreakBondState",
      "getBreakBondState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );

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

  try_getBreakBondState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ethereum.CallResult<ChargedState__getBreakBondStateResult> {
    let result = super.tryCall(
      "getBreakBondState",
      "getBreakBondState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new ChargedState__getBreakBondStateResult(
        value[0].toBoolean(),
        value[1].toBoolean(),
        value[2].toBigInt(),
        value[3].toBigInt()
      )
    );
  }

  getBreakBondTimelockExpiry(
    contractAddress: Address,
    tokenId: BigInt
  ): BigInt {
    let result = super.call(
      "getBreakBondTimelockExpiry",
      "getBreakBondTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );

    return result[0].toBigInt();
  }

  try_getBreakBondTimelockExpiry(
    contractAddress: Address,
    tokenId: BigInt
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "getBreakBondTimelockExpiry",
      "getBreakBondTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  getDischargeState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ChargedState__getDischargeStateResult {
    let result = super.call(
      "getDischargeState",
      "getDischargeState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );

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

  try_getDischargeState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ethereum.CallResult<ChargedState__getDischargeStateResult> {
    let result = super.tryCall(
      "getDischargeState",
      "getDischargeState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new ChargedState__getDischargeStateResult(
        value[0].toBoolean(),
        value[1].toBoolean(),
        value[2].toBigInt(),
        value[3].toBigInt()
      )
    );
  }

  getDischargeTimelockExpiry(
    contractAddress: Address,
    tokenId: BigInt
  ): BigInt {
    let result = super.call(
      "getDischargeTimelockExpiry",
      "getDischargeTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );

    return result[0].toBigInt();
  }

  try_getDischargeTimelockExpiry(
    contractAddress: Address,
    tokenId: BigInt
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "getDischargeTimelockExpiry",
      "getDischargeTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  getReleaseState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ChargedState__getReleaseStateResult {
    let result = super.call(
      "getReleaseState",
      "getReleaseState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );

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

  try_getReleaseState(
    contractAddress: Address,
    tokenId: BigInt,
    sender: Address
  ): ethereum.CallResult<ChargedState__getReleaseStateResult> {
    let result = super.tryCall(
      "getReleaseState",
      "getReleaseState(address,uint256,address):(bool,bool,uint256,uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(sender)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(
      new ChargedState__getReleaseStateResult(
        value[0].toBoolean(),
        value[1].toBoolean(),
        value[2].toBigInt(),
        value[3].toBigInt()
      )
    );
  }

  getReleaseTimelockExpiry(contractAddress: Address, tokenId: BigInt): BigInt {
    let result = super.call(
      "getReleaseTimelockExpiry",
      "getReleaseTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );

    return result[0].toBigInt();
  }

  try_getReleaseTimelockExpiry(
    contractAddress: Address,
    tokenId: BigInt
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "getReleaseTimelockExpiry",
      "getReleaseTimelockExpiry(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  isApprovedForBreakBond(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): boolean {
    let result = super.call(
      "isApprovedForBreakBond",
      "isApprovedForBreakBond(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );

    return result[0].toBoolean();
  }

  try_isApprovedForBreakBond(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isApprovedForBreakBond",
      "isApprovedForBreakBond(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isApprovedForDischarge(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): boolean {
    let result = super.call(
      "isApprovedForDischarge",
      "isApprovedForDischarge(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );

    return result[0].toBoolean();
  }

  try_isApprovedForDischarge(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isApprovedForDischarge",
      "isApprovedForDischarge(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isApprovedForRelease(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): boolean {
    let result = super.call(
      "isApprovedForRelease",
      "isApprovedForRelease(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );

    return result[0].toBoolean();
  }

  try_isApprovedForRelease(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isApprovedForRelease",
      "isApprovedForRelease(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isApprovedForTimelock(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): boolean {
    let result = super.call(
      "isApprovedForTimelock",
      "isApprovedForTimelock(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );

    return result[0].toBoolean();
  }

  try_isApprovedForTimelock(
    contractAddress: Address,
    tokenId: BigInt,
    operator: Address
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isApprovedForTimelock",
      "isApprovedForTimelock(address,uint256,address):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId),
        ethereum.Value.fromAddress(operator)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isCovalentBondRestricted(contractAddress: Address, tokenId: BigInt): boolean {
    let result = super.call(
      "isCovalentBondRestricted",
      "isCovalentBondRestricted(address,uint256):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );

    return result[0].toBoolean();
  }

  try_isCovalentBondRestricted(
    contractAddress: Address,
    tokenId: BigInt
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isCovalentBondRestricted",
      "isCovalentBondRestricted(address,uint256):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  isEnergizeRestricted(contractAddress: Address, tokenId: BigInt): boolean {
    let result = super.call(
      "isEnergizeRestricted",
      "isEnergizeRestricted(address,uint256):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );

    return result[0].toBoolean();
  }

  try_isEnergizeRestricted(
    contractAddress: Address,
    tokenId: BigInt
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isEnergizeRestricted",
      "isEnergizeRestricted(address,uint256):(bool)",
      [
        ethereum.Value.fromAddress(contractAddress),
        ethereum.Value.fromUnsignedBigInt(tokenId)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

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

    return result[0].toBoolean();
  }

  try_isTrustedForwarder(forwarder: Address): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "isTrustedForwarder",
      "isTrustedForwarder(address):(bool)",
      [ethereum.Value.fromAddress(forwarder)]
    );
    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());
  }

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

    return result[0].toAddress();
  }

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

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

    return result[0].toString();
  }

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

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

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

export class GetBreakBondStateCall__Inputs {
  _call: GetBreakBondStateCall;

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

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

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

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

export class GetBreakBondStateCall__Outputs {
  _call: GetBreakBondStateCall;

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

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

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

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

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

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

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

export class GetDischargeStateCall__Inputs {
  _call: GetDischargeStateCall;

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

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

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

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

export class GetDischargeStateCall__Outputs {
  _call: GetDischargeStateCall;

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

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

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

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

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

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

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

export class GetReleaseStateCall__Inputs {
  _call: GetReleaseStateCall;

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

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

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

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

export class GetReleaseStateCall__Outputs {
  _call: GetReleaseStateCall;

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

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

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

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

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

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 IsApprovedForBreakBondCall extends ethereum.Call {
  get inputs(): IsApprovedForBreakBondCall__Inputs {
    return new IsApprovedForBreakBondCall__Inputs(this);
  }

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

export class IsApprovedForBreakBondCall__Inputs {
  _call: IsApprovedForBreakBondCall;

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

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

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

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

export class IsApprovedForBreakBondCall__Outputs {
  _call: IsApprovedForBreakBondCall;

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

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

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

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

export class IsApprovedForDischargeCall__Inputs {
  _call: IsApprovedForDischargeCall;

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

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

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

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

export class IsApprovedForDischargeCall__Outputs {
  _call: IsApprovedForDischargeCall;

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

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

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

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

export class IsApprovedForReleaseCall__Inputs {
  _call: IsApprovedForReleaseCall;

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

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

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

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

export class IsApprovedForReleaseCall__Outputs {
  _call: IsApprovedForReleaseCall;

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

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

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

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

export class IsApprovedForTimelockCall__Inputs {
  _call: IsApprovedForTimelockCall;

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

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

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

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

export class IsApprovedForTimelockCall__Outputs {
  _call: IsApprovedForTimelockCall;

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

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

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

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

export class MigrateTokenCall__Inputs {
  _call: MigrateTokenCall;

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

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

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

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

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

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

export class MigrateTokenCall__Outputs {
  _call: MigrateTokenCall;

  constructor(call: MigrateTokenCall) {
    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 SetApprovalForAllCall extends ethereum.Call {
  get inputs(): SetApprovalForAllCall__Inputs {
    return new SetApprovalForAllCall__Inputs(this);
  }

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

export class SetApprovalForAllCall__Inputs {
  _call: SetApprovalForAllCall;

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

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

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

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

export class SetApprovalForAllCall__Outputs {
  _call: SetApprovalForAllCall;

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

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

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

export class SetBreakBondApprovalCall__Inputs {
  _call: SetBreakBondApprovalCall;

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

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

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

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

export class SetBreakBondApprovalCall__Outputs {
  _call: SetBreakBondApprovalCall;

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

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

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

export class SetBreakBondTimelockCall__Inputs {
  _call: SetBreakBondTimelockCall;

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

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

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

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

export class SetBreakBondTimelockCall__Outputs {
  _call: SetBreakBondTimelockCall;

  constructor(call: SetBreakBondTimelockCall) {
    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 SetDischargeApprovalCall extends ethereum.Call {
  get inputs(): SetDischargeApprovalCall__Inputs {
    return new SetDischargeApprovalCall__Inputs(this);
  }

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

export class SetDischargeApprovalCall__Inputs {
  _call: SetDischargeApprovalCall;

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

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

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

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

export class SetDischargeApprovalCall__Outputs {
  _call: SetDischargeApprovalCall;

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

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

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

export class SetDischargeTimelockCall__Inputs {
  _call: SetDischargeTimelockCall;

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

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

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

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

export class SetDischargeTimelockCall__Outputs {
  _call: SetDischargeTimelockCall;

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

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

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

export class SetPermsForAllowBreakBondCall__Inputs {
  _call: SetPermsForAllowBreakBondCall;

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

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

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

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

export class SetPermsForAllowBreakBondCall__Outputs {
  _call: SetPermsForAllowBreakBondCall;

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

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

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

export class SetPermsForAllowDischargeCall__Inputs {
  _call: SetPermsForAllowDischargeCall;

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

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

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

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

export class SetPermsForAllowDischargeCall__Outputs {
  _call: SetPermsForAllowDischargeCall;

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

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

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

export class SetPermsForAllowReleaseCall__Inputs {
  _call: SetPermsForAllowReleaseCall;

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

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

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

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

export class SetPermsForAllowReleaseCall__Outputs {
  _call: SetPermsForAllowReleaseCall;

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

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

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

export class SetPermsForRestrictBondCall__Inputs {
  _call: SetPermsForRestrictBondCall;

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

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

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

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

export class SetPermsForRestrictBondCall__Outputs {
  _call: SetPermsForRestrictBondCall;

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

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

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

export class SetPermsForRestrictChargeCall__Inputs {
  _call: SetPermsForRestrictChargeCall;

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

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

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

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

export class SetPermsForRestrictChargeCall__Outputs {
  _call: SetPermsForRestrictChargeCall;

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

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

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

export class SetReleaseApprovalCall__Inputs {
  _call: SetReleaseApprovalCall;

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

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

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

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

export class SetReleaseApprovalCall__Outputs {
  _call: SetReleaseApprovalCall;

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

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

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

export class SetReleaseTimelockCall__Inputs {
  _call: SetReleaseTimelockCall;

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

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

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

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

export class SetReleaseTimelockCall__Outputs {
  _call: SetReleaseTimelockCall;

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

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

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

export class SetTemporaryLockCall__Inputs {
  _call: SetTemporaryLockCall;

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

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

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

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

export class SetTemporaryLockCall__Outputs {
  _call: SetTemporaryLockCall;

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

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

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

export class SetTimelockApprovalCall__Inputs {
  _call: SetTimelockApprovalCall;

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

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

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

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

export class SetTimelockApprovalCall__Outputs {
  _call: SetTimelockApprovalCall;

  constructor(call: SetTimelockApprovalCall) {
    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 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;
  }
}