import { Writer, Reader } from "as-proto";

export namespace nft {
  export class royalty {
    static encode(message: royalty, writer: Writer): void {
      if (message.percentage != 0) {
        writer.uint32(8);
        writer.uint64(message.percentage);
      }

      const unique_name_address = message.address;
      if (unique_name_address !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_address);
      }
    }

    static decode(reader: Reader, length: i32): royalty {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new royalty();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.percentage = reader.uint64();
            break;

          case 2:
            message.address = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    percentage: u64;
    address: Uint8Array | null;

    constructor(percentage: u64 = 0, address: Uint8Array | null = null) {
      this.percentage = percentage;
      this.address = address;
    }
  }

  export class royalties {
    static encode(message: royalties, writer: Writer): void {
      const unique_name_value = message.value;
      for (let i = 0; i < unique_name_value.length; ++i) {
        writer.uint32(10);
        writer.fork();
        royalty.encode(unique_name_value[i], writer);
        writer.ldelim();
      }
    }

    static decode(reader: Reader, length: i32): royalties {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new royalties();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.value.push(royalty.decode(reader, reader.uint32()));
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    value: Array<royalty>;

    constructor(value: Array<royalty> = []) {
      this.value = value;
    }
  }

  export class metadata_args {
    static encode(message: metadata_args, writer: Writer): void {
      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_token_id);
      }

      const unique_name_metadata = message.metadata;
      if (unique_name_metadata !== null) {
        writer.uint32(18);
        writer.string(unique_name_metadata);
      }
    }

    static decode(reader: Reader, length: i32): metadata_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new metadata_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.token_id = reader.bytes();
            break;

          case 2:
            message.metadata = reader.string();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    token_id: Uint8Array | null;
    metadata: string | null;

