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

export namespace textparserlib {
  export class parse_message_args {
    static encode(message: parse_message_args, writer: Writer): void {
      const unique_name_message_2 = message.message;
      if (unique_name_message_2 !== null) {
        writer.uint32(10);
        writer.string(unique_name_message_2);
      }

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

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

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

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

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

      return message;
    }

    message: string | null;
    pattern: string | null;

    constructor(message: string | null = null, pattern: string | null = null) {
      this.message = message;
      this.pattern = pattern;
    }
  }

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

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

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

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

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

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

      return message;
    }

    error: string | null;
    result: Uint8Array | null;

    constructor(error: string | null = null, result: Uint8Array | null = null) {
      this.error = error;
      this.result = result;
    }
  }
}