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

import {
  TypedMap,
  Entity,
  Value,
  ValueKind,
  store,
  Bytes,
  BigInt,
  BigDecimal
} from "@graphprotocol/graph-ts";

export class GlobalData extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save GlobalData entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GlobalData entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GlobalData", id.toString(), this);
    }
  }

  static load(id: string): GlobalData | null {
    return changetype<GlobalData | null>(store.get("GlobalData", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get chargedParticlesAddress(): Bytes | null {
    let value = this.get("chargedParticlesAddress");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set chargedParticlesAddress(value: Bytes | null) {
    if (!value) {
      this.unset("chargedParticlesAddress");
    } else {
      this.set("chargedParticlesAddress", Value.fromBytes(<Bytes>value));
    }
  }
}

export class Universe extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save Universe entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save Universe entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("Universe", id.toString(), this);
    }
  }

  static load(id: string): Universe | null {
    return changetype<Universe | null>(store.get("Universe", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get chargedParticles(): string | null {
    let value = this.get("chargedParticles");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedParticles(value: string | null) {
    if (!value) {
      this.unset("chargedParticles");
    } else {
      this.set("chargedParticles", Value.fromString(<string>value));
    }
  }

  get ionxToken(): string | null {
    let value = this.get("ionxToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set ionxToken(value: string | null) {
    if (!value) {
      this.unset("ionxToken");
    } else {
      this.set("ionxToken", Value.fromString(<string>value));
    }
  }

  get ionxMaxSupply(): BigInt | null {
    let value = this.get("ionxMaxSupply");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set ionxMaxSupply(value: BigInt | null) {
    if (!value) {
      this.unset("ionxMaxSupply");
    } else {
      this.set("ionxMaxSupply", Value.fromBigInt(<BigInt>value));
    }
  }

  get protonToken(): string | null {
    let value = this.get("protonToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set protonToken(value: string | null) {
    if (!value) {
      this.unset("protonToken");
    } else {
      this.set("protonToken", Value.fromString(<string>value));
    }
  }

  get leptonToken(): string | null {
    let value = this.get("leptonToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set leptonToken(value: string | null) {
    if (!value) {
      this.unset("leptonToken");
    } else {
      this.set("leptonToken", Value.fromString(<string>value));
    }
  }

  get esaMultiplier(): Array<string> {
    let value = this.get("esaMultiplier");
    return value!.toStringArray();
  }

  set esaMultiplier(value: Array<string>) {
    this.set("esaMultiplier", Value.fromStringArray(value));
  }

  get esaLevel(): Array<string> {
    let value = this.get("esaLevel");
    return value!.toStringArray();
  }

  set esaLevel(value: Array<string>) {
    this.set("esaLevel", Value.fromStringArray(value));
  }
}

export class ChargedParticles extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ChargedParticles entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ChargedParticles entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ChargedParticles", id.toString(), this);
    }
  }

  static load(id: string): ChargedParticles | null {
    return changetype<ChargedParticles | null>(
      store.get("ChargedParticles", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get depositFee(): BigInt | null {
    let value = this.get("depositFee");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set depositFee(value: BigInt | null) {
    if (!value) {
      this.unset("depositFee");
    } else {
      this.set("depositFee", Value.fromBigInt(<BigInt>value));
    }
  }

  get universe(): string | null {
    let value = this.get("universe");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set universe(value: string | null) {
    if (!value) {
      this.unset("universe");
    } else {
      this.set("universe", Value.fromString(<string>value));
    }
  }

  get chargedSettings(): string | null {
    let value = this.get("chargedSettings");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedSettings(value: string | null) {
    if (!value) {
      this.unset("chargedSettings");
    } else {
      this.set("chargedSettings", Value.fromString(<string>value));
    }
  }

  get chargedState(): string | null {
    let value = this.get("chargedState");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedState(value: string | null) {
    if (!value) {
      this.unset("chargedState");
    } else {
      this.set("chargedState", Value.fromString(<string>value));
    }
  }

  get chargedManagers(): string | null {
    let value = this.get("chargedManagers");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedManagers(value: string | null) {
    if (!value) {
      this.unset("chargedManagers");
    } else {
      this.set("chargedManagers", Value.fromString(<string>value));
    }
  }

  get leptonToken(): string | null {
    let value = this.get("leptonToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set leptonToken(value: string | null) {
    if (!value) {
      this.unset("leptonToken");
    } else {
      this.set("leptonToken", Value.fromString(<string>value));
    }
  }

  get tokenInfoProxy(): Bytes | null {
    let value = this.get("tokenInfoProxy");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set tokenInfoProxy(value: Bytes | null) {
    if (!value) {
      this.unset("tokenInfoProxy");
    } else {
      this.set("tokenInfoProxy", Value.fromBytes(<Bytes>value));
    }
  }

  get trustedForwarder(): Bytes | null {
    let value = this.get("trustedForwarder");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set trustedForwarder(value: Bytes | null) {
    if (!value) {
      this.unset("trustedForwarder");
    } else {
      this.set("trustedForwarder", Value.fromBytes(<Bytes>value));
    }
  }
}

export class ChargedManagers extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ChargedManagers entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ChargedManagers entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ChargedManagers", id.toString(), this);
    }
  }

  static load(id: string): ChargedManagers | null {
    return changetype<ChargedManagers | null>(store.get("ChargedManagers", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get genericBasketManagers(): Array<string> | null {
    let value = this.get("genericBasketManagers");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toStringArray();
    }
  }

  set genericBasketManagers(value: Array<string> | null) {
    if (!value) {
      this.unset("genericBasketManagers");
    } else {
      this.set(
        "genericBasketManagers",
        Value.fromStringArray(<Array<string>>value)
      );
    }
  }

  get genericWalletManagers(): Array<string> | null {
    let value = this.get("genericWalletManagers");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toStringArray();
    }
  }

  set genericWalletManagers(value: Array<string> | null) {
    if (!value) {
      this.unset("genericWalletManagers");
    } else {
      this.set(
        "genericWalletManagers",
        Value.fromStringArray(<Array<string>>value)
      );
    }
  }

  get aaveWalletManagers(): Array<string> | null {
    let value = this.get("aaveWalletManagers");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toStringArray();
    }
  }

  set aaveWalletManagers(value: Array<string> | null) {
    if (!value) {
      this.unset("aaveWalletManagers");
    } else {
      this.set(
        "aaveWalletManagers",
        Value.fromStringArray(<Array<string>>value)
      );
    }
  }
}

export class ChargedSettings extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ChargedSettings entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ChargedSettings entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ChargedSettings", id.toString(), this);
    }
  }

  static load(id: string): ChargedSettings | null {
    return changetype<ChargedSettings | null>(store.get("ChargedSettings", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get depositCaps(): Array<string> {
    let value = this.get("depositCaps");
    return value!.toStringArray();
  }

  set depositCaps(value: Array<string>) {
    this.set("depositCaps", Value.fromStringArray(value));
  }

  get tempLockExpiryBlocks(): BigInt | null {
    let value = this.get("tempLockExpiryBlocks");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set tempLockExpiryBlocks(value: BigInt | null) {
    if (!value) {
      this.unset("tempLockExpiryBlocks");
    } else {
      this.set("tempLockExpiryBlocks", Value.fromBigInt(<BigInt>value));
    }
  }

  get nftSettings(): Array<string> {
    let value = this.get("nftSettings");
    return value!.toStringArray();
  }

  set nftSettings(value: Array<string>) {
    this.set("nftSettings", Value.fromStringArray(value));
  }

  get nftCreatorSettings(): Array<string> {
    let value = this.get("nftCreatorSettings");
    return value!.toStringArray();
  }

  set nftCreatorSettings(value: Array<string>) {
    this.set("nftCreatorSettings", Value.fromStringArray(value));
  }
}

export class NftSettings extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("chargedSettings", Value.fromString(""));
    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftSettings entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftSettings entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftSettings", id.toString(), this);
    }
  }

  static load(id: string): NftSettings | null {
    return changetype<NftSettings | null>(store.get("NftSettings", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get chargedSettings(): string {
    let value = this.get("chargedSettings");
    return value!.toString();
  }

  set chargedSettings(value: string) {
    this.set("chargedSettings", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get requiredWalletManager(): string | null {
    let value = this.get("requiredWalletManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set requiredWalletManager(value: string | null) {
    if (!value) {
      this.unset("requiredWalletManager");
    } else {
      this.set("requiredWalletManager", Value.fromString(<string>value));
    }
  }

  get requiredBasketManager(): string | null {
    let value = this.get("requiredBasketManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set requiredBasketManager(value: string | null) {
    if (!value) {
      this.unset("requiredBasketManager");
    } else {
      this.set("requiredBasketManager", Value.fromString(<string>value));
    }
  }

  get allowedAssetTokens(): Array<string> {
    let value = this.get("allowedAssetTokens");
    return value!.toStringArray();
  }

  set allowedAssetTokens(value: Array<string>) {
    this.set("allowedAssetTokens", Value.fromStringArray(value));
  }

  get assetDepositMin(): BigInt | null {
    let value = this.get("assetDepositMin");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set assetDepositMin(value: BigInt | null) {
    if (!value) {
      this.unset("assetDepositMin");
    } else {
      this.set("assetDepositMin", Value.fromBigInt(<BigInt>value));
    }
  }

  get assetDepositMax(): BigInt | null {
    let value = this.get("assetDepositMax");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set assetDepositMax(value: BigInt | null) {
    if (!value) {
      this.unset("assetDepositMax");
    } else {
      this.set("assetDepositMax", Value.fromBigInt(<BigInt>value));
    }
  }

  get maxNfts(): Array<string> {
    let value = this.get("maxNfts");
    return value!.toStringArray();
  }

  set maxNfts(value: Array<string>) {
    this.set("maxNfts", Value.fromStringArray(value));
  }

  get allowCharge(): boolean {
    let value = this.get("allowCharge");
    return value!.toBoolean();
  }

  set allowCharge(value: boolean) {
    this.set("allowCharge", Value.fromBoolean(value));
  }

  get allowBond(): boolean {
    let value = this.get("allowBond");
    return value!.toBoolean();
  }

  set allowBond(value: boolean) {
    this.set("allowBond", Value.fromBoolean(value));
  }

  get allowTimelockAnyNft(): boolean {
    let value = this.get("allowTimelockAnyNft");
    return value!.toBoolean();
  }

  set allowTimelockAnyNft(value: boolean) {
    this.set("allowTimelockAnyNft", Value.fromBoolean(value));
  }

  get allowTimelockOwnNft(): boolean {
    let value = this.get("allowTimelockOwnNft");
    return value!.toBoolean();
  }

  set allowTimelockOwnNft(value: boolean) {
    this.set("allowTimelockOwnNft", Value.fromBoolean(value));
  }

  get hasRestrictedAssets(): boolean {
    let value = this.get("hasRestrictedAssets");
    return value!.toBoolean();
  }

  set hasRestrictedAssets(value: boolean) {
    this.set("hasRestrictedAssets", Value.fromBoolean(value));
  }
}

export class AllowedAssetToken extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("nftSettings", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save AllowedAssetToken entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save AllowedAssetToken entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("AllowedAssetToken", id.toString(), this);
    }
  }

  static load(id: string): AllowedAssetToken | null {
    return changetype<AllowedAssetToken | null>(
      store.get("AllowedAssetToken", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get nftSettings(): string {
    let value = this.get("nftSettings");
    return value!.toString();
  }

  set nftSettings(value: string) {
    this.set("nftSettings", Value.fromString(value));
  }

  get assetToken(): Bytes | null {
    let value = this.get("assetToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set assetToken(value: Bytes | null) {
    if (!value) {
      this.unset("assetToken");
    } else {
      this.set("assetToken", Value.fromBytes(<Bytes>value));
    }
  }

  get isAllowed(): boolean {
    let value = this.get("isAllowed");
    return value!.toBoolean();
  }

  set isAllowed(value: boolean) {
    this.set("isAllowed", Value.fromBoolean(value));
  }
}

export class DepositCap extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("chargedSettings", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save DepositCap entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save DepositCap entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("DepositCap", id.toString(), this);
    }
  }

  static load(id: string): DepositCap | null {
    return changetype<DepositCap | null>(store.get("DepositCap", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get chargedSettings(): string {
    let value = this.get("chargedSettings");
    return value!.toString();
  }

  set chargedSettings(value: string) {
    this.set("chargedSettings", Value.fromString(value));
  }

  get assetToken(): Bytes | null {
    let value = this.get("assetToken");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set assetToken(value: Bytes | null) {
    if (!value) {
      this.unset("assetToken");
    } else {
      this.set("assetToken", Value.fromBytes(<Bytes>value));
    }
  }

  get maxDeposit(): BigInt | null {
    let value = this.get("maxDeposit");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxDeposit(value: BigInt | null) {
    if (!value) {
      this.unset("maxDeposit");
    } else {
      this.set("maxDeposit", Value.fromBigInt(<BigInt>value));
    }
  }
}

export class MaxNfts extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("nftSettings", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save MaxNfts entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save MaxNfts entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("MaxNfts", id.toString(), this);
    }
  }

  static load(id: string): MaxNfts | null {
    return changetype<MaxNfts | null>(store.get("MaxNfts", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get nftSettings(): string {
    let value = this.get("nftSettings");
    return value!.toString();
  }

  set nftSettings(value: string) {
    this.set("nftSettings", Value.fromString(value));
  }

  get tokenAddress(): Bytes | null {
    let value = this.get("tokenAddress");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set tokenAddress(value: Bytes | null) {
    if (!value) {
      this.unset("tokenAddress");
    } else {
      this.set("tokenAddress", Value.fromBytes(<Bytes>value));
    }
  }

  get maxNfts(): BigInt | null {
    let value = this.get("maxNfts");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxNfts(value: BigInt | null) {
    if (!value) {
      this.unset("maxNfts");
    } else {
      this.set("maxNfts", Value.fromBigInt(<BigInt>value));
    }
  }
}

export class NftCreatorSettings extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("chargedSettings", Value.fromString(""));
    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("creatorAddress", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftCreatorSettings entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftCreatorSettings entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftCreatorSettings", id.toString(), this);
    }
  }

  static load(id: string): NftCreatorSettings | null {
    return changetype<NftCreatorSettings | null>(
      store.get("NftCreatorSettings", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get chargedSettings(): string {
    let value = this.get("chargedSettings");
    return value!.toString();
  }

  set chargedSettings(value: string) {
    this.set("chargedSettings", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get creatorAddress(): Bytes {
    let value = this.get("creatorAddress");
    return value!.toBytes();
  }

  set creatorAddress(value: Bytes) {
    this.set("creatorAddress", Value.fromBytes(value));
  }

  get annuityPercent(): BigInt | null {
    let value = this.get("annuityPercent");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set annuityPercent(value: BigInt | null) {
    if (!value) {
      this.unset("annuityPercent");
    } else {
      this.set("annuityPercent", Value.fromBigInt(<BigInt>value));
    }
  }

  get annuityRedirect(): Bytes | null {
    let value = this.get("annuityRedirect");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set annuityRedirect(value: Bytes | null) {
    if (!value) {
      this.unset("annuityRedirect");
    } else {
      this.set("annuityRedirect", Value.fromBytes(<Bytes>value));
    }
  }
}

export class ChargedState extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ChargedState entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ChargedState entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ChargedState", id.toString(), this);
    }
  }

  static load(id: string): ChargedState | null {
    return changetype<ChargedState | null>(store.get("ChargedState", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get nftState(): Array<string> {
    let value = this.get("nftState");
    return value!.toStringArray();
  }

  set nftState(value: Array<string>) {
    this.set("nftState", Value.fromStringArray(value));
  }
}

export class NftState extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("chargedState", Value.fromString(""));
    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftState entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftState entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftState", id.toString(), this);
    }
  }

  static load(id: string): NftState | null {
    return changetype<NftState | null>(store.get("NftState", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get chargedState(): string {
    let value = this.get("chargedState");
    return value!.toString();
  }

  set chargedState(value: string) {
    this.set("chargedState", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get lastKnownOwner(): Bytes | null {
    let value = this.get("lastKnownOwner");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set lastKnownOwner(value: Bytes | null) {
    if (!value) {
      this.unset("lastKnownOwner");
    } else {
      this.set("lastKnownOwner", Value.fromBytes(<Bytes>value));
    }
  }

  get dischargeApproval(): Bytes | null {
    let value = this.get("dischargeApproval");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set dischargeApproval(value: Bytes | null) {
    if (!value) {
      this.unset("dischargeApproval");
    } else {
      this.set("dischargeApproval", Value.fromBytes(<Bytes>value));
    }
  }

  get releaseApproval(): Bytes | null {
    let value = this.get("releaseApproval");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set releaseApproval(value: Bytes | null) {
    if (!value) {
      this.unset("releaseApproval");
    } else {
      this.set("releaseApproval", Value.fromBytes(<Bytes>value));
    }
  }

  get breakBondApproval(): Bytes | null {
    let value = this.get("breakBondApproval");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set breakBondApproval(value: Bytes | null) {
    if (!value) {
      this.unset("breakBondApproval");
    } else {
      this.set("breakBondApproval", Value.fromBytes(<Bytes>value));
    }
  }

  get timelockApproval(): Bytes | null {
    let value = this.get("timelockApproval");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set timelockApproval(value: Bytes | null) {
    if (!value) {
      this.unset("timelockApproval");
    } else {
      this.set("timelockApproval", Value.fromBytes(<Bytes>value));
    }
  }

  get dischargeTimelockExpiry(): BigInt | null {
    let value = this.get("dischargeTimelockExpiry");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set dischargeTimelockExpiry(value: BigInt | null) {
    if (!value) {
      this.unset("dischargeTimelockExpiry");
    } else {
      this.set("dischargeTimelockExpiry", Value.fromBigInt(<BigInt>value));
    }
  }

  get dischargeTimelockLockedBy(): Bytes | null {
    let value = this.get("dischargeTimelockLockedBy");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set dischargeTimelockLockedBy(value: Bytes | null) {
    if (!value) {
      this.unset("dischargeTimelockLockedBy");
    } else {
      this.set("dischargeTimelockLockedBy", Value.fromBytes(<Bytes>value));
    }
  }

  get releaseTimelockExpiry(): BigInt | null {
    let value = this.get("releaseTimelockExpiry");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set releaseTimelockExpiry(value: BigInt | null) {
    if (!value) {
      this.unset("releaseTimelockExpiry");
    } else {
      this.set("releaseTimelockExpiry", Value.fromBigInt(<BigInt>value));
    }
  }

  get releaseTimelockLockedBy(): Bytes | null {
    let value = this.get("releaseTimelockLockedBy");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set releaseTimelockLockedBy(value: Bytes | null) {
    if (!value) {
      this.unset("releaseTimelockLockedBy");
    } else {
      this.set("releaseTimelockLockedBy", Value.fromBytes(<Bytes>value));
    }
  }

  get breakBondTimelockExpiry(): BigInt | null {
    let value = this.get("breakBondTimelockExpiry");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set breakBondTimelockExpiry(value: BigInt | null) {
    if (!value) {
      this.unset("breakBondTimelockExpiry");
    } else {
      this.set("breakBondTimelockExpiry", Value.fromBigInt(<BigInt>value));
    }
  }

  get breakBondTimelockLockedBy(): Bytes | null {
    let value = this.get("breakBondTimelockLockedBy");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set breakBondTimelockLockedBy(value: Bytes | null) {
    if (!value) {
      this.unset("breakBondTimelockLockedBy");
    } else {
      this.set("breakBondTimelockLockedBy", Value.fromBytes(<Bytes>value));
    }
  }

  get tempLockExpiry(): BigInt | null {
    let value = this.get("tempLockExpiry");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set tempLockExpiry(value: BigInt | null) {
    if (!value) {
      this.unset("tempLockExpiry");
    } else {
      this.set("tempLockExpiry", Value.fromBigInt(<BigInt>value));
    }
  }

  get restrictChargeFromAny(): boolean {
    let value = this.get("restrictChargeFromAny");
    return value!.toBoolean();
  }

  set restrictChargeFromAny(value: boolean) {
    this.set("restrictChargeFromAny", Value.fromBoolean(value));
  }

  get allowDischargeFromAny(): boolean {
    let value = this.get("allowDischargeFromAny");
    return value!.toBoolean();
  }

  set allowDischargeFromAny(value: boolean) {
    this.set("allowDischargeFromAny", Value.fromBoolean(value));
  }

  get allowReleaseFromAny(): boolean {
    let value = this.get("allowReleaseFromAny");
    return value!.toBoolean();
  }

  set allowReleaseFromAny(value: boolean) {
    this.set("allowReleaseFromAny", Value.fromBoolean(value));
  }

  get restrictBondFromAny(): boolean {
    let value = this.get("restrictBondFromAny");
    return value!.toBoolean();
  }

  set restrictBondFromAny(value: boolean) {
    this.set("restrictBondFromAny", Value.fromBoolean(value));
  }

  get allowBreakBondFromAny(): boolean {
    let value = this.get("allowBreakBondFromAny");
    return value!.toBoolean();
  }

  set allowBreakBondFromAny(value: boolean) {
    this.set("allowBreakBondFromAny", Value.fromBoolean(value));
  }
}

export class GenericBasketManager extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
    this.set("name", Value.fromString(""));
    this.set("address", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save GenericBasketManager entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericBasketManager entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericBasketManager", id.toString(), this);
    }
  }

  static load(id: string): GenericBasketManager | null {
    return changetype<GenericBasketManager | null>(
      store.get("GenericBasketManager", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get name(): string {
    let value = this.get("name");
    return value!.toString();
  }

  set name(value: string) {
    this.set("name", Value.fromString(value));
  }

  get address(): Bytes {
    let value = this.get("address");
    return value!.toBytes();
  }

  set address(value: Bytes) {
    this.set("address", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get chargedManager(): string | null {
    let value = this.get("chargedManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedManager(value: string | null) {
    if (!value) {
      this.unset("chargedManager");
    } else {
      this.set("chargedManager", Value.fromString(<string>value));
    }
  }

  get chargedParticles(): Bytes | null {
    let value = this.get("chargedParticles");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set chargedParticles(value: Bytes | null) {
    if (!value) {
      this.unset("chargedParticles");
    } else {
      this.set("chargedParticles", Value.fromBytes(<Bytes>value));
    }
  }

  get executor(): Bytes | null {
    let value = this.get("executor");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set executor(value: Bytes | null) {
    if (!value) {
      this.unset("executor");
    } else {
      this.set("executor", Value.fromBytes(<Bytes>value));
    }
  }

  get baskets(): Array<string> {
    let value = this.get("baskets");
    return value!.toStringArray();
  }

  set baskets(value: Array<string>) {
    this.set("baskets", Value.fromStringArray(value));
  }
}

export class GenericSmartBasket extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("totalTokens", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save GenericSmartBasket entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericSmartBasket entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericSmartBasket", id.toString(), this);
    }
  }

  static load(id: string): GenericSmartBasket | null {
    return changetype<GenericSmartBasket | null>(
      store.get("GenericSmartBasket", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get address(): Bytes | null {
    let value = this.get("address");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set address(value: Bytes | null) {
    if (!value) {
      this.unset("address");
    } else {
      this.set("address", Value.fromBytes(<Bytes>value));
    }
  }

  get basketManager(): string | null {
    let value = this.get("basketManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set basketManager(value: string | null) {
    if (!value) {
      this.unset("basketManager");
    } else {
      this.set("basketManager", Value.fromString(<string>value));
    }
  }

  get managerId(): string | null {
    let value = this.get("managerId");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set managerId(value: string | null) {
    if (!value) {
      this.unset("managerId");
    } else {
      this.set("managerId", Value.fromString(<string>value));
    }
  }

  get totalTokens(): BigInt {
    let value = this.get("totalTokens");
    return value!.toBigInt();
  }

  set totalTokens(value: BigInt) {
    this.set("totalTokens", Value.fromBigInt(value));
  }

  get tokenBalances(): Array<string> {
    let value = this.get("tokenBalances");
    return value!.toStringArray();
  }

  set tokenBalances(value: Array<string>) {
    this.set("tokenBalances", Value.fromStringArray(value));
  }
}

export class GenericNftTokenBalance extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("nftTokenAddress", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(
      id != null,
      "Cannot save GenericNftTokenBalance entity without an ID"
    );
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericNftTokenBalance entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericNftTokenBalance", id.toString(), this);
    }
  }

  static load(id: string): GenericNftTokenBalance | null {
    return changetype<GenericNftTokenBalance | null>(
      store.get("GenericNftTokenBalance", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get smartBasket(): string | null {
    let value = this.get("smartBasket");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set smartBasket(value: string | null) {
    if (!value) {
      this.unset("smartBasket");
    } else {
      this.set("smartBasket", Value.fromString(<string>value));
    }
  }

  get nftTokenAddress(): Bytes {
    let value = this.get("nftTokenAddress");
    return value!.toBytes();
  }

  set nftTokenAddress(value: Bytes) {
    this.set("nftTokenAddress", Value.fromBytes(value));
  }

  get nftTokenIds(): Array<BigInt> | null {
    let value = this.get("nftTokenIds");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigIntArray();
    }
  }

  set nftTokenIds(value: Array<BigInt> | null) {
    if (!value) {
      this.unset("nftTokenIds");
    } else {
      this.set("nftTokenIds", Value.fromBigIntArray(<Array<BigInt>>value));
    }
  }

  get nftsById(): Array<string> {
    let value = this.get("nftsById");
    return value!.toStringArray();
  }

  set nftsById(value: Array<string>) {
    this.set("nftsById", Value.fromStringArray(value));
  }
}

export class NftBalanceByTokenId extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("parent", Value.fromString(""));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("tokenBalance", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftBalanceByTokenId entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftBalanceByTokenId entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftBalanceByTokenId", id.toString(), this);
    }
  }

  static load(id: string): NftBalanceByTokenId | null {
    return changetype<NftBalanceByTokenId | null>(
      store.get("NftBalanceByTokenId", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get parent(): string {
    let value = this.get("parent");
    return value!.toString();
  }

  set parent(value: string) {
    this.set("parent", Value.fromString(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get tokenBalance(): BigInt {
    let value = this.get("tokenBalance");
    return value!.toBigInt();
  }

  set tokenBalance(value: BigInt) {
    this.set("tokenBalance", Value.fromBigInt(value));
  }
}

export class GenericWalletManager extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
    this.set("name", Value.fromString(""));
    this.set("address", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save GenericWalletManager entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericWalletManager entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericWalletManager", id.toString(), this);
    }
  }

  static load(id: string): GenericWalletManager | null {
    return changetype<GenericWalletManager | null>(
      store.get("GenericWalletManager", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get name(): string {
    let value = this.get("name");
    return value!.toString();
  }

  set name(value: string) {
    this.set("name", Value.fromString(value));
  }

  get address(): Bytes {
    let value = this.get("address");
    return value!.toBytes();
  }

  set address(value: Bytes) {
    this.set("address", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get chargedManager(): string | null {
    let value = this.get("chargedManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedManager(value: string | null) {
    if (!value) {
      this.unset("chargedManager");
    } else {
      this.set("chargedManager", Value.fromString(<string>value));
    }
  }

  get chargedParticles(): Bytes | null {
    let value = this.get("chargedParticles");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set chargedParticles(value: Bytes | null) {
    if (!value) {
      this.unset("chargedParticles");
    } else {
      this.set("chargedParticles", Value.fromBytes(<Bytes>value));
    }
  }

  get executor(): Bytes | null {
    let value = this.get("executor");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set executor(value: Bytes | null) {
    if (!value) {
      this.unset("executor");
    } else {
      this.set("executor", Value.fromBytes(<Bytes>value));
    }
  }

  get wallets(): Array<string> {
    let value = this.get("wallets");
    return value!.toStringArray();
  }

  set wallets(value: Array<string>) {
    this.set("wallets", Value.fromStringArray(value));
  }
}

export class GenericSmartWallet extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save GenericSmartWallet entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericSmartWallet entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericSmartWallet", id.toString(), this);
    }
  }

  static load(id: string): GenericSmartWallet | null {
    return changetype<GenericSmartWallet | null>(
      store.get("GenericSmartWallet", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get address(): Bytes | null {
    let value = this.get("address");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set address(value: Bytes | null) {
    if (!value) {
      this.unset("address");
    } else {
      this.set("address", Value.fromBytes(<Bytes>value));
    }
  }

  get walletManager(): string | null {
    let value = this.get("walletManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set walletManager(value: string | null) {
    if (!value) {
      this.unset("walletManager");
    } else {
      this.set("walletManager", Value.fromString(<string>value));
    }
  }

  get managerId(): string | null {
    let value = this.get("managerId");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set managerId(value: string | null) {
    if (!value) {
      this.unset("managerId");
    } else {
      this.set("managerId", Value.fromString(<string>value));
    }
  }

  get assetTokens(): Array<Bytes> | null {
    let value = this.get("assetTokens");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytesArray();
    }
  }

  set assetTokens(value: Array<Bytes> | null) {
    if (!value) {
      this.unset("assetTokens");
    } else {
      this.set("assetTokens", Value.fromBytesArray(<Array<Bytes>>value));
    }
  }

  get assetBalances(): Array<string> {
    let value = this.get("assetBalances");
    return value!.toStringArray();
  }

  set assetBalances(value: Array<string>) {
    this.set("assetBalances", Value.fromStringArray(value));
  }
}

export class GenericAssetTokenBalance extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("assetToken", Value.fromBytes(Bytes.empty()));
    this.set("name", Value.fromString(""));
    this.set("symbol", Value.fromString(""));
    this.set("decimals", Value.fromBigInt(BigInt.zero()));
    this.set("principal", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(
      id != null,
      "Cannot save GenericAssetTokenBalance entity without an ID"
    );
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save GenericAssetTokenBalance entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("GenericAssetTokenBalance", id.toString(), this);
    }
  }

  static load(id: string): GenericAssetTokenBalance | null {
    return changetype<GenericAssetTokenBalance | null>(
      store.get("GenericAssetTokenBalance", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get smartWallet(): string | null {
    let value = this.get("smartWallet");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set smartWallet(value: string | null) {
    if (!value) {
      this.unset("smartWallet");
    } else {
      this.set("smartWallet", Value.fromString(<string>value));
    }
  }

  get assetToken(): Bytes {
    let value = this.get("assetToken");
    return value!.toBytes();
  }

  set assetToken(value: Bytes) {
    this.set("assetToken", Value.fromBytes(value));
  }

  get name(): string {
    let value = this.get("name");
    return value!.toString();
  }

  set name(value: string) {
    this.set("name", Value.fromString(value));
  }

  get symbol(): string {
    let value = this.get("symbol");
    return value!.toString();
  }

  set symbol(value: string) {
    this.set("symbol", Value.fromString(value));
  }

  get decimals(): BigInt {
    let value = this.get("decimals");
    return value!.toBigInt();
  }

  set decimals(value: BigInt) {
    this.set("decimals", Value.fromBigInt(value));
  }

  get principal(): BigInt {
    let value = this.get("principal");
    return value!.toBigInt();
  }

  set principal(value: BigInt) {
    this.set("principal", Value.fromBigInt(value));
  }
}

export class AaveWalletManager extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
    this.set("name", Value.fromString(""));
    this.set("address", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save AaveWalletManager entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save AaveWalletManager entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("AaveWalletManager", id.toString(), this);
    }
  }

  static load(id: string): AaveWalletManager | null {
    return changetype<AaveWalletManager | null>(
      store.get("AaveWalletManager", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get name(): string {
    let value = this.get("name");
    return value!.toString();
  }

  set name(value: string) {
    this.set("name", Value.fromString(value));
  }

  get address(): Bytes {
    let value = this.get("address");
    return value!.toBytes();
  }

  set address(value: Bytes) {
    this.set("address", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get chargedManager(): string | null {
    let value = this.get("chargedManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedManager(value: string | null) {
    if (!value) {
      this.unset("chargedManager");
    } else {
      this.set("chargedManager", Value.fromString(<string>value));
    }
  }

  get chargedParticles(): Bytes | null {
    let value = this.get("chargedParticles");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set chargedParticles(value: Bytes | null) {
    if (!value) {
      this.unset("chargedParticles");
    } else {
      this.set("chargedParticles", Value.fromBytes(<Bytes>value));
    }
  }

  get aaveBridge(): Bytes | null {
    let value = this.get("aaveBridge");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set aaveBridge(value: Bytes | null) {
    if (!value) {
      this.unset("aaveBridge");
    } else {
      this.set("aaveBridge", Value.fromBytes(<Bytes>value));
    }
  }

  get executor(): Bytes | null {
    let value = this.get("executor");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set executor(value: Bytes | null) {
    if (!value) {
      this.unset("executor");
    } else {
      this.set("executor", Value.fromBytes(<Bytes>value));
    }
  }

  get wallets(): Array<string> {
    let value = this.get("wallets");
    return value!.toStringArray();
  }

  set wallets(value: Array<string>) {
    this.set("wallets", Value.fromStringArray(value));
  }
}

export class AaveSmartWallet extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save AaveSmartWallet entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save AaveSmartWallet entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("AaveSmartWallet", id.toString(), this);
    }
  }

  static load(id: string): AaveSmartWallet | null {
    return changetype<AaveSmartWallet | null>(store.get("AaveSmartWallet", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get address(): Bytes | null {
    let value = this.get("address");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set address(value: Bytes | null) {
    if (!value) {
      this.unset("address");
    } else {
      this.set("address", Value.fromBytes(<Bytes>value));
    }
  }

  get walletManager(): string | null {
    let value = this.get("walletManager");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set walletManager(value: string | null) {
    if (!value) {
      this.unset("walletManager");
    } else {
      this.set("walletManager", Value.fromString(<string>value));
    }
  }

  get managerId(): string | null {
    let value = this.get("managerId");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set managerId(value: string | null) {
    if (!value) {
      this.unset("managerId");
    } else {
      this.set("managerId", Value.fromString(<string>value));
    }
  }

  get assetTokens(): Array<Bytes> | null {
    let value = this.get("assetTokens");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytesArray();
    }
  }

  set assetTokens(value: Array<Bytes> | null) {
    if (!value) {
      this.unset("assetTokens");
    } else {
      this.set("assetTokens", Value.fromBytesArray(<Array<Bytes>>value));
    }
  }

  get nftCreator(): Bytes | null {
    let value = this.get("nftCreator");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set nftCreator(value: Bytes | null) {
    if (!value) {
      this.unset("nftCreator");
    } else {
      this.set("nftCreator", Value.fromBytes(<Bytes>value));
    }
  }

  get nftCreatorAnnuityPct(): BigInt | null {
    let value = this.get("nftCreatorAnnuityPct");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set nftCreatorAnnuityPct(value: BigInt | null) {
    if (!value) {
      this.unset("nftCreatorAnnuityPct");
    } else {
      this.set("nftCreatorAnnuityPct", Value.fromBigInt(<BigInt>value));
    }
  }

  get nftCreatorAnnuityRedirect(): Bytes | null {
    let value = this.get("nftCreatorAnnuityRedirect");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set nftCreatorAnnuityRedirect(value: Bytes | null) {
    if (!value) {
      this.unset("nftCreatorAnnuityRedirect");
    } else {
      this.set("nftCreatorAnnuityRedirect", Value.fromBytes(<Bytes>value));
    }
  }

  get assetBalances(): Array<string> {
    let value = this.get("assetBalances");
    return value!.toStringArray();
  }

  set assetBalances(value: Array<string>) {
    this.set("assetBalances", Value.fromStringArray(value));
  }
}

export class AaveAssetTokenBalance extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("assetToken", Value.fromBytes(Bytes.empty()));
    this.set("name", Value.fromString(""));
    this.set("symbol", Value.fromString(""));
    this.set("decimals", Value.fromBigInt(BigInt.zero()));
    this.set("principal", Value.fromBigInt(BigInt.zero()));
    this.set("ownerInterestDischarged", Value.fromBigInt(BigInt.zero()));
    this.set("creatorInterestDischarged", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(
      id != null,
      "Cannot save AaveAssetTokenBalance entity without an ID"
    );
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save AaveAssetTokenBalance entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("AaveAssetTokenBalance", id.toString(), this);
    }
  }

  static load(id: string): AaveAssetTokenBalance | null {
    return changetype<AaveAssetTokenBalance | null>(
      store.get("AaveAssetTokenBalance", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get smartWallet(): string | null {
    let value = this.get("smartWallet");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set smartWallet(value: string | null) {
    if (!value) {
      this.unset("smartWallet");
    } else {
      this.set("smartWallet", Value.fromString(<string>value));
    }
  }

  get assetToken(): Bytes {
    let value = this.get("assetToken");
    return value!.toBytes();
  }

  set assetToken(value: Bytes) {
    this.set("assetToken", Value.fromBytes(value));
  }

  get name(): string {
    let value = this.get("name");
    return value!.toString();
  }

  set name(value: string) {
    this.set("name", Value.fromString(value));
  }

  get symbol(): string {
    let value = this.get("symbol");
    return value!.toString();
  }

  set symbol(value: string) {
    this.set("symbol", Value.fromString(value));
  }

  get decimals(): BigInt {
    let value = this.get("decimals");
    return value!.toBigInt();
  }

  set decimals(value: BigInt) {
    this.set("decimals", Value.fromBigInt(value));
  }

  get principal(): BigInt {
    let value = this.get("principal");
    return value!.toBigInt();
  }

  set principal(value: BigInt) {
    this.set("principal", Value.fromBigInt(value));
  }

  get ownerInterestDischarged(): BigInt {
    let value = this.get("ownerInterestDischarged");
    return value!.toBigInt();
  }

  set ownerInterestDischarged(value: BigInt) {
    this.set("ownerInterestDischarged", Value.fromBigInt(value));
  }

  get creatorInterestDischarged(): BigInt {
    let value = this.get("creatorInterestDischarged");
    return value!.toBigInt();
  }

  set creatorInterestDischarged(value: BigInt) {
    this.set("creatorInterestDischarged", Value.fromBigInt(value));
  }
}

export class WBoson extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("wBoson", Value.fromBytes(Bytes.empty()));
    this.set("account", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save WBoson entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save WBoson entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("WBoson", id.toString(), this);
    }
  }

  static load(id: string): WBoson | null {
    return changetype<WBoson | null>(store.get("WBoson", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get wBoson(): Bytes {
    let value = this.get("wBoson");
    return value!.toBytes();
  }

  set wBoson(value: Bytes) {
    this.set("wBoson", Value.fromBytes(value));
  }

  get account(): Bytes {
    let value = this.get("account");
    return value!.toBytes();
  }

  set account(value: Bytes) {
    this.set("account", Value.fromBytes(value));
  }

  get discarded(): boolean {
    let value = this.get("discarded");
    return value!.toBoolean();
  }

  set discarded(value: boolean) {
    this.set("discarded", Value.fromBoolean(value));
  }

  get wBosonUri(): string | null {
    let value = this.get("wBosonUri");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set wBosonUri(value: string | null) {
    if (!value) {
      this.unset("wBosonUri");
    } else {
      this.set("wBosonUri", Value.fromString(<string>value));
    }
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get description(): string | null {
    let value = this.get("description");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set description(value: string | null) {
    if (!value) {
      this.unset("description");
    } else {
      this.set("description", Value.fromString(<string>value));
    }
  }

  get thumbnail(): string | null {
    let value = this.get("thumbnail");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set thumbnail(value: string | null) {
    if (!value) {
      this.unset("thumbnail");
    } else {
      this.set("thumbnail", Value.fromString(<string>value));
    }
  }

  get image(): string | null {
    let value = this.get("image");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set image(value: string | null) {
    if (!value) {
      this.unset("image");
    } else {
      this.set("image", Value.fromString(<string>value));
    }
  }

  get email(): string | null {
    let value = this.get("email");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set email(value: string | null) {
    if (!value) {
      this.unset("email");
    } else {
      this.set("email", Value.fromString(<string>value));
    }
  }

  get twitter(): string | null {
    let value = this.get("twitter");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set twitter(value: string | null) {
    if (!value) {
      this.unset("twitter");
    } else {
      this.set("twitter", Value.fromString(<string>value));
    }
  }

  get website(): string | null {
    let value = this.get("website");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set website(value: string | null) {
    if (!value) {
      this.unset("website");
    } else {
      this.set("website", Value.fromString(<string>value));
    }
  }
}

export class Ionx extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save Ionx entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save Ionx entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("Ionx", id.toString(), this);
    }
  }

  static load(id: string): Ionx | null {
    return changetype<Ionx | null>(store.get("Ionx", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get universe(): string | null {
    let value = this.get("universe");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set universe(value: string | null) {
    if (!value) {
      this.unset("universe");
    } else {
      this.set("universe", Value.fromString(<string>value));
    }
  }

  get holders(): Array<string> {
    let value = this.get("holders");
    return value!.toStringArray();
  }

  set holders(value: Array<string>) {
    this.set("holders", Value.fromStringArray(value));
  }
}

export class IonxHolder extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("ionx", Value.fromString(""));
    this.set("address", Value.fromBytes(Bytes.empty()));
    this.set("balance", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save IonxHolder entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save IonxHolder entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("IonxHolder", id.toString(), this);
    }
  }

  static load(id: string): IonxHolder | null {
    return changetype<IonxHolder | null>(store.get("IonxHolder", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get ionx(): string {
    let value = this.get("ionx");
    return value!.toString();
  }

  set ionx(value: string) {
    this.set("ionx", Value.fromString(value));
  }

  get address(): Bytes {
    let value = this.get("address");
    return value!.toBytes();
  }

  set address(value: Bytes) {
    this.set("address", Value.fromBytes(value));
  }

  get balance(): BigInt {
    let value = this.get("balance");
    return value!.toBigInt();
  }

  set balance(value: BigInt) {
    this.set("balance", Value.fromBigInt(value));
  }
}

export class ESAMultiplier extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("universe", Value.fromString(""));
    this.set("assetToken", Value.fromBytes(Bytes.empty()));
    this.set("multiplier", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ESAMultiplier entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ESAMultiplier entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ESAMultiplier", id.toString(), this);
    }
  }

  static load(id: string): ESAMultiplier | null {
    return changetype<ESAMultiplier | null>(store.get("ESAMultiplier", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get universe(): string {
    let value = this.get("universe");
    return value!.toString();
  }

  set universe(value: string) {
    this.set("universe", Value.fromString(value));
  }

  get assetToken(): Bytes {
    let value = this.get("assetToken");
    return value!.toBytes();
  }

  set assetToken(value: Bytes) {
    this.set("assetToken", Value.fromBytes(value));
  }

  get multiplier(): BigInt {
    let value = this.get("multiplier");
    return value!.toBigInt();
  }

  set multiplier(value: BigInt) {
    this.set("multiplier", Value.fromBigInt(value));
  }
}

export class ESALevel extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("universe", Value.fromString(""));
    this.set("accountAddress", Value.fromBytes(Bytes.empty()));
    this.set("level", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ESALevel entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ESALevel entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ESALevel", id.toString(), this);
    }
  }

  static load(id: string): ESALevel | null {
    return changetype<ESALevel | null>(store.get("ESALevel", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get universe(): string {
    let value = this.get("universe");
    return value!.toString();
  }

  set universe(value: string) {
    this.set("universe", Value.fromString(value));
  }

  get accountAddress(): Bytes {
    let value = this.get("accountAddress");
    return value!.toBytes();
  }

  set accountAddress(value: Bytes) {
    this.set("accountAddress", Value.fromBytes(value));
  }

  get level(): BigInt {
    let value = this.get("level");
    return value!.toBigInt();
  }

  set level(value: BigInt) {
    this.set("level", Value.fromBigInt(value));
  }
}

export class Proton extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("version", Value.fromString(""));
    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save Proton entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save Proton entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("Proton", id.toString(), this);
    }
  }

  static load(id: string): Proton | null {
    return changetype<Proton | null>(store.get("Proton", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get version(): string {
    let value = this.get("version");
    return value!.toString();
  }

  set version(value: string) {
    this.set("version", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get universe(): string | null {
    let value = this.get("universe");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set universe(value: string | null) {
    if (!value) {
      this.unset("universe");
    } else {
      this.set("universe", Value.fromString(<string>value));
    }
  }

  get chargedSettings(): string | null {
    let value = this.get("chargedSettings");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedSettings(value: string | null) {
    if (!value) {
      this.unset("chargedSettings");
    } else {
      this.set("chargedSettings", Value.fromString(<string>value));
    }
  }

  get chargedState(): string | null {
    let value = this.get("chargedState");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedState(value: string | null) {
    if (!value) {
      this.unset("chargedState");
    } else {
      this.set("chargedState", Value.fromString(<string>value));
    }
  }

  get chargedParticles(): string | null {
    let value = this.get("chargedParticles");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set chargedParticles(value: string | null) {
    if (!value) {
      this.unset("chargedParticles");
    } else {
      this.set("chargedParticles", Value.fromString(<string>value));
    }
  }

  get tokens(): Array<string> {
    let value = this.get("tokens");
    return value!.toStringArray();
  }

  set tokens(value: Array<string>) {
    this.set("tokens", Value.fromStringArray(value));
  }
}

export class ProtonNFT extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("version", Value.fromString(""));
    this.set("tokenAddress", Value.fromString(""));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("overallSalesTotal", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ProtonNFT entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ProtonNFT entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ProtonNFT", id.toString(), this);
    }
  }

  static load(id: string): ProtonNFT | null {
    return changetype<ProtonNFT | null>(store.get("ProtonNFT", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get version(): string {
    let value = this.get("version");
    return value!.toString();
  }

  set version(value: string) {
    this.set("version", Value.fromString(value));
  }

  get tokenAddress(): string {
    let value = this.get("tokenAddress");
    return value!.toString();
  }

  set tokenAddress(value: string) {
    this.set("tokenAddress", Value.fromString(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get proton(): string | null {
    let value = this.get("proton");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set proton(value: string | null) {
    if (!value) {
      this.unset("proton");
    } else {
      this.set("proton", Value.fromString(<string>value));
    }
  }

  get creator(): Bytes | null {
    let value = this.get("creator");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set creator(value: Bytes | null) {
    if (!value) {
      this.unset("creator");
    } else {
      this.set("creator", Value.fromBytes(<Bytes>value));
    }
  }

  get owner(): Bytes | null {
    let value = this.get("owner");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set owner(value: Bytes | null) {
    if (!value) {
      this.unset("owner");
    } else {
      this.set("owner", Value.fromBytes(<Bytes>value));
    }
  }

  get overallSalesTotal(): BigInt {
    let value = this.get("overallSalesTotal");
    return value!.toBigInt();
  }

  set overallSalesTotal(value: BigInt) {
    this.set("overallSalesTotal", Value.fromBigInt(value));
  }

  get particleType(): string | null {
    let value = this.get("particleType");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set particleType(value: string | null) {
    if (!value) {
      this.unset("particleType");
    } else {
      this.set("particleType", Value.fromString(<string>value));
    }
  }

  get creatorAnnuity(): BigInt | null {
    let value = this.get("creatorAnnuity");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set creatorAnnuity(value: BigInt | null) {
    if (!value) {
      this.unset("creatorAnnuity");
    } else {
      this.set("creatorAnnuity", Value.fromBigInt(<BigInt>value));
    }
  }

  get salePrice(): BigInt | null {
    let value = this.get("salePrice");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set salePrice(value: BigInt | null) {
    if (!value) {
      this.unset("salePrice");
    } else {
      this.set("salePrice", Value.fromBigInt(<BigInt>value));
    }
  }

  get lastSalePrice(): BigInt | null {
    let value = this.get("lastSalePrice");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set lastSalePrice(value: BigInt | null) {
    if (!value) {
      this.unset("lastSalePrice");
    } else {
      this.set("lastSalePrice", Value.fromBigInt(<BigInt>value));
    }
  }

  get resaleRoyalties(): BigInt | null {
    let value = this.get("resaleRoyalties");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set resaleRoyalties(value: BigInt | null) {
    if (!value) {
      this.unset("resaleRoyalties");
    } else {
      this.set("resaleRoyalties", Value.fromBigInt(<BigInt>value));
    }
  }

  get resaleRoyaltiesRedirect(): Bytes | null {
    let value = this.get("resaleRoyaltiesRedirect");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set resaleRoyaltiesRedirect(value: Bytes | null) {
    if (!value) {
      this.unset("resaleRoyaltiesRedirect");
    } else {
      this.set("resaleRoyaltiesRedirect", Value.fromBytes(<Bytes>value));
    }
  }

  get metadataUri(): string | null {
    let value = this.get("metadataUri");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set metadataUri(value: string | null) {
    if (!value) {
      this.unset("metadataUri");
    } else {
      this.set("metadataUri", Value.fromString(<string>value));
    }
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get description(): string | null {
    let value = this.get("description");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set description(value: string | null) {
    if (!value) {
      this.unset("description");
    } else {
      this.set("description", Value.fromString(<string>value));
    }
  }

  get external_url(): string | null {
    let value = this.get("external_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set external_url(value: string | null) {
    if (!value) {
      this.unset("external_url");
    } else {
      this.set("external_url", Value.fromString(<string>value));
    }
  }

  get animation_url(): string | null {
    let value = this.get("animation_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set animation_url(value: string | null) {
    if (!value) {
      this.unset("animation_url");
    } else {
      this.set("animation_url", Value.fromString(<string>value));
    }
  }

  get youtube_url(): string | null {
    let value = this.get("youtube_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set youtube_url(value: string | null) {
    if (!value) {
      this.unset("youtube_url");
    } else {
      this.set("youtube_url", Value.fromString(<string>value));
    }
  }

  get icon(): string | null {
    let value = this.get("icon");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set icon(value: string | null) {
    if (!value) {
      this.unset("icon");
    } else {
      this.set("icon", Value.fromString(<string>value));
    }
  }

  get thumbnail(): string | null {
    let value = this.get("thumbnail");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set thumbnail(value: string | null) {
    if (!value) {
      this.unset("thumbnail");
    } else {
      this.set("thumbnail", Value.fromString(<string>value));
    }
  }

  get image(): string | null {
    let value = this.get("image");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set image(value: string | null) {
    if (!value) {
      this.unset("image");
    } else {
      this.set("image", Value.fromString(<string>value));
    }
  }

  get symbol(): string | null {
    let value = this.get("symbol");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set symbol(value: string | null) {
    if (!value) {
      this.unset("symbol");
    } else {
      this.set("symbol", Value.fromString(<string>value));
    }
  }

  get decimals(): BigInt | null {
    let value = this.get("decimals");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set decimals(value: BigInt | null) {
    if (!value) {
      this.unset("decimals");
    } else {
      this.set("decimals", Value.fromBigInt(<BigInt>value));
    }
  }

  get background_color(): string | null {
    let value = this.get("background_color");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set background_color(value: string | null) {
    if (!value) {
      this.unset("background_color");
    } else {
      this.set("background_color", Value.fromString(<string>value));
    }
  }

  get attributes(): Array<string> {
    let value = this.get("attributes");
    return value!.toStringArray();
  }

  set attributes(value: Array<string>) {
    this.set("attributes", Value.fromStringArray(value));
  }
}

export class ProtonNftCount extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("createdCount", Value.fromBigInt(BigInt.zero()));
    this.set("ownedCount", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ProtonNftCount entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ProtonNftCount entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ProtonNftCount", id.toString(), this);
    }
  }

  static load(id: string): ProtonNftCount | null {
    return changetype<ProtonNftCount | null>(store.get("ProtonNftCount", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get createdCount(): BigInt {
    let value = this.get("createdCount");
    return value!.toBigInt();
  }

  set createdCount(value: BigInt) {
    this.set("createdCount", Value.fromBigInt(value));
  }

  get ownedCount(): BigInt {
    let value = this.get("ownedCount");
    return value!.toBigInt();
  }

  set ownedCount(value: BigInt) {
    this.set("ownedCount", Value.fromBigInt(value));
  }
}

export class ProtonNftAttributes extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("protonNft", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ProtonNftAttributes entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ProtonNftAttributes entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ProtonNftAttributes", id.toString(), this);
    }
  }

  static load(id: string): ProtonNftAttributes | null {
    return changetype<ProtonNftAttributes | null>(
      store.get("ProtonNftAttributes", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get protonNft(): string {
    let value = this.get("protonNft");
    return value!.toString();
  }

  set protonNft(value: string) {
    this.set("protonNft", Value.fromString(value));
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get value(): string | null {
    let value = this.get("value");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set value(value: string | null) {
    if (!value) {
      this.unset("value");
    } else {
      this.set("value", Value.fromString(<string>value));
    }
  }
}

export class StandardNFT extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("tokenAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save StandardNFT entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save StandardNFT entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("StandardNFT", id.toString(), this);
    }
  }

  static load(id: string): StandardNFT | null {
    return changetype<StandardNFT | null>(store.get("StandardNFT", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get tokenAddress(): Bytes {
    let value = this.get("tokenAddress");
    return value!.toBytes();
  }

  set tokenAddress(value: Bytes) {
    this.set("tokenAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get owner(): Bytes | null {
    let value = this.get("owner");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set owner(value: Bytes | null) {
    if (!value) {
      this.unset("owner");
    } else {
      this.set("owner", Value.fromBytes(<Bytes>value));
    }
  }

  get metadataUri(): string | null {
    let value = this.get("metadataUri");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set metadataUri(value: string | null) {
    if (!value) {
      this.unset("metadataUri");
    } else {
      this.set("metadataUri", Value.fromString(<string>value));
    }
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get description(): string | null {
    let value = this.get("description");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set description(value: string | null) {
    if (!value) {
      this.unset("description");
    } else {
      this.set("description", Value.fromString(<string>value));
    }
  }

  get external_url(): string | null {
    let value = this.get("external_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set external_url(value: string | null) {
    if (!value) {
      this.unset("external_url");
    } else {
      this.set("external_url", Value.fromString(<string>value));
    }
  }

  get icon(): string | null {
    let value = this.get("icon");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set icon(value: string | null) {
    if (!value) {
      this.unset("icon");
    } else {
      this.set("icon", Value.fromString(<string>value));
    }
  }

  get image(): string | null {
    let value = this.get("image");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set image(value: string | null) {
    if (!value) {
      this.unset("image");
    } else {
      this.set("image", Value.fromString(<string>value));
    }
  }

  get symbol(): string | null {
    let value = this.get("symbol");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set symbol(value: string | null) {
    if (!value) {
      this.unset("symbol");
    } else {
      this.set("symbol", Value.fromString(<string>value));
    }
  }

  get attributes(): Array<string> {
    let value = this.get("attributes");
    return value!.toStringArray();
  }

  set attributes(value: Array<string>) {
    this.set("attributes", Value.fromStringArray(value));
  }
}

export class StandardNftAttributes extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("standardNft", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(
      id != null,
      "Cannot save StandardNftAttributes entity without an ID"
    );
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save StandardNftAttributes entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("StandardNftAttributes", id.toString(), this);
    }
  }

  static load(id: string): StandardNftAttributes | null {
    return changetype<StandardNftAttributes | null>(
      store.get("StandardNftAttributes", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get standardNft(): string {
    let value = this.get("standardNft");
    return value!.toString();
  }

  set standardNft(value: string) {
    this.set("standardNft", Value.fromString(value));
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get value(): string | null {
    let value = this.get("value");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set value(value: string | null) {
    if (!value) {
      this.unset("value");
    } else {
      this.set("value", Value.fromString(<string>value));
    }
  }
}

export class Lepton extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save Lepton entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save Lepton entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("Lepton", id.toString(), this);
    }
  }

  static load(id: string): Lepton | null {
    return changetype<Lepton | null>(store.get("Lepton", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get totalMinted(): BigInt | null {
    let value = this.get("totalMinted");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set totalMinted(value: BigInt | null) {
    if (!value) {
      this.unset("totalMinted");
    } else {
      this.set("totalMinted", Value.fromBigInt(<BigInt>value));
    }
  }

  get typeIndex(): BigInt | null {
    let value = this.get("typeIndex");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set typeIndex(value: BigInt | null) {
    if (!value) {
      this.unset("typeIndex");
    } else {
      this.set("typeIndex", Value.fromBigInt(<BigInt>value));
    }
  }

  get maxSupply(): BigInt | null {
    let value = this.get("maxSupply");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxSupply(value: BigInt | null) {
    if (!value) {
      this.unset("maxSupply");
    } else {
      this.set("maxSupply", Value.fromBigInt(<BigInt>value));
    }
  }

  get maxMintPerTx(): BigInt | null {
    let value = this.get("maxMintPerTx");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxMintPerTx(value: BigInt | null) {
    if (!value) {
      this.unset("maxMintPerTx");
    } else {
      this.set("maxMintPerTx", Value.fromBigInt(<BigInt>value));
    }
  }

  get types(): Array<string> {
    let value = this.get("types");
    return value!.toStringArray();
  }

  set types(value: Array<string>) {
    this.set("types", Value.fromStringArray(value));
  }

  get tokens(): Array<string> {
    let value = this.get("tokens");
    return value!.toStringArray();
  }

  set tokens(value: Array<string>) {
    this.set("tokens", Value.fromStringArray(value));
  }
}

export class Lepton2 extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("owner", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save Lepton2 entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save Lepton2 entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("Lepton2", id.toString(), this);
    }
  }

  static load(id: string): Lepton2 | null {
    return changetype<Lepton2 | null>(store.get("Lepton2", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get owner(): Bytes {
    let value = this.get("owner");
    return value!.toBytes();
  }

  set owner(value: Bytes) {
    this.set("owner", Value.fromBytes(value));
  }

  get paused(): boolean {
    let value = this.get("paused");
    return value!.toBoolean();
  }

  set paused(value: boolean) {
    this.set("paused", Value.fromBoolean(value));
  }

  get totalMinted(): BigInt | null {
    let value = this.get("totalMinted");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set totalMinted(value: BigInt | null) {
    if (!value) {
      this.unset("totalMinted");
    } else {
      this.set("totalMinted", Value.fromBigInt(<BigInt>value));
    }
  }

  get typeIndex(): BigInt | null {
    let value = this.get("typeIndex");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set typeIndex(value: BigInt | null) {
    if (!value) {
      this.unset("typeIndex");
    } else {
      this.set("typeIndex", Value.fromBigInt(<BigInt>value));
    }
  }

  get maxSupply(): BigInt | null {
    let value = this.get("maxSupply");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxSupply(value: BigInt | null) {
    if (!value) {
      this.unset("maxSupply");
    } else {
      this.set("maxSupply", Value.fromBigInt(<BigInt>value));
    }
  }

  get maxMintPerTx(): BigInt | null {
    let value = this.get("maxMintPerTx");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set maxMintPerTx(value: BigInt | null) {
    if (!value) {
      this.unset("maxMintPerTx");
    } else {
      this.set("maxMintPerTx", Value.fromBigInt(<BigInt>value));
    }
  }

  get types(): Array<string> {
    let value = this.get("types");
    return value!.toStringArray();
  }

  set types(value: Array<string>) {
    this.set("types", Value.fromStringArray(value));
  }

  get tokens(): Array<string> {
    let value = this.get("tokens");
    return value!.toStringArray();
  }

  set tokens(value: Array<string>) {
    this.set("tokens", Value.fromStringArray(value));
  }
}

export class LeptonClassification extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save LeptonClassification entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save LeptonClassification entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("LeptonClassification", id.toString(), this);
    }
  }

  static load(id: string): LeptonClassification | null {
    return changetype<LeptonClassification | null>(
      store.get("LeptonClassification", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get lepton(): string | null {
    let value = this.get("lepton");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set lepton(value: string | null) {
    if (!value) {
      this.unset("lepton");
    } else {
      this.set("lepton", Value.fromString(<string>value));
    }
  }

  get lepton2(): string | null {
    let value = this.get("lepton2");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set lepton2(value: string | null) {
    if (!value) {
      this.unset("lepton2");
    } else {
      this.set("lepton2", Value.fromString(<string>value));
    }
  }

  get metadataUri(): string | null {
    let value = this.get("metadataUri");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set metadataUri(value: string | null) {
    if (!value) {
      this.unset("metadataUri");
    } else {
      this.set("metadataUri", Value.fromString(<string>value));
    }
  }

  get price(): BigInt | null {
    let value = this.get("price");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set price(value: BigInt | null) {
    if (!value) {
      this.unset("price");
    } else {
      this.set("price", Value.fromBigInt(<BigInt>value));
    }
  }

  get supply(): BigInt | null {
    let value = this.get("supply");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set supply(value: BigInt | null) {
    if (!value) {
      this.unset("supply");
    } else {
      this.set("supply", Value.fromBigInt(<BigInt>value));
    }
  }

  get multiplier(): BigInt | null {
    let value = this.get("multiplier");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set multiplier(value: BigInt | null) {
    if (!value) {
      this.unset("multiplier");
    } else {
      this.set("multiplier", Value.fromBigInt(<BigInt>value));
    }
  }

  get bonus(): BigInt | null {
    let value = this.get("bonus");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set bonus(value: BigInt | null) {
    if (!value) {
      this.unset("bonus");
    } else {
      this.set("bonus", Value.fromBigInt(<BigInt>value));
    }
  }

  get upperBounds(): BigInt | null {
    let value = this.get("upperBounds");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set upperBounds(value: BigInt | null) {
    if (!value) {
      this.unset("upperBounds");
    } else {
      this.set("upperBounds", Value.fromBigInt(<BigInt>value));
    }
  }
}

export class LeptonNFT extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save LeptonNFT entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save LeptonNFT entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("LeptonNFT", id.toString(), this);
    }
  }

  static load(id: string): LeptonNFT | null {
    return changetype<LeptonNFT | null>(store.get("LeptonNFT", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get lepton(): string | null {
    let value = this.get("lepton");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set lepton(value: string | null) {
    if (!value) {
      this.unset("lepton");
    } else {
      this.set("lepton", Value.fromString(<string>value));
    }
  }

  get lepton2(): string | null {
    let value = this.get("lepton2");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set lepton2(value: string | null) {
    if (!value) {
      this.unset("lepton2");
    } else {
      this.set("lepton2", Value.fromString(<string>value));
    }
  }

  get owner(): Bytes | null {
    let value = this.get("owner");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBytes();
    }
  }

  set owner(value: Bytes | null) {
    if (!value) {
      this.unset("owner");
    } else {
      this.set("owner", Value.fromBytes(<Bytes>value));
    }
  }

  get price(): BigInt | null {
    let value = this.get("price");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set price(value: BigInt | null) {
    if (!value) {
      this.unset("price");
    } else {
      this.set("price", Value.fromBigInt(<BigInt>value));
    }
  }

  get supply(): BigInt | null {
    let value = this.get("supply");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set supply(value: BigInt | null) {
    if (!value) {
      this.unset("supply");
    } else {
      this.set("supply", Value.fromBigInt(<BigInt>value));
    }
  }

  get multiplier(): BigInt | null {
    let value = this.get("multiplier");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set multiplier(value: BigInt | null) {
    if (!value) {
      this.unset("multiplier");
    } else {
      this.set("multiplier", Value.fromBigInt(<BigInt>value));
    }
  }

  get bonus(): BigInt | null {
    let value = this.get("bonus");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigInt();
    }
  }

  set bonus(value: BigInt | null) {
    if (!value) {
      this.unset("bonus");
    } else {
      this.set("bonus", Value.fromBigInt(<BigInt>value));
    }
  }

  get metadataUri(): string | null {
    let value = this.get("metadataUri");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set metadataUri(value: string | null) {
    if (!value) {
      this.unset("metadataUri");
    } else {
      this.set("metadataUri", Value.fromString(<string>value));
    }
  }

  get name(): string | null {
    let value = this.get("name");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set name(value: string | null) {
    if (!value) {
      this.unset("name");
    } else {
      this.set("name", Value.fromString(<string>value));
    }
  }

  get description(): string | null {
    let value = this.get("description");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set description(value: string | null) {
    if (!value) {
      this.unset("description");
    } else {
      this.set("description", Value.fromString(<string>value));
    }
  }

  get external_url(): string | null {
    let value = this.get("external_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set external_url(value: string | null) {
    if (!value) {
      this.unset("external_url");
    } else {
      this.set("external_url", Value.fromString(<string>value));
    }
  }

  get animation_url(): string | null {
    let value = this.get("animation_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set animation_url(value: string | null) {
    if (!value) {
      this.unset("animation_url");
    } else {
      this.set("animation_url", Value.fromString(<string>value));
    }
  }

  get youtube_url(): string | null {
    let value = this.get("youtube_url");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set youtube_url(value: string | null) {
    if (!value) {
      this.unset("youtube_url");
    } else {
      this.set("youtube_url", Value.fromString(<string>value));
    }
  }

  get thumbnail(): string | null {
    let value = this.get("thumbnail");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set thumbnail(value: string | null) {
    if (!value) {
      this.unset("thumbnail");
    } else {
      this.set("thumbnail", Value.fromString(<string>value));
    }
  }

  get image(): string | null {
    let value = this.get("image");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set image(value: string | null) {
    if (!value) {
      this.unset("image");
    } else {
      this.set("image", Value.fromString(<string>value));
    }
  }

  get symbol(): string | null {
    let value = this.get("symbol");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toString();
    }
  }

  set symbol(value: string | null) {
    if (!value) {
      this.unset("symbol");
    } else {
      this.set("symbol", Value.fromString(<string>value));
    }
  }
}

export class NftTxHistory extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("timestamp", Value.fromBigInt(BigInt.zero()));
    this.set("eventType", Value.fromString(""));
    this.set("eventData", Value.fromString(""));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftTxHistory entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftTxHistory entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftTxHistory", id.toString(), this);
    }
  }

  static load(id: string): NftTxHistory | null {
    return changetype<NftTxHistory | null>(store.get("NftTxHistory", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get timestamp(): BigInt {
    let value = this.get("timestamp");
    return value!.toBigInt();
  }

  set timestamp(value: BigInt) {
    this.set("timestamp", Value.fromBigInt(value));
  }

  get eventType(): string {
    let value = this.get("eventType");
    return value!.toString();
  }

  set eventType(value: string) {
    this.set("eventType", Value.fromString(value));
  }

  get eventData(): string {
    let value = this.get("eventData");
    return value!.toString();
  }

  set eventData(value: string) {
    this.set("eventData", Value.fromString(value));
  }
}

export class NftTxCount extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("count", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftTxCount entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftTxCount entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftTxCount", id.toString(), this);
    }
  }

  static load(id: string): NftTxCount | null {
    return changetype<NftTxCount | null>(store.get("NftTxCount", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get count(): BigInt {
    let value = this.get("count");
    return value!.toBigInt();
  }

  set count(value: BigInt) {
    this.set("count", Value.fromBigInt(value));
  }
}

export class UserRoyalty extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("accountAddress", Value.fromBytes(Bytes.empty()));
    this.set("claimableRoyalties", Value.fromBigInt(BigInt.zero()));
    this.set("royaltiesClaimed", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save UserRoyalty entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save UserRoyalty entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("UserRoyalty", id.toString(), this);
    }
  }

  static load(id: string): UserRoyalty | null {
    return changetype<UserRoyalty | null>(store.get("UserRoyalty", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get accountAddress(): Bytes {
    let value = this.get("accountAddress");
    return value!.toBytes();
  }

  set accountAddress(value: Bytes) {
    this.set("accountAddress", Value.fromBytes(value));
  }

  get claimableRoyalties(): BigInt {
    let value = this.get("claimableRoyalties");
    return value!.toBigInt();
  }

  set claimableRoyalties(value: BigInt) {
    this.set("claimableRoyalties", Value.fromBigInt(value));
  }

  get royaltiesClaimed(): BigInt {
    let value = this.get("royaltiesClaimed");
    return value!.toBigInt();
  }

  set royaltiesClaimed(value: BigInt) {
    this.set("royaltiesClaimed", Value.fromBigInt(value));
  }
}

export class ApprovedOperator extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("operatorAddress", Value.fromBytes(Bytes.empty()));
    this.set("ownerAddress", Value.fromBytes(Bytes.empty()));
    this.set("assetAddress", Value.fromBytes(Bytes.empty()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ApprovedOperator entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ApprovedOperator entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ApprovedOperator", id.toString(), this);
    }
  }

  static load(id: string): ApprovedOperator | null {
    return changetype<ApprovedOperator | null>(
      store.get("ApprovedOperator", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get operatorAddress(): Bytes {
    let value = this.get("operatorAddress");
    return value!.toBytes();
  }

  set operatorAddress(value: Bytes) {
    this.set("operatorAddress", Value.fromBytes(value));
  }

  get ownerAddress(): Bytes {
    let value = this.get("ownerAddress");
    return value!.toBytes();
  }

  set ownerAddress(value: Bytes) {
    this.set("ownerAddress", Value.fromBytes(value));
  }

  get assetAddress(): Bytes {
    let value = this.get("assetAddress");
    return value!.toBytes();
  }

  set assetAddress(value: Bytes) {
    this.set("assetAddress", Value.fromBytes(value));
  }

  get tokenIds(): Array<BigInt> | null {
    let value = this.get("tokenIds");
    if (!value || value.kind == ValueKind.NULL) {
      return null;
    } else {
      return value.toBigIntArray();
    }
  }

  set tokenIds(value: Array<BigInt> | null) {
    if (!value) {
      this.unset("tokenIds");
    } else {
      this.set("tokenIds", Value.fromBigIntArray(<Array<BigInt>>value));
    }
  }
}

export class AssetTokenAnalytic extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("totalAssetsLocked", Value.fromBigInt(BigInt.zero()));
    this.set("totalAssetsLockedAave", Value.fromBigInt(BigInt.zero()));
    this.set("totalAssetsLockedERC20", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save AssetTokenAnalytic entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save AssetTokenAnalytic entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("AssetTokenAnalytic", id.toString(), this);
    }
  }

  static load(id: string): AssetTokenAnalytic | null {
    return changetype<AssetTokenAnalytic | null>(
      store.get("AssetTokenAnalytic", id)
    );
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get totalAssetsLocked(): BigInt {
    let value = this.get("totalAssetsLocked");
    return value!.toBigInt();
  }

  set totalAssetsLocked(value: BigInt) {
    this.set("totalAssetsLocked", Value.fromBigInt(value));
  }

  get totalAssetsLockedAave(): BigInt {
    let value = this.get("totalAssetsLockedAave");
    return value!.toBigInt();
  }

  set totalAssetsLockedAave(value: BigInt) {
    this.set("totalAssetsLockedAave", Value.fromBigInt(value));
  }

  get totalAssetsLockedERC20(): BigInt {
    let value = this.get("totalAssetsLockedERC20");
    return value!.toBigInt();
  }

  set totalAssetsLockedERC20(value: BigInt) {
    this.set("totalAssetsLockedERC20", Value.fromBigInt(value));
  }
}

export class NftAnalytic extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("contractAddress", Value.fromBytes(Bytes.empty()));
    this.set("tokenId", Value.fromBigInt(BigInt.zero()));
    this.set("totalSalesVolume", Value.fromBigInt(BigInt.zero()));
    this.set("totalRoyalties", Value.fromBigInt(BigInt.zero()));
    this.set("numSales", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save NftAnalytic entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save NftAnalytic entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("NftAnalytic", id.toString(), this);
    }
  }

  static load(id: string): NftAnalytic | null {
    return changetype<NftAnalytic | null>(store.get("NftAnalytic", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get contractAddress(): Bytes {
    let value = this.get("contractAddress");
    return value!.toBytes();
  }

  set contractAddress(value: Bytes) {
    this.set("contractAddress", Value.fromBytes(value));
  }

  get tokenId(): BigInt {
    let value = this.get("tokenId");
    return value!.toBigInt();
  }

  set tokenId(value: BigInt) {
    this.set("tokenId", Value.fromBigInt(value));
  }

  get totalSalesVolume(): BigInt {
    let value = this.get("totalSalesVolume");
    return value!.toBigInt();
  }

  set totalSalesVolume(value: BigInt) {
    this.set("totalSalesVolume", Value.fromBigInt(value));
  }

  get totalRoyalties(): BigInt {
    let value = this.get("totalRoyalties");
    return value!.toBigInt();
  }

  set totalRoyalties(value: BigInt) {
    this.set("totalRoyalties", Value.fromBigInt(value));
  }

  get numSales(): BigInt {
    let value = this.get("numSales");
    return value!.toBigInt();
  }

  set numSales(value: BigInt) {
    this.set("numSales", Value.fromBigInt(value));
  }
}

export class ProfileMetric extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("totalEthEarned", Value.fromBigInt(BigInt.zero()));
    this.set("buyProtonCount", Value.fromBigInt(BigInt.zero()));
    this.set("sellProtonCount", Value.fromBigInt(BigInt.zero()));
    this.set("mintProtonCount", Value.fromBigInt(BigInt.zero()));
    this.set("buyLeptonCount", Value.fromBigInt(BigInt.zero()));
    this.set("transferLeptonCount", Value.fromBigInt(BigInt.zero()));
    this.set("energizeAaveCount", Value.fromBigInt(BigInt.zero()));
    this.set("energizeERC20Count", Value.fromBigInt(BigInt.zero()));
    this.set("dischargeInterestCount", Value.fromBigInt(BigInt.zero()));
    this.set("releaseMassCount", Value.fromBigInt(BigInt.zero()));
    this.set("royaltiesClaimedCount", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save ProfileMetric entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save ProfileMetric entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("ProfileMetric", id.toString(), this);
    }
  }

  static load(id: string): ProfileMetric | null {
    return changetype<ProfileMetric | null>(store.get("ProfileMetric", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get totalEthEarned(): BigInt {
    let value = this.get("totalEthEarned");
    return value!.toBigInt();
  }

  set totalEthEarned(value: BigInt) {
    this.set("totalEthEarned", Value.fromBigInt(value));
  }

  get buyProtonCount(): BigInt {
    let value = this.get("buyProtonCount");
    return value!.toBigInt();
  }

  set buyProtonCount(value: BigInt) {
    this.set("buyProtonCount", Value.fromBigInt(value));
  }

  get sellProtonCount(): BigInt {
    let value = this.get("sellProtonCount");
    return value!.toBigInt();
  }

  set sellProtonCount(value: BigInt) {
    this.set("sellProtonCount", Value.fromBigInt(value));
  }

  get mintProtonCount(): BigInt {
    let value = this.get("mintProtonCount");
    return value!.toBigInt();
  }

  set mintProtonCount(value: BigInt) {
    this.set("mintProtonCount", Value.fromBigInt(value));
  }

  get buyLeptonCount(): BigInt {
    let value = this.get("buyLeptonCount");
    return value!.toBigInt();
  }

  set buyLeptonCount(value: BigInt) {
    this.set("buyLeptonCount", Value.fromBigInt(value));
  }

  get transferLeptonCount(): BigInt {
    let value = this.get("transferLeptonCount");
    return value!.toBigInt();
  }

  set transferLeptonCount(value: BigInt) {
    this.set("transferLeptonCount", Value.fromBigInt(value));
  }

  get energizeAaveCount(): BigInt {
    let value = this.get("energizeAaveCount");
    return value!.toBigInt();
  }

  set energizeAaveCount(value: BigInt) {
    this.set("energizeAaveCount", Value.fromBigInt(value));
  }

  get energizeERC20Count(): BigInt {
    let value = this.get("energizeERC20Count");
    return value!.toBigInt();
  }

  set energizeERC20Count(value: BigInt) {
    this.set("energizeERC20Count", Value.fromBigInt(value));
  }

  get dischargeInterestCount(): BigInt {
    let value = this.get("dischargeInterestCount");
    return value!.toBigInt();
  }

  set dischargeInterestCount(value: BigInt) {
    this.set("dischargeInterestCount", Value.fromBigInt(value));
  }

  get releaseMassCount(): BigInt {
    let value = this.get("releaseMassCount");
    return value!.toBigInt();
  }

  set releaseMassCount(value: BigInt) {
    this.set("releaseMassCount", Value.fromBigInt(value));
  }

  get royaltiesClaimedCount(): BigInt {
    let value = this.get("royaltiesClaimedCount");
    return value!.toBigInt();
  }

  set royaltiesClaimedCount(value: BigInt) {
    this.set("royaltiesClaimedCount", Value.fromBigInt(value));
  }
}

export class UserTokenMetric extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("lifetimeValueLocked", Value.fromBigInt(BigInt.zero()));
    this.set("totalMassReleased", Value.fromBigInt(BigInt.zero()));
    this.set("totalInterestDischarged", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save UserTokenMetric entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save UserTokenMetric entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("UserTokenMetric", id.toString(), this);
    }
  }

  static load(id: string): UserTokenMetric | null {
    return changetype<UserTokenMetric | null>(store.get("UserTokenMetric", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get lifetimeValueLocked(): BigInt {
    let value = this.get("lifetimeValueLocked");
    return value!.toBigInt();
  }

  set lifetimeValueLocked(value: BigInt) {
    this.set("lifetimeValueLocked", Value.fromBigInt(value));
  }

  get totalMassReleased(): BigInt {
    let value = this.get("totalMassReleased");
    return value!.toBigInt();
  }

  set totalMassReleased(value: BigInt) {
    this.set("totalMassReleased", Value.fromBigInt(value));
  }

  get totalInterestDischarged(): BigInt {
    let value = this.get("totalInterestDischarged");
    return value!.toBigInt();
  }

  set totalInterestDischarged(value: BigInt) {
    this.set("totalInterestDischarged", Value.fromBigInt(value));
  }
}

export class PlatformMetric extends Entity {
  constructor(id: string) {
    super();
    this.set("id", Value.fromString(id));

    this.set("platformEthEarned", Value.fromBigInt(BigInt.zero()));
    this.set("platformInterestDischarged", Value.fromBigInt(BigInt.zero()));
    this.set("platformProtonsMinted", Value.fromBigInt(BigInt.zero()));
  }

  save(): void {
    let id = this.get("id");
    assert(id != null, "Cannot save PlatformMetric entity without an ID");
    if (id) {
      assert(
        id.kind == ValueKind.STRING,
        "Cannot save PlatformMetric entity with non-string ID. " +
          'Considering using .toHex() to convert the "id" to a string.'
      );
      store.set("PlatformMetric", id.toString(), this);
    }
  }

  static load(id: string): PlatformMetric | null {
    return changetype<PlatformMetric | null>(store.get("PlatformMetric", id));
  }

  get id(): string {
    let value = this.get("id");
    return value!.toString();
  }

  set id(value: string) {
    this.set("id", Value.fromString(value));
  }

  get platformEthEarned(): BigInt {
    let value = this.get("platformEthEarned");
    return value!.toBigInt();
  }

  set platformEthEarned(value: BigInt) {
    this.set("platformEthEarned", Value.fromBigInt(value));
  }

  get platformInterestDischarged(): BigInt {
    let value = this.get("platformInterestDischarged");
    return value!.toBigInt();
  }

  set platformInterestDischarged(value: BigInt) {
    this.set("platformInterestDischarged", Value.fromBigInt(value));
  }

  get platformProtonsMinted(): BigInt {
    let value = this.get("platformProtonsMinted");
    return value!.toBigInt();
  }

  set platformProtonsMinted(value: BigInt) {
    this.set("platformProtonsMinted", Value.fromBigInt(value));
  }
}