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

export namespace smartwalletallowance {
  export class allowance {
    static encode(message: allowance, writer: Writer): void {
      if (message.type != 0) {
        writer.uint32(8);
        writer.int32(message.type);
      }

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

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

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

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

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

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

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

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

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

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

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

      return message;
    }

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

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

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

      const unique_name_allowances = message.allowances;
      for (let i = 0; i < unique_name_allowances.length; ++i) {
        writer.uint32(18);
        writer.fork();
        allowance.encode(unique_name_allowances[i], writer);
        writer.ldelim();
      }
    }

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

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

          case 2:
            message.allowances.push(allowance.decode(reader, reader.uint32()));
            break;

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

      return message;
    }

    transaction_id: Uint8Array | null;
    allowances: Array<allowance>;

    constructor(
      transaction_id: Uint8Array | null = null,
      allowances: Array<allowance> = []
    ) {
      this.transaction_id = transaction_id;
      this.allowances = allowances;
    }
  }

  export enum allowance_type {
    undefined = 0,
    transfer_token = 1,
    transfer_nft = 2,
    mint_token = 3,
    burn_token = 4,
    other = 100,
  }
}