    constructor(
      token_id: Uint8Array | null = null,
      metadata: string | null = null
    ) {
      this.token_id = token_id;
      this.metadata = metadata;
    }
  }

  export class info {
    static encode(message: info, writer: Writer): void {
      const unique_name_name = message.name;
      if (unique_name_name !== null) {
        writer.uint32(10);
        writer.string(unique_name_name);
      }

      const unique_name_symbol = message.symbol;
      if (unique_name_symbol !== null) {
        writer.uint32(18);
        writer.string(unique_name_symbol);
      }

      const unique_name_uri = message.uri;
      if (unique_name_uri !== null) {
        writer.uint32(26);
        writer.string(unique_name_uri);
      }

      const unique_name_description = message.description;
      if (unique_name_description !== null) {
        writer.uint32(34);
        writer.string(unique_name_description);
      }
    }

    static decode(reader: Reader, length: i32): info {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new info();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.name = reader.string();
            break;

          case 2:
            message.symbol = reader.string();
            break;

          case 3:
            message.uri = reader.string();
            break;

          case 4:
            message.description = reader.string();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    name: string | null;
    symbol: string | null;
    uri: string | null;
    description: string | null;

    constructor(
      name: string | null = null,
      symbol: string | null = null,
      uri: string | null = null,
      description: string | null = null
    ) {
      this.name = name;
      this.symbol = symbol;
      this.uri = uri;
      this.description = description;
    }
  }

  export class balance_of_args {
    static encode(message: balance_of_args, writer: Writer): void {
      const unique_name_owner = message.owner;
      if (unique_name_owner !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_owner);
      }
    }

    static decode(reader: Reader, length: i32): balance_of_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new balance_of_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.owner = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    owner: Uint8Array | null;

    constructor(owner: Uint8Array | null = null) {
      this.owner = owner;
    }
  }

  export class token {
    static encode(message: token, writer: Writer): void {
      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_token_id);
      }
    }

    static decode(reader: Reader, length: i32): token {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new token();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.token_id = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    token_id: Uint8Array | null;

    constructor(token_id: Uint8Array | null = null) {
      this.token_id = token_id;
    }
  }

  export class is_approved_for_all_args {
    static encode(message: is_approved_for_all_args, writer: Writer): void {
      const unique_name_owner = message.owner;
      if (unique_name_owner !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_owner);
      }

      const unique_name_operator = message.operator;
      if (unique_name_operator !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_operator);
      }
    }

    static decode(reader: Reader, length: i32): is_approved_for_all_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new is_approved_for_all_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.owner = reader.bytes();
            break;

          case 2:
            message.operator = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    owner: Uint8Array | null;
    operator: Uint8Array | null;

    constructor(
      owner: Uint8Array | null = null,
      operator: Uint8Array | null = null
    ) {
      this.owner = owner;
      this.operator = operator;
    }
  }

  export class mint_args {
    static encode(message: mint_args, writer: Writer): void {
      const unique_name_to = message.to;
      if (unique_name_to !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_to);
      }

      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_token_id);
      }
    }

    static decode(reader: Reader, length: i32): mint_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new mint_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.to = reader.bytes();
            break;

          case 2:
            message.token_id = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    to: Uint8Array | null;
    token_id: Uint8Array | null;

    constructor(
      to: Uint8Array | null = null,
      token_id: Uint8Array | null = null
    ) {
      this.to = to;
      this.token_id = token_id;
    }
  }

  export class burn_args {
    static encode(message: burn_args, writer: Writer): void {
      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_token_id);
      }
    }

    static decode(reader: Reader, length: i32): burn_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new burn_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.token_id = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    token_id: Uint8Array | null;

    constructor(token_id: Uint8Array | null = null) {
      this.token_id = token_id;
    }
  }

  export class transfer_args {
    static encode(message: transfer_args, writer: Writer): void {
      const unique_name_from = message.from;
      if (unique_name_from !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_from);
      }

      const unique_name_to = message.to;
      if (unique_name_to !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_to);
      }

      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(26);
        writer.bytes(unique_name_token_id);
      }

      const unique_name_memo = message.memo;
      if (unique_name_memo !== null) {
        writer.uint32(34);
        writer.string(unique_name_memo);
      }
    }

    static decode(reader: Reader, length: i32): transfer_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new transfer_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.from = reader.bytes();
            break;

          case 2:
            message.to = reader.bytes();
            break;

          case 3:
            message.token_id = reader.bytes();
            break;

          case 4:
            message.memo = reader.string();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    from: Uint8Array | null;
    to: Uint8Array | null;
    token_id: Uint8Array | null;
    memo: string | null;

    constructor(
      from: Uint8Array | null = null,
      to: Uint8Array | null = null,
      token_id: Uint8Array | null = null,
      memo: string | null = null
    ) {
      this.from = from;
      this.to = to;
      this.token_id = token_id;
      this.memo = memo;
    }
  }

  export class approve_args {
    static encode(message: approve_args, writer: Writer): void {
      const unique_name_approver_address = message.approver_address;
      if (unique_name_approver_address !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_approver_address);
      }

      const unique_name_to = message.to;
      if (unique_name_to !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_to);
      }

      const unique_name_token_id = message.token_id;
      if (unique_name_token_id !== null) {
        writer.uint32(26);
        writer.bytes(unique_name_token_id);
      }
    }

    static decode(reader: Reader, length: i32): approve_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new approve_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.approver_address = reader.bytes();
            break;

          case 2:
            message.to = reader.bytes();
            break;

          case 3:
            message.token_id = reader.bytes();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    approver_address: Uint8Array | null;
    to: Uint8Array | null;
    token_id: Uint8Array | null;

    constructor(
      approver_address: Uint8Array | null = null,
      to: Uint8Array | null = null,
      token_id: Uint8Array | null = null
    ) {
      this.approver_address = approver_address;
      this.to = to;
      this.token_id = token_id;
    }
  }

  export class set_approval_for_all_args {
    static encode(message: set_approval_for_all_args, writer: Writer): void {
      const unique_name_approver_address = message.approver_address;
      if (unique_name_approver_address !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_approver_address);
      }

      const unique_name_operator_address = message.operator_address;
      if (unique_name_operator_address !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_operator_address);
      }

      if (message.approved != false) {
        writer.uint32(24);
        writer.bool(message.approved);
      }
    }

    static decode(reader: Reader, length: i32): set_approval_for_all_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new set_approval_for_all_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.approver_address = reader.bytes();
            break;

          case 2:
            message.operator_address = reader.bytes();
            break;

          case 3:
            message.approved = reader.bool();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    approver_address: Uint8Array | null;
    operator_address: Uint8Array | null;
    approved: bool;

    constructor(
      approver_address: Uint8Array | null = null,
      operator_address: Uint8Array | null = null,
      approved: bool = false
    ) {
      this.approver_address = approver_address;
      this.operator_address = operator_address;
      this.approved = approved;
    }
  }

  export class get_operators_args {
    static encode(message: get_operators_args, writer: Writer): void {
      const unique_name_owner = message.owner;
      if (unique_name_owner !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_owner);
      }

      const unique_name_start = message.start;
      if (unique_name_start !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_start);
      }

      if (message.limit != 0) {
        writer.uint32(24);
        writer.int32(message.limit);
      }

      if (message.descending != false) {
        writer.uint32(32);
        writer.bool(message.descending);
      }
    }

    static decode(reader: Reader, length: i32): get_operators_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_operators_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.owner = reader.bytes();
            break;

          case 2:
            message.start = reader.bytes();
            break;

          case 3:
            message.limit = reader.int32();
            break;

          case 4:
            message.descending = reader.bool();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    owner: Uint8Array | null;
    start: Uint8Array | null;
    limit: i32;
    descending: bool;

    constructor(
      owner: Uint8Array | null = null,
      start: Uint8Array | null = null,
      limit: i32 = 0,
      descending: bool = false
    ) {
      this.owner = owner;
      this.start = start;
      this.limit = limit;
      this.descending = descending;
    }
  }

  export class get_operators_return {
    static encode(message: get_operators_return, writer: Writer): void {
      const unique_name_owner = message.owner;
      if (unique_name_owner !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_owner);
      }

      const unique_name_operators = message.operators;
      if (unique_name_operators.length !== 0) {
        for (let i = 0; i < unique_name_operators.length; ++i) {
          writer.uint32(18);
          writer.bytes(unique_name_operators[i]);
        }
      }
    }

    static decode(reader: Reader, length: i32): get_operators_return {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_operators_return();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.owner = reader.bytes();
            break;

          case 2:
            message.operators.push(reader.bytes());
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    owner: Uint8Array | null;
    operators: Array<Uint8Array>;

    constructor(
      owner: Uint8Array | null = null,
      operators: Array<Uint8Array> = []
    ) {
      this.owner = owner;
      this.operators = operators;
    }
  }

  export class get_tokens_args {
    static encode(message: get_tokens_args, writer: Writer): void {
      const unique_name_start = message.start;
      if (unique_name_start !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_start);
      }

      if (message.limit != 0) {
        writer.uint32(16);
        writer.int32(message.limit);
      }

      if (message.descending != false) {
        writer.uint32(24);
        writer.bool(message.descending);
      }
    }

    static decode(reader: Reader, length: i32): get_tokens_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_tokens_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.start = reader.bytes();
            break;

          case 2:
            message.limit = reader.int32();
            break;

          case 3:
            message.descending = reader.bool();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    start: Uint8Array | null;
    limit: i32;
    descending: bool;

    constructor(
      start: Uint8Array | null = null,
      limit: i32 = 0,
      descending: bool = false
    ) {
      this.start = start;
      this.limit = limit;
      this.descending = descending;
    }
  }

  export class get_tokens_by_owner_args {
    static encode(message: get_tokens_by_owner_args, writer: Writer): void {
      const unique_name_owner = message.owner;
      if (unique_name_owner !== null) {
        writer.uint32(10);
        writer.bytes(unique_name_owner);
      }

      const unique_name_start = message.start;
      if (unique_name_start !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_start);
      }

      if (message.limit != 0) {
        writer.uint32(24);
        writer.int32(message.limit);
      }

      if (message.descending != false) {
        writer.uint32(32);
        writer.bool(message.descending);
      }
    }

    static decode(reader: Reader, length: i32): get_tokens_by_owner_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_tokens_by_owner_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.owner = reader.bytes();
            break;

          case 2:
            message.start = reader.bytes();
            break;

          case 3:
            message.limit = reader.int32();
            break;

          case 4:
            message.descending = reader.bool();
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    owner: Uint8Array | null;
    start: Uint8Array | null;
    limit: i32;
    descending: bool;

    constructor(
      owner: Uint8Array | null = null,
      start: Uint8Array | null = null,
      limit: i32 = 0,
      descending: bool = false
    ) {
      this.owner = owner;
      this.start = start;
      this.limit = limit;
      this.descending = descending;
    }
  }

  export class token_ids {
    static encode(message: token_ids, writer: Writer): void {
      const unique_name_token_ids = message.token_ids;
      if (unique_name_token_ids.length !== 0) {
        for (let i = 0; i < unique_name_token_ids.length; ++i) {
          writer.uint32(10);
          writer.bytes(unique_name_token_ids[i]);
        }
      }
    }

    static decode(reader: Reader, length: i32): token_ids {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new token_ids();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.token_ids.push(reader.bytes());
            break;

          default:
            reader.skipType(tag & 7);
            break;
        }
      }

      return message;
    }

    token_ids: Array<Uint8Array>;

    constructor(token_ids: Array<Uint8Array> = []) {
      this.token_ids = token_ids;
    }
  }
}