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

export namespace nicknames {
  export class tabi_item {
    static encode(message: tabi_item, writer: Writer): void {
      const unique_name_pattern = message.pattern;
      if (unique_name_pattern !== null) {
        writer.uint32(10);
        writer.string(unique_name_pattern);
      }

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

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

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

          case 2:
            message.entry_point = reader.uint32();
            break;

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

      return message;
    }

    pattern: string | null;
    entry_point: u32;

    constructor(pattern: string | null = null, entry_point: u32 = 0) {
      this.pattern = pattern;
      this.entry_point = entry_point;
    }
  }

  export class tabi {
    static encode(message: tabi, writer: Writer): void {
      const unique_name_items = message.items;
      for (let i = 0; i < unique_name_items.length; ++i) {
        writer.uint32(10);
        writer.fork();
        tabi_item.encode(unique_name_items[i], writer);
        writer.ldelim();
      }
    }

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

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

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

      return message;
    }

    items: Array<tabi_item>;

    constructor(items: Array<tabi_item> = []) {
      this.items = items;
    }
  }

  export class get_tabi_result {
    static encode(message: get_tabi_result, writer: Writer): void {
      const unique_name_items = message.items;
      for (let i = 0; i < unique_name_items.length; ++i) {
        writer.uint32(10);
        writer.fork();
        tabi_item.encode(unique_name_items[i], writer);
        writer.ldelim();
      }

      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): get_tabi_result {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_tabi_result();

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

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

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

      return message;
    }

    items: Array<tabi_item>;
    address: Uint8Array | null;

    constructor(
      items: Array<tabi_item> = [],
      address: Uint8Array | null = null
    ) {
      this.items = items;
      this.address = address;
    }
  }

  export class set_tabi_args {
    static encode(message: set_tabi_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_tabi = message.tabi;
      if (unique_name_tabi !== null) {
        writer.uint32(18);
        writer.fork();
        tabi.encode(unique_name_tabi, writer);
        writer.ldelim();
      }
    }

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

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

          case 2:
            message.tabi = tabi.decode(reader, reader.uint32());
            break;

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

      return message;
    }

    token_id: Uint8Array | null;
    tabi: tabi | null;

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

  export class set_address_args {
    static encode(message: set_address_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_address = message.address;
      if (unique_name_address !== null) {
        writer.uint32(18);
        writer.bytes(unique_name_address);
      }

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

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

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

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

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

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

      return message;
    }

    token_id: Uint8Array | null;
    address: Uint8Array | null;
    gov_proposal_update: bool;

    constructor(
      token_id: Uint8Array | null = null,
      address: Uint8Array | null = null,
      gov_proposal_update: bool = false
    ) {
      this.token_id = token_id;
      this.address = address;
      this.gov_proposal_update = gov_proposal_update;
    }
  }

  export class set_extended_metadata_args {
    static encode(message: set_extended_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);
      }

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

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

      const unique_name_other = message.other;
      if (unique_name_other !== null) {
        writer.uint32(82);
        writer.bytes(unique_name_other);
      }
    }

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

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

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

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

          case 10:
            message.other = reader.bytes();
            break;

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

      return message;
    }

    token_id: Uint8Array | null;
    permanent_address: bool;
    address_modifiable_only_by_governance: bool;
    other: Uint8Array | null;

    constructor(
      token_id: Uint8Array | null = null,
      permanent_address: bool = false,
      address_modifiable_only_by_governance: bool = false,
      other: Uint8Array | null = null
    ) {
      this.token_id = token_id;
      this.permanent_address = permanent_address;
      this.address_modifiable_only_by_governance =
        address_modifiable_only_by_governance;
      this.other = other;
    }
  }

  export class extended_metadata {
    static encode(message: extended_metadata, 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);
      }

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

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

      const unique_name_other = message.other;
      if (unique_name_other !== null) {
        writer.uint32(82);
        writer.bytes(unique_name_other);
      }
    }

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

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

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

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

          case 10:
            message.other = reader.bytes();
            break;

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

      return message;
    }

    token_id: Uint8Array | null;
    permanent_address: bool;
    address_modifiable_only_by_governance: bool;
    other: Uint8Array | null;

    constructor(
      token_id: Uint8Array | null = null,
      permanent_address: bool = false,
      address_modifiable_only_by_governance: bool = false,
      other: Uint8Array | null = null
    ) {
      this.token_id = token_id;
      this.permanent_address = permanent_address;
      this.address_modifiable_only_by_governance =
        address_modifiable_only_by_governance;
      this.other = other;
    }
  }

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

      if (message.permanent_address != false) {
        writer.uint32(16);
        writer.bool(message.permanent_address);
      }

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

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

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

          case 2:
            message.permanent_address = reader.bool();
            break;

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

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

      return message;
    }

    value: Uint8Array | null;
    permanent_address: bool;
    address_modifiable_only_by_governance: bool;

    constructor(
      value: Uint8Array | null = null,
      permanent_address: bool = false,
      address_modifiable_only_by_governance: bool = false
    ) {
      this.value = value;
      this.permanent_address = permanent_address;
      this.address_modifiable_only_by_governance =
        address_modifiable_only_by_governance;
    }
  }

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

      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_address_args {
      const end: usize = length < 0 ? reader.end : reader.ptr + length;
      const message = new get_tokens_by_address_args();

      while (reader.ptr < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1:
            message.address = 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;
    }

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

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