// 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 Approval extends ethereum.Event {
  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 approved(): Address {
    return this._event.parameters[1].value.toAddress();
  }

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

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

export class ApprovalForAll__Params {
  _event: ApprovalForAll;

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

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

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

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

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

export class ChargedParticlesSet__Params {
  _event: ChargedParticlesSet;

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

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

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

export class ChargedSettingsSet__Params {
  _event: ChargedSettingsSet;

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

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

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

export class ChargedStateSet__Params {
  _event: ChargedStateSet;

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

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

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

export class CreatorRoyaltiesSet__Params {
  _event: CreatorRoyaltiesSet;

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

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

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

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

export class FeesWithdrawn__Params {
  _event: FeesWithdrawn;

  constructor(event: FeesWithdrawn) {
    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 Locked extends ethereum.Event {
  get params(): Locked__Params {
    return new Locked__Params(this);
  }
}

export class Locked__Params {
  _event: Locked;

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

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

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

export class PausedStateSet__Params {
  _event: PausedStateSet;

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

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

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

export class ProtonSold__Params {
  _event: ProtonSold;

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

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

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

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

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

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

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

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

export class Received__Params {
  _event: Received;

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

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

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

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

export class RoyaltiesClaimed__Params {
  _event: RoyaltiesClaimed;

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

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

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

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

export class SalePriceSet__Params {
  _event: SalePriceSet;

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

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

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

export class Transfer extends ethereum.Event {
  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 tokenId(): BigInt {
    return this._event.parameters[2].value.toBigInt();
  }
}

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

export class TransferBatch__Params {
  _event: TransferBatch;

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

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

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

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

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

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

export class UniverseSet__Params {
  _event: UniverseSet;

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

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

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

export class Unlocked__Params {
  _event: Unlocked;

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

  get tokenId(): BigInt {
    return this._event.parameters[0].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 ProtonC extends ethereum.SmartContract {
  static bind(address: Address): ProtonC {
    return new ProtonC("ProtonC", address);
  }

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

    return result[0].toBigInt();
  }

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

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

    return result[0].toBigInt();
  }

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

  createProton(
    creator: Address,
    receiver: Address,
    tokenMetaUri: string
  ): BigInt {
    let result = super.call(
      "createProton",
      "createProton(address,address,string):(uint256)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromString(tokenMetaUri)
      ]
    );

    return result[0].toBigInt();
  }

  try_createProton(
    creator: Address,
    receiver: Address,
    tokenMetaUri: string
  ): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "createProton",
      "createProton(address,address,string):(uint256)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromString(tokenMetaUri)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  createProtons(
    creator: Address,
    receiver: Address,
    tokenMetaUris: Array<string>
  ): boolean {
    let result = super.call(
      "createProtons",
      "createProtons(address,address,string[]):(bool)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromStringArray(tokenMetaUris)
      ]
    );

    return result[0].toBoolean();
  }

  try_createProtons(
    creator: Address,
    receiver: Address,
    tokenMetaUris: Array<string>
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "createProtons",
      "createProtons(address,address,string[]):(bool)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromStringArray(tokenMetaUris)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

  createProtonsForSale(
    creator: Address,
    receiver: Address,
    royaltiesPercent: BigInt,
    tokenMetaUris: Array<string>,
    salePrices: Array<BigInt>
  ): boolean {
    let result = super.call(
      "createProtonsForSale",
      "createProtonsForSale(address,address,uint256,string[],uint256[]):(bool)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromUnsignedBigInt(royaltiesPercent),
        ethereum.Value.fromStringArray(tokenMetaUris),
        ethereum.Value.fromUnsignedBigIntArray(salePrices)
      ]
    );

    return result[0].toBoolean();
  }

  try_createProtonsForSale(
    creator: Address,
    receiver: Address,
    royaltiesPercent: BigInt,
    tokenMetaUris: Array<string>,
    salePrices: Array<BigInt>
  ): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "createProtonsForSale",
      "createProtonsForSale(address,address,uint256,string[],uint256[]):(bool)",
      [
        ethereum.Value.fromAddress(creator),
        ethereum.Value.fromAddress(receiver),
        ethereum.Value.fromUnsignedBigInt(royaltiesPercent),
        ethereum.Value.fromStringArray(tokenMetaUris),
        ethereum.Value.fromUnsignedBigIntArray(salePrices)
      ]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

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

    return result[0].toAddress();
  }

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

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

    return result[0].toAddress();
  }

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

  getCreatorRoyalties(account: Address): BigInt {
    let result = super.call(
      "getCreatorRoyalties",
      "getCreatorRoyalties(address):(uint256)",
      [ethereum.Value.fromAddress(account)]
    );

    return result[0].toBigInt();
  }

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

  getCreatorRoyaltiesPct(tokenId: BigInt): BigInt {
    let result = super.call(
      "getCreatorRoyaltiesPct",
      "getCreatorRoyaltiesPct(uint256):(uint256)",
      [ethereum.Value.fromUnsignedBigInt(tokenId)]
    );

    return result[0].toBigInt();
  }

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

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

    return result[0].toAddress();
  }

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

  getLastSellPrice(tokenId: BigInt): BigInt {
    let result = super.call(
      "getLastSellPrice",
      "getLastSellPrice(uint256):(uint256)",
      [ethereum.Value.fromUnsignedBigInt(tokenId)]
    );

    return result[0].toBigInt();
  }

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

  getSalePrice(tokenId: BigInt): BigInt {
    let result = super.call("getSalePrice", "getSalePrice(uint256):(uint256)", [
      ethereum.Value.fromUnsignedBigInt(tokenId)
    ]);

    return result[0].toBigInt();
  }

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

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

    return result[0].toBoolean();
  }

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

  locked(tokenId: BigInt): boolean {
    let result = super.call("locked", "locked(uint256):(bool)", [
      ethereum.Value.fromUnsignedBigInt(tokenId)
    ]);

    return result[0].toBoolean();
  }

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

  lockedTokens(param0: BigInt): boolean {
    let result = super.call("lockedTokens", "lockedTokens(uint256):(bool)", [
      ethereum.Value.fromUnsignedBigInt(param0)
    ]);

    return result[0].toBoolean();
  }

  try_lockedTokens(param0: BigInt): ethereum.CallResult<boolean> {
    let result = super.tryCall("lockedTokens", "lockedTokens(uint256):(bool)", [
      ethereum.Value.fromUnsignedBigInt(param0)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

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

    return result[0].toString();
  }

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

  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());
  }

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

    return result[0].toAddress();
  }

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

  supportsInterface(interfaceId: Bytes): boolean {
    let result = super.call(
      "supportsInterface",
      "supportsInterface(bytes4):(bool)",
      [ethereum.Value.fromFixedBytes(interfaceId)]
    );

    return result[0].toBoolean();
  }

  try_supportsInterface(interfaceId: Bytes): ethereum.CallResult<boolean> {
    let result = super.tryCall(
      "supportsInterface",
      "supportsInterface(bytes4):(bool)",
      [ethereum.Value.fromFixedBytes(interfaceId)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBoolean());
  }

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

    return result[0].toString();
  }

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

  tokenByIndex(index: BigInt): BigInt {
    let result = super.call("tokenByIndex", "tokenByIndex(uint256):(uint256)", [
      ethereum.Value.fromUnsignedBigInt(index)
    ]);

    return result[0].toBigInt();
  }

  try_tokenByIndex(index: BigInt): ethereum.CallResult<BigInt> {
    let result = super.tryCall(
      "tokenByIndex",
      "tokenByIndex(uint256):(uint256)",
      [ethereum.Value.fromUnsignedBigInt(index)]
    );
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toBigInt());
  }

  tokenOfOwnerByIndex(owner: Address, index: BigInt): BigInt {
    let result = super.call(
      "tokenOfOwnerByIndex",
      "tokenOfOwnerByIndex(address,uint256):(uint256)",
      [
        ethereum.Value.fromAddress(owner),
        ethereum.Value.fromUnsignedBigInt(index)
      ]
    );

    return result[0].toBigInt();
  }

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

  tokenURI(tokenId: BigInt): string {
    let result = super.call("tokenURI", "tokenURI(uint256):(string)", [
      ethereum.Value.fromUnsignedBigInt(tokenId)
    ]);

    return result[0].toString();
  }

  try_tokenURI(tokenId: BigInt): ethereum.CallResult<string> {
    let result = super.tryCall("tokenURI", "tokenURI(uint256):(string)", [
      ethereum.Value.fromUnsignedBigInt(tokenId)
    ]);
    if (result.reverted) {
      return new ethereum.CallResult();
    }
    let value = result.value;
    return ethereum.CallResult.fromValue(value[0].toString());
  }

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

    return result[0].toBigInt();
  }

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

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

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

export class ConstructorCall__Inputs {
  _call: ConstructorCall;

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

export class ConstructorCall__Outputs {
  _call: ConstructorCall;

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

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

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

export class ApproveCall__Outputs {
  _call: ApproveCall;

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

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

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

export class BurnCall__Inputs {
  _call: BurnCall;

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

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

export class BurnCall__Outputs {
  _call: BurnCall;

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

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

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

export class BuyProtonCall__Inputs {
  _call: BuyProtonCall;

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

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

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

export class BuyProtonCall__Outputs {
  _call: BuyProtonCall;

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

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

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

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

export class ClaimCreatorRoyaltiesCall__Inputs {
  _call: ClaimCreatorRoyaltiesCall;

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

export class ClaimCreatorRoyaltiesCall__Outputs {
  _call: ClaimCreatorRoyaltiesCall;

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

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

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

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

export class CreateBasicProtonCall__Inputs {
  _call: CreateBasicProtonCall;

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

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

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

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

export class CreateBasicProtonCall__Outputs {
  _call: CreateBasicProtonCall;

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

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

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

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

export class CreateBondedTokenCall__Inputs {
  _call: CreateBondedTokenCall;

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

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

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

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

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

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

export class CreateBondedTokenCall__Outputs {
  _call: CreateBondedTokenCall;

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

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

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

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

export class CreateChargedParticleCall__Inputs {
  _call: CreateChargedParticleCall;

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

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

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

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

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

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

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

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

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

export class CreateChargedParticleCall__Outputs {
  _call: CreateChargedParticleCall;

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

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

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

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

export class CreateProtonCall__Inputs {
  _call: CreateProtonCall;

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

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

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

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

export class CreateProtonCall__Outputs {
  _call: CreateProtonCall;

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

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

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

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

export class CreateProtonForSaleCall__Inputs {
  _call: CreateProtonForSaleCall;

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

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

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

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

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

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

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

export class CreateProtonForSaleCall__Outputs {
  _call: CreateProtonForSaleCall;

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

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

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

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

export class CreateProtonsCall__Inputs {
  _call: CreateProtonsCall;

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

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

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

