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

export namespace manuscriptwallet {
  export class authorities {
    static encode(message: authorities, writer: Writer): void {
      if (message.koin_address_authority != false) {
        writer.uint32(8);
        writer.bool(message.koin_address_authority);
      }

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

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

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

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

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

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

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

      return message;
    }

    koin_address_authority: bool;
    eth_address_authority: bool;
    eth_address: Uint8Array | null;

    constructor(
      koin_address_authority: bool = false,
      eth_address_authority: bool = false,
      eth_address: Uint8Array | null = null
    ) {
      this.koin_address_authority = koin_address_authority;
      this.eth_address_authority = eth_address_authority;
      this.eth_address = eth_address;
    }
  }

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

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

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

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

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

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

      return message;
    }

    transaction: string | null;
    debug: bool;

    constructor(transaction: string | null = null, debug: bool = false) {
      this.transaction = transaction;
      this.debug = debug;
    }
  }

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

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

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

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

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

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

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

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

      return message;
    }

    token: Uint8Array | null;
    limit: u64;
    spender: Uint8Array | null;

    constructor(
      token: Uint8Array | null = null,
      limit: u64 = 0,
      spender: Uint8Array | null = null
    ) {
      this.token = token;
      this.limit = limit;
      this.spender = spender;
    }
  }

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

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

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

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

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

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

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

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

      return message;
    }

    collection: Uint8Array | null;
    token_id: Uint8Array | null;
    spender: Uint8Array | null;

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

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

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

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

      const unique_name_data = message.data;
      if (unique_name_data !== null) {
        writer.uint32(34);
        writer.bytes(unique_name_data);
      }
    }

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

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

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

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

          case 4:
            message.data = reader.bytes();
            break;

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

      return message;
    }

    contract_id: Uint8Array | null;
    entry_point: u32;
    caller: Uint8Array | null;
    data: Uint8Array | null;

    constructor(
      contract_id: Uint8Array | null = null,
      entry_point: u32 = 0,
      caller: Uint8Array | null = null,
      data: Uint8Array | null = null
    ) {
      this.contract_id = contract_id;
      this.entry_point = entry_point;
      this.caller = caller;
      this.data = data;
    }
  }
}