  get tokenMetaUris(): Array<string> {
    return this._call.inputValues[2].value.toStringArray();
  }
}

export class CreateProtonsCall__Outputs {
  _call: CreateProtonsCall;

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

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

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

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

export class CreateProtonsForSaleCall__Inputs {
  _call: CreateProtonsForSaleCall;

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

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

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

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

  get tokenMetaUris(): Array<string> {
    return this._call.inputValues[3].value.toStringArray();
  }

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

export class CreateProtonsForSaleCall__Outputs {
  _call: CreateProtonsForSaleCall;

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

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

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

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

export class LockTokenCall__Inputs {
  _call: LockTokenCall;

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

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

export class LockTokenCall__Outputs {
  _call: LockTokenCall;

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

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

export class SafeTransferFromCall__Inputs {
  _call: SafeTransferFromCall;

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

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

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

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

export class SafeTransferFromCall__Outputs {
  _call: SafeTransferFromCall;

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

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

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

export class SafeTransferFrom1Call__Inputs {
  _call: SafeTransferFrom1Call;

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

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

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

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

  get _data(): Bytes {
    return this._call.inputValues[3].value.toBytes();
  }
}

export class SafeTransferFrom1Call__Outputs {
  _call: SafeTransferFrom1Call;

  constructor(call: SafeTransferFrom1Call) {
    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 operator(): Address {
    return this._call.inputValues[0].value.toAddress();
  }

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

export class SetApprovalForAllCall__Outputs {
  _call: SetApprovalForAllCall;

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

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

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

export class SetChargedParticlesCall__Inputs {
  _call: SetChargedParticlesCall;

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

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

export class SetChargedParticlesCall__Outputs {
  _call: SetChargedParticlesCall;

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

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

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

export class SetChargedSettingsCall__Inputs {
  _call: SetChargedSettingsCall;

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

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

export class SetChargedSettingsCall__Outputs {
  _call: SetChargedSettingsCall;

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

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

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

export class SetChargedStateCall__Inputs {
  _call: SetChargedStateCall;

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

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

export class SetChargedStateCall__Outputs {
  _call: SetChargedStateCall;

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

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

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

export class SetCreatorRoyaltiesReceiverCall__Inputs {
  _call: SetCreatorRoyaltiesReceiverCall;

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

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

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

export class SetCreatorRoyaltiesReceiverCall__Outputs {
  _call: SetCreatorRoyaltiesReceiverCall;

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

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

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

export class SetPausedStateCall__Inputs {
  _call: SetPausedStateCall;

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

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

export class SetPausedStateCall__Outputs {
  _call: SetPausedStateCall;

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

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

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

export class SetRoyaltiesPctCall__Inputs {
  _call: SetRoyaltiesPctCall;

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

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

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

export class SetRoyaltiesPctCall__Outputs {
  _call: SetRoyaltiesPctCall;

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

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

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

export class SetSalePriceCall__Inputs {
  _call: SetSalePriceCall;

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

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

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

export class SetSalePriceCall__Outputs {
  _call: SetSalePriceCall;

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

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

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

export class SetTrustedForwarderCall__Inputs {
  _call: SetTrustedForwarderCall;

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

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

export class SetTrustedForwarderCall__Outputs {
  _call: SetTrustedForwarderCall;

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

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

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

export class SetUniverseCall__Inputs {
  _call: SetUniverseCall;

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

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

export class SetUniverseCall__Outputs {
  _call: SetUniverseCall;

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

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

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

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

export class TransferFromCall__Outputs {
  _call: TransferFromCall;

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