/** @preserve This file is generated by the script
 * ../bin/generate-defs.js, which is not in general included in a
 * distribution, but is available in the source repository e.g. at
 * https://github.com/amqp-node/amqplib/
 */
'use strict';

function decodeBasicQos(buffer) {
  var val,
    offset = 0,
    fields = {
      prefetchSize: void 0,
      prefetchCount: void 0,
      global: void 0,
    };
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.prefetchSize = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.prefetchCount = val;
  val = !!(1 & buffer[offset]);
  fields.global = val;
  return fields;
}

function encodeBasicQos(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(19);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932170, 7);
  offset = 11;
  val = fields.prefetchSize;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'prefetchSize' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  val = fields.prefetchCount;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'prefetchCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.global;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicQosOk(buffer) {
  return {};
}

function encodeBasicQosOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932171, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicConsume(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      consumerTag: void 0,
      noLocal: void 0,
      noAck: void 0,
      exclusive: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.consumerTag = val;
  val = !!(1 & buffer[offset]);
  fields.noLocal = val;
  val = !!(2 & buffer[offset]);
  fields.noAck = val;
  val = !!(4 & buffer[offset]);
  fields.exclusive = val;
  val = !!(8 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeBasicConsume(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  val = fields.consumerTag;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)");
  var consumerTag_len = Buffer.byteLength(val, 'utf8');
  varyingSize += consumerTag_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932180, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.consumerTag;
  void 0 === val && (val = '');
  buffer[offset] = consumerTag_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += consumerTag_len;
  val = fields.noLocal;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.noAck;
  void 0 === val && (val = !1);
  val && (bits += 2);
  val = fields.exclusive;
  void 0 === val && (val = !1);
  val && (bits += 4);
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 8);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicConsumeOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      consumerTag: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.consumerTag = val;
  return fields;
}

function encodeBasicConsumeOk(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.consumerTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)");
  var consumerTag_len = Buffer.byteLength(val, 'utf8');
  varyingSize += consumerTag_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932181, 7);
  offset = 11;
  val = fields.consumerTag;
  void 0 === val && (val = void 0);
  buffer[offset] = consumerTag_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += consumerTag_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicCancel(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      consumerTag: void 0,
      nowait: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.consumerTag = val;
  val = !!(1 & buffer[offset]);
  fields.nowait = val;
  return fields;
}

function encodeBasicCancel(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.consumerTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)");
  var consumerTag_len = Buffer.byteLength(val, 'utf8');
  varyingSize += consumerTag_len;
  var buffer = Buffer.alloc(14 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932190, 7);
  offset = 11;
  val = fields.consumerTag;
  void 0 === val && (val = void 0);
  buffer[offset] = consumerTag_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += consumerTag_len;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicCancelOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      consumerTag: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.consumerTag = val;
  return fields;
}

function encodeBasicCancelOk(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.consumerTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)");
  var consumerTag_len = Buffer.byteLength(val, 'utf8');
  varyingSize += consumerTag_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932191, 7);
  offset = 11;
  val = fields.consumerTag;
  void 0 === val && (val = void 0);
  buffer[offset] = consumerTag_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += consumerTag_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicPublish(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      exchange: void 0,
      routingKey: void 0,
      mandatory: void 0,
      immediate: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  val = !!(1 & buffer[offset]);
  fields.mandatory = val;
  val = !!(2 & buffer[offset]);
  fields.immediate = val;
  return fields;
}

function encodeBasicPublish(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.exchange;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932200, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.exchange;
  void 0 === val && (val = '');
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = '');
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  val = fields.mandatory;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.immediate;
  void 0 === val && (val = !1);
  val && (bits += 2);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicReturn(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      replyCode: void 0,
      replyText: void 0,
      exchange: void 0,
      routingKey: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.replyCode = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.replyText = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  return fields;
}

function encodeBasicReturn(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.replyText;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)");
  var replyText_len = Buffer.byteLength(val, 'utf8');
  varyingSize += replyText_len;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932210, 7);
  offset = 11;
  val = fields.replyCode;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.replyText;
  void 0 === val && (val = '');
  buffer[offset] = replyText_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += replyText_len;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = void 0);
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicDeliver(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      consumerTag: void 0,
      deliveryTag: void 0,
      redelivered: void 0,
      exchange: void 0,
      routingKey: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.consumerTag = val;
  val = ints.readUInt64BE(buffer, offset);
  offset += 8;
  fields.deliveryTag = val;
  val = !!(1 & buffer[offset]);
  fields.redelivered = val;
  offset++;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  return fields;
}

function encodeBasicDeliver(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.consumerTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)");
  var consumerTag_len = Buffer.byteLength(val, 'utf8');
  varyingSize += consumerTag_len;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  var buffer = Buffer.alloc(24 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932220, 7);
  offset = 11;
  val = fields.consumerTag;
  void 0 === val && (val = void 0);
  buffer[offset] = consumerTag_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += consumerTag_len;
  val = fields.deliveryTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)");
  ints.writeUInt64BE(buffer, val, offset);
  offset += 8;
  val = fields.redelivered;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = void 0);
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicGet(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      noAck: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  val = !!(1 & buffer[offset]);
  fields.noAck = val;
  return fields;
}

function encodeBasicGet(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932230, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.noAck;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicGetOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      deliveryTag: void 0,
      redelivered: void 0,
      exchange: void 0,
      routingKey: void 0,
      messageCount: void 0,
    };
  val = ints.readUInt64BE(buffer, offset);
  offset += 8;
  fields.deliveryTag = val;
  val = !!(1 & buffer[offset]);
  fields.redelivered = val;
  offset++;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.messageCount = val;
  return fields;
}

function encodeBasicGetOk(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  var buffer = Buffer.alloc(27 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932231, 7);
  offset = 11;
  val = fields.deliveryTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)");
  ints.writeUInt64BE(buffer, val, offset);
  offset += 8;
  val = fields.redelivered;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = void 0);
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  val = fields.messageCount;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicGetEmpty(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      clusterId: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.clusterId = val;
  return fields;
}

function encodeBasicGetEmpty(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.clusterId;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'clusterId' is the wrong type; must be a string (up to 255 chars)");
  var clusterId_len = Buffer.byteLength(val, 'utf8');
  varyingSize += clusterId_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932232, 7);
  offset = 11;
  val = fields.clusterId;
  void 0 === val && (val = '');
  buffer[offset] = clusterId_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += clusterId_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicAck(buffer) {
  var val,
    offset = 0,
    fields = {
      deliveryTag: void 0,
      multiple: void 0,
    };
  val = ints.readUInt64BE(buffer, offset);
  offset += 8;
  fields.deliveryTag = val;
  val = !!(1 & buffer[offset]);
  fields.multiple = val;
  return fields;
}

function encodeBasicAck(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(21);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932240, 7);
  offset = 11;
  val = fields.deliveryTag;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)");
  ints.writeUInt64BE(buffer, val, offset);
  offset += 8;
  val = fields.multiple;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicReject(buffer) {
  var val,
    offset = 0,
    fields = {
      deliveryTag: void 0,
      requeue: void 0,
    };
  val = ints.readUInt64BE(buffer, offset);
  offset += 8;
  fields.deliveryTag = val;
  val = !!(1 & buffer[offset]);
  fields.requeue = val;
  return fields;
}

function encodeBasicReject(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(21);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932250, 7);
  offset = 11;
  val = fields.deliveryTag;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)");
  ints.writeUInt64BE(buffer, val, offset);
  offset += 8;
  val = fields.requeue;
  void 0 === val && (val = !0);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicRecoverAsync(buffer) {
  var val,
    fields = {
      requeue: void 0,
    };
  val = !!(1 & buffer[0]);
  fields.requeue = val;
  return fields;
}

function encodeBasicRecoverAsync(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(13);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932260, 7);
  offset = 11;
  val = fields.requeue;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicRecover(buffer) {
  var val,
    fields = {
      requeue: void 0,
    };
  val = !!(1 & buffer[0]);
  fields.requeue = val;
  return fields;
}

function encodeBasicRecover(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(13);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932270, 7);
  offset = 11;
  val = fields.requeue;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicRecoverOk(buffer) {
  return {};
}

function encodeBasicRecoverOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932271, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeBasicNack(buffer) {
  var val,
    offset = 0,
    fields = {
      deliveryTag: void 0,
      multiple: void 0,
      requeue: void 0,
    };
  val = ints.readUInt64BE(buffer, offset);
  offset += 8;
  fields.deliveryTag = val;
  val = !!(1 & buffer[offset]);
  fields.multiple = val;
  val = !!(2 & buffer[offset]);
  fields.requeue = val;
  return fields;
}

function encodeBasicNack(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(21);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932280, 7);
  offset = 11;
  val = fields.deliveryTag;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)");
  ints.writeUInt64BE(buffer, val, offset);
  offset += 8;
  val = fields.multiple;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.requeue;
  void 0 === val && (val = !0);
  val && (bits += 2);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionStart(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      versionMajor: void 0,
      versionMinor: void 0,
      serverProperties: void 0,
      mechanisms: void 0,
      locales: void 0,
    };
  val = buffer[offset];
  offset++;
  fields.versionMajor = val;
  val = buffer[offset];
  offset++;
  fields.versionMinor = val;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.serverProperties = val;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.mechanisms = val;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.locales = val;
  return fields;
}

function encodeConnectionStart(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.serverProperties;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'serverProperties'");
  if ('object' != typeof val) throw new TypeError("Field 'serverProperties' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var serverProperties_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += serverProperties_encoded.length;
  val = fields.mechanisms;
  if (void 0 === val) val = Buffer.from('PLAIN');
  else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'mechanisms' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  val = fields.locales;
  if (void 0 === val) val = Buffer.from('en_US');
  else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'locales' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  var buffer = Buffer.alloc(22 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655370, 7);
  offset = 11;
  val = fields.versionMajor;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'versionMajor' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt8(val, offset);
  offset++;
  val = fields.versionMinor;
  if (void 0 === val) val = 9;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'versionMinor' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt8(val, offset);
  offset++;
  offset += serverProperties_encoded.copy(buffer, offset);
  val = fields.mechanisms;
  void 0 === val && (val = Buffer.from('PLAIN'));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  val = fields.locales;
  void 0 === val && (val = Buffer.from('en_US'));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionStartOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      clientProperties: void 0,
      mechanism: void 0,
      response: void 0,
      locale: void 0,
    };
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.clientProperties = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.mechanism = val;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.response = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.locale = val;
  return fields;
}

function encodeConnectionStartOk(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.clientProperties;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'clientProperties'");
  if ('object' != typeof val) throw new TypeError("Field 'clientProperties' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var clientProperties_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += clientProperties_encoded.length;
  val = fields.mechanism;
  if (void 0 === val) val = 'PLAIN';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'mechanism' is the wrong type; must be a string (up to 255 chars)");
  var mechanism_len = Buffer.byteLength(val, 'utf8');
  varyingSize += mechanism_len;
  val = fields.response;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'response'");
  if (!Buffer.isBuffer(val)) throw new TypeError("Field 'response' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  val = fields.locale;
  if (void 0 === val) val = 'en_US';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'locale' is the wrong type; must be a string (up to 255 chars)");
  var locale_len = Buffer.byteLength(val, 'utf8');
  varyingSize += locale_len;
  var buffer = Buffer.alloc(18 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655371, 7);
  offset = 11;
  offset += clientProperties_encoded.copy(buffer, offset);
  val = fields.mechanism;
  void 0 === val && (val = 'PLAIN');
  buffer[offset] = mechanism_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += mechanism_len;
  val = fields.response;
  void 0 === val && (val = Buffer.from(void 0));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  val = fields.locale;
  void 0 === val && (val = 'en_US');
  buffer[offset] = locale_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += locale_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionSecure(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      challenge: void 0,
    };
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.challenge = val;
  return fields;
}

function encodeConnectionSecure(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.challenge;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'challenge'");
  if (!Buffer.isBuffer(val)) throw new TypeError("Field 'challenge' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655380, 7);
  offset = 11;
  val = fields.challenge;
  void 0 === val && (val = Buffer.from(void 0));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionSecureOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      response: void 0,
    };
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.response = val;
  return fields;
}

function encodeConnectionSecureOk(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.response;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'response'");
  if (!Buffer.isBuffer(val)) throw new TypeError("Field 'response' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655381, 7);
  offset = 11;
  val = fields.response;
  void 0 === val && (val = Buffer.from(void 0));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionTune(buffer) {
  var val,
    offset = 0,
    fields = {
      channelMax: void 0,
      frameMax: void 0,
      heartbeat: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.channelMax = val;
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.frameMax = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.heartbeat = val;
  return fields;
}

function encodeConnectionTune(channel, fields) {
  var offset = 0,
    val = null,
    buffer = Buffer.alloc(20);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655390, 7);
  offset = 11;
  val = fields.channelMax;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'channelMax' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.frameMax;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'frameMax' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  val = fields.heartbeat;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'heartbeat' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionTuneOk(buffer) {
  var val,
    offset = 0,
    fields = {
      channelMax: void 0,
      frameMax: void 0,
      heartbeat: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.channelMax = val;
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.frameMax = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.heartbeat = val;
  return fields;
}

function encodeConnectionTuneOk(channel, fields) {
  var offset = 0,
    val = null,
    buffer = Buffer.alloc(20);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655391, 7);
  offset = 11;
  val = fields.channelMax;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val))
    throw new TypeError("Field 'channelMax' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.frameMax;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'frameMax' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  val = fields.heartbeat;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'heartbeat' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionOpen(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      virtualHost: void 0,
      capabilities: void 0,
      insist: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.virtualHost = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.capabilities = val;
  val = !!(1 & buffer[offset]);
  fields.insist = val;
  return fields;
}

function encodeConnectionOpen(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.virtualHost;
  if (void 0 === val) val = '/';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'virtualHost' is the wrong type; must be a string (up to 255 chars)");
  var virtualHost_len = Buffer.byteLength(val, 'utf8');
  varyingSize += virtualHost_len;
  val = fields.capabilities;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'capabilities' is the wrong type; must be a string (up to 255 chars)");
  var capabilities_len = Buffer.byteLength(val, 'utf8');
  varyingSize += capabilities_len;
  var buffer = Buffer.alloc(15 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655400, 7);
  offset = 11;
  val = fields.virtualHost;
  void 0 === val && (val = '/');
  buffer[offset] = virtualHost_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += virtualHost_len;
  val = fields.capabilities;
  void 0 === val && (val = '');
  buffer[offset] = capabilities_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += capabilities_len;
  val = fields.insist;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionOpenOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      knownHosts: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.knownHosts = val;
  return fields;
}

function encodeConnectionOpenOk(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.knownHosts;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'knownHosts' is the wrong type; must be a string (up to 255 chars)");
  var knownHosts_len = Buffer.byteLength(val, 'utf8');
  varyingSize += knownHosts_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655401, 7);
  offset = 11;
  val = fields.knownHosts;
  void 0 === val && (val = '');
  buffer[offset] = knownHosts_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += knownHosts_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionClose(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      replyCode: void 0,
      replyText: void 0,
      classId: void 0,
      methodId: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.replyCode = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.replyText = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.classId = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.methodId = val;
  return fields;
}

function encodeConnectionClose(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.replyText;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)");
  var replyText_len = Buffer.byteLength(val, 'utf8');
  varyingSize += replyText_len;
  var buffer = Buffer.alloc(19 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655410, 7);
  offset = 11;
  val = fields.replyCode;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.replyText;
  void 0 === val && (val = '');
  buffer[offset] = replyText_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += replyText_len;
  val = fields.classId;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'classId'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'classId' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.methodId;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'methodId'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'methodId' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionCloseOk(buffer) {
  return {};
}

function encodeConnectionCloseOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655411, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionBlocked(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      reason: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.reason = val;
  return fields;
}

function encodeConnectionBlocked(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.reason;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'reason' is the wrong type; must be a string (up to 255 chars)");
  var reason_len = Buffer.byteLength(val, 'utf8');
  varyingSize += reason_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655420, 7);
  offset = 11;
  val = fields.reason;
  void 0 === val && (val = '');
  buffer[offset] = reason_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += reason_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionUnblocked(buffer) {
  return {};
}

function encodeConnectionUnblocked(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655421, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionUpdateSecret(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      newSecret: void 0,
      reason: void 0,
    };
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.newSecret = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.reason = val;
  return fields;
}

function encodeConnectionUpdateSecret(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.newSecret;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'newSecret'");
  if (!Buffer.isBuffer(val)) throw new TypeError("Field 'newSecret' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  val = fields.reason;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'reason'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'reason' is the wrong type; must be a string (up to 255 chars)");
  var reason_len = Buffer.byteLength(val, 'utf8');
  varyingSize += reason_len;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655430, 7);
  offset = 11;
  val = fields.newSecret;
  void 0 === val && (val = Buffer.from(void 0));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  val = fields.reason;
  void 0 === val && (val = void 0);
  buffer[offset] = reason_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += reason_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConnectionUpdateSecretOk(buffer) {
  return {};
}

function encodeConnectionUpdateSecretOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(655431, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelOpen(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      outOfBand: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.outOfBand = val;
  return fields;
}

function encodeChannelOpen(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.outOfBand;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'outOfBand' is the wrong type; must be a string (up to 255 chars)");
  var outOfBand_len = Buffer.byteLength(val, 'utf8');
  varyingSize += outOfBand_len;
  var buffer = Buffer.alloc(13 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310730, 7);
  offset = 11;
  val = fields.outOfBand;
  void 0 === val && (val = '');
  buffer[offset] = outOfBand_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += outOfBand_len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelOpenOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      channelId: void 0,
    };
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = buffer.subarray(offset, offset + len);
  offset += len;
  fields.channelId = val;
  return fields;
}

function encodeChannelOpenOk(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.channelId;
  if (void 0 === val) val = Buffer.from('');
  else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'channelId' is the wrong type; must be a Buffer");
  varyingSize += val.length;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310731, 7);
  offset = 11;
  val = fields.channelId;
  void 0 === val && (val = Buffer.from(''));
  len = val.length;
  buffer.writeUInt32BE(len, offset);
  offset += 4;
  val.copy(buffer, offset);
  offset += len;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelFlow(buffer) {
  var val,
    fields = {
      active: void 0,
    };
  val = !!(1 & buffer[0]);
  fields.active = val;
  return fields;
}

function encodeChannelFlow(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(13);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310740, 7);
  offset = 11;
  val = fields.active;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'active'");
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelFlowOk(buffer) {
  var val,
    fields = {
      active: void 0,
    };
  val = !!(1 & buffer[0]);
  fields.active = val;
  return fields;
}

function encodeChannelFlowOk(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(13);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310741, 7);
  offset = 11;
  val = fields.active;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'active'");
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelClose(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      replyCode: void 0,
      replyText: void 0,
      classId: void 0,
      methodId: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.replyCode = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.replyText = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.classId = val;
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.methodId = val;
  return fields;
}

function encodeChannelClose(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.replyText;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)");
  var replyText_len = Buffer.byteLength(val, 'utf8');
  varyingSize += replyText_len;
  var buffer = Buffer.alloc(19 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310760, 7);
  offset = 11;
  val = fields.replyCode;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.replyText;
  void 0 === val && (val = '');
  buffer[offset] = replyText_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += replyText_len;
  val = fields.classId;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'classId'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'classId' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.methodId;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'methodId'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'methodId' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeChannelCloseOk(buffer) {
  return {};
}

function encodeChannelCloseOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1310761, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeAccessRequest(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      realm: void 0,
      exclusive: void 0,
      passive: void 0,
      active: void 0,
      write: void 0,
      read: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.realm = val;
  val = !!(1 & buffer[offset]);
  fields.exclusive = val;
  val = !!(2 & buffer[offset]);
  fields.passive = val;
  val = !!(4 & buffer[offset]);
  fields.active = val;
  val = !!(8 & buffer[offset]);
  fields.write = val;
  val = !!(16 & buffer[offset]);
  fields.read = val;
  return fields;
}

function encodeAccessRequest(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.realm;
  if (void 0 === val) val = '/data';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'realm' is the wrong type; must be a string (up to 255 chars)");
  var realm_len = Buffer.byteLength(val, 'utf8');
  varyingSize += realm_len;
  var buffer = Buffer.alloc(14 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1966090, 7);
  offset = 11;
  val = fields.realm;
  void 0 === val && (val = '/data');
  buffer[offset] = realm_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += realm_len;
  val = fields.exclusive;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.passive;
  void 0 === val && (val = !0);
  val && (bits += 2);
  val = fields.active;
  void 0 === val && (val = !0);
  val && (bits += 4);
  val = fields.write;
  void 0 === val && (val = !0);
  val && (bits += 8);
  val = fields.read;
  void 0 === val && (val = !0);
  val && (bits += 16);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeAccessRequestOk(buffer) {
  var val,
    offset = 0,
    fields = {
      ticket: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  return fields;
}

function encodeAccessRequestOk(channel, fields) {
  var offset = 0,
    val = null,
    buffer = Buffer.alloc(14);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(1966091, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 1;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeDeclare(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      exchange: void 0,
      type: void 0,
      passive: void 0,
      durable: void 0,
      autoDelete: void 0,
      internal: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.type = val;
  val = !!(1 & buffer[offset]);
  fields.passive = val;
  val = !!(2 & buffer[offset]);
  fields.durable = val;
  val = !!(4 & buffer[offset]);
  fields.autoDelete = val;
  val = !!(8 & buffer[offset]);
  fields.internal = val;
  val = !!(16 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeExchangeDeclare(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.type;
  if (void 0 === val) val = 'direct';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'type' is the wrong type; must be a string (up to 255 chars)");
  var type_len = Buffer.byteLength(val, 'utf8');
  varyingSize += type_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621450, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.type;
  void 0 === val && (val = 'direct');
  buffer[offset] = type_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += type_len;
  val = fields.passive;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.durable;
  void 0 === val && (val = !1);
  val && (bits += 2);
  val = fields.autoDelete;
  void 0 === val && (val = !1);
  val && (bits += 4);
  val = fields.internal;
  void 0 === val && (val = !1);
  val && (bits += 8);
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 16);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeDeclareOk(buffer) {
  return {};
}

function encodeExchangeDeclareOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621451, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeDelete(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      exchange: void 0,
      ifUnused: void 0,
      nowait: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  val = !!(1 & buffer[offset]);
  fields.ifUnused = val;
  val = !!(2 & buffer[offset]);
  fields.nowait = val;
  return fields;
}

function encodeExchangeDelete(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621460, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.ifUnused;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 2);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeDeleteOk(buffer) {
  return {};
}

function encodeExchangeDeleteOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621461, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeBind(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      destination: void 0,
      source: void 0,
      routingKey: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.destination = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.source = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  val = !!(1 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeExchangeBind(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.destination;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'destination'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'destination' is the wrong type; must be a string (up to 255 chars)");
  var destination_len = Buffer.byteLength(val, 'utf8');
  varyingSize += destination_len;
  val = fields.source;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'source'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'source' is the wrong type; must be a string (up to 255 chars)");
  var source_len = Buffer.byteLength(val, 'utf8');
  varyingSize += source_len;
  val = fields.routingKey;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(18 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621470, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.destination;
  void 0 === val && (val = void 0);
  buffer[offset] = destination_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += destination_len;
  val = fields.source;
  void 0 === val && (val = void 0);
  buffer[offset] = source_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += source_len;
  val = fields.routingKey;
  void 0 === val && (val = '');
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeBindOk(buffer) {
  return {};
}

function encodeExchangeBindOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621471, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeUnbind(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      destination: void 0,
      source: void 0,
      routingKey: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.destination = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.source = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  val = !!(1 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeExchangeUnbind(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.destination;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'destination'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'destination' is the wrong type; must be a string (up to 255 chars)");
  var destination_len = Buffer.byteLength(val, 'utf8');
  varyingSize += destination_len;
  val = fields.source;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'source'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'source' is the wrong type; must be a string (up to 255 chars)");
  var source_len = Buffer.byteLength(val, 'utf8');
  varyingSize += source_len;
  val = fields.routingKey;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(18 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621480, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.destination;
  void 0 === val && (val = void 0);
  buffer[offset] = destination_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += destination_len;
  val = fields.source;
  void 0 === val && (val = void 0);
  buffer[offset] = source_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += source_len;
  val = fields.routingKey;
  void 0 === val && (val = '');
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeExchangeUnbindOk(buffer) {
  return {};
}

function encodeExchangeUnbindOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(2621491, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueDeclare(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      passive: void 0,
      durable: void 0,
      exclusive: void 0,
      autoDelete: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  val = !!(1 & buffer[offset]);
  fields.passive = val;
  val = !!(2 & buffer[offset]);
  fields.durable = val;
  val = !!(4 & buffer[offset]);
  fields.exclusive = val;
  val = !!(8 & buffer[offset]);
  fields.autoDelete = val;
  val = !!(16 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeQueueDeclare(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276810, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.passive;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.durable;
  void 0 === val && (val = !1);
  val && (bits += 2);
  val = fields.exclusive;
  void 0 === val && (val = !1);
  val && (bits += 4);
  val = fields.autoDelete;
  void 0 === val && (val = !1);
  val && (bits += 8);
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 16);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueDeclareOk(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      queue: void 0,
      messageCount: void 0,
      consumerCount: void 0,
    };
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.messageCount = val;
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.consumerCount = val;
  return fields;
}

function encodeQueueDeclareOk(channel, fields) {
  var offset = 0,
    val = null,
    varyingSize = 0;
  val = fields.queue;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'queue'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  var buffer = Buffer.alloc(21 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276811, 7);
  offset = 11;
  val = fields.queue;
  void 0 === val && (val = void 0);
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.messageCount;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  val = fields.consumerCount;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerCount'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'consumerCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueBind(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      exchange: void 0,
      routingKey: void 0,
      nowait: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  val = !!(1 & buffer[offset]);
  fields.nowait = val;
  offset++;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeQueueBind(channel, fields) {
  var len,
    offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(18 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276820, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = '');
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  bits = 0;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueBindOk(buffer) {
  return {};
}

function encodeQueueBindOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276821, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueuePurge(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      nowait: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  val = !!(1 & buffer[offset]);
  fields.nowait = val;
  return fields;
}

function encodeQueuePurge(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276830, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueuePurgeOk(buffer) {
  var val,
    offset = 0,
    fields = {
      messageCount: void 0,
    };
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.messageCount = val;
  return fields;
}

function encodeQueuePurgeOk(channel, fields) {
  var offset = 0,
    val = null,
    buffer = Buffer.alloc(16);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276831, 7);
  offset = 11;
  val = fields.messageCount;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueDelete(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      ifUnused: void 0,
      ifEmpty: void 0,
      nowait: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  val = !!(1 & buffer[offset]);
  fields.ifUnused = val;
  val = !!(2 & buffer[offset]);
  fields.ifEmpty = val;
  val = !!(4 & buffer[offset]);
  fields.nowait = val;
  return fields;
}

function encodeQueueDelete(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    varyingSize = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  var buffer = Buffer.alloc(16 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276840, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.ifUnused;
  void 0 === val && (val = !1);
  val && (bits += 1);
  val = fields.ifEmpty;
  void 0 === val && (val = !1);
  val && (bits += 2);
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 4);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueDeleteOk(buffer) {
  var val,
    offset = 0,
    fields = {
      messageCount: void 0,
    };
  val = buffer.readUInt32BE(offset);
  offset += 4;
  fields.messageCount = val;
  return fields;
}

function encodeQueueDeleteOk(channel, fields) {
  var offset = 0,
    val = null,
    buffer = Buffer.alloc(16);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276841, 7);
  offset = 11;
  val = fields.messageCount;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'");
  if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt32BE(val, offset);
  offset += 4;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueUnbind(buffer) {
  var val,
    len,
    offset = 0,
    fields = {
      ticket: void 0,
      queue: void 0,
      exchange: void 0,
      routingKey: void 0,
      arguments: void 0,
    };
  val = buffer.readUInt16BE(offset);
  offset += 2;
  fields.ticket = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.queue = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.exchange = val;
  len = buffer.readUInt8(offset);
  offset++;
  val = buffer.toString('utf8', offset, offset + len);
  offset += len;
  fields.routingKey = val;
  len = buffer.readUInt32BE(offset);
  offset += 4;
  val = decodeFields(buffer.subarray(offset, offset + len));
  offset += len;
  fields.arguments = val;
  return fields;
}

function encodeQueueUnbind(channel, fields) {
  var len,
    offset = 0,
    val = null,
    varyingSize = 0,
    scratchOffset = 0;
  val = fields.queue;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)");
  var queue_len = Buffer.byteLength(val, 'utf8');
  varyingSize += queue_len;
  val = fields.exchange;
  if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'");
  if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)");
  var exchange_len = Buffer.byteLength(val, 'utf8');
  varyingSize += exchange_len;
  val = fields.routingKey;
  if (void 0 === val) val = '';
  else if (!('string' == typeof val && Buffer.byteLength(val) < 256))
    throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)");
  var routingKey_len = Buffer.byteLength(val, 'utf8');
  varyingSize += routingKey_len;
  val = fields.arguments;
  if (void 0 === val) val = {};
  else if ('object' != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object");
  len = encodeTable(SCRATCH, val, scratchOffset);
  var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
  scratchOffset += len;
  varyingSize += arguments_encoded.length;
  var buffer = Buffer.alloc(17 + varyingSize);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276850, 7);
  offset = 11;
  val = fields.ticket;
  if (void 0 === val) val = 0;
  else if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)");
  buffer.writeUInt16BE(val, offset);
  offset += 2;
  val = fields.queue;
  void 0 === val && (val = '');
  buffer[offset] = queue_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += queue_len;
  val = fields.exchange;
  void 0 === val && (val = void 0);
  buffer[offset] = exchange_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += exchange_len;
  val = fields.routingKey;
  void 0 === val && (val = '');
  buffer[offset] = routingKey_len;
  offset++;
  buffer.write(val, offset, 'utf8');
  offset += routingKey_len;
  offset += arguments_encoded.copy(buffer, offset);
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeQueueUnbindOk(buffer) {
  return {};
}

function encodeQueueUnbindOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3276851, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxSelect(buffer) {
  return {};
}

function encodeTxSelect(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898250, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxSelectOk(buffer) {
  return {};
}

function encodeTxSelectOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898251, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxCommit(buffer) {
  return {};
}

function encodeTxCommit(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898260, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxCommitOk(buffer) {
  return {};
}

function encodeTxCommitOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898261, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxRollback(buffer) {
  return {};
}

function encodeTxRollback(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898270, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeTxRollbackOk(buffer) {
  return {};
}

function encodeTxRollbackOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5898271, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConfirmSelect(buffer) {
  var val,
    fields = {
      nowait: void 0,
    };
  val = !!(1 & buffer[0]);
  fields.nowait = val;
  return fields;
}

function encodeConfirmSelect(channel, fields) {
  var offset = 0,
    val = null,
    bits = 0,
    buffer = Buffer.alloc(13);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5570570, 7);
  offset = 11;
  val = fields.nowait;
  void 0 === val && (val = !1);
  val && (bits += 1);
  buffer[offset] = bits;
  offset++;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function decodeConfirmSelectOk(buffer) {
  return {};
}

function encodeConfirmSelectOk(channel, fields) {
  var offset = 0,
    buffer = Buffer.alloc(12);
  buffer[0] = 1;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(5570571, 7);
  offset = 11;
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  return buffer;
}

function encodeBasicProperties(channel, size, fields) {
  var val,
    len,
    offset = 0,
    flags = 0,
    scratchOffset = 0,
    varyingSize = 0;
  val = fields.contentType;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'contentType' is the wrong type; must be a string (up to 255 chars)");
    var contentType_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += contentType_len;
  }
  val = fields.contentEncoding;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'contentEncoding' is the wrong type; must be a string (up to 255 chars)");
    var contentEncoding_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += contentEncoding_len;
  }
  val = fields.headers;
  if (void 0 != val) {
    if ('object' != typeof val) throw new TypeError("Field 'headers' is the wrong type; must be an object");
    len = encodeTable(SCRATCH, val, scratchOffset);
    var headers_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len);
    scratchOffset += len;
    varyingSize += headers_encoded.length;
  }
  val = fields.deliveryMode;
  if (void 0 != val) {
    if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryMode' is the wrong type; must be a number (but not NaN)");
    varyingSize += 1;
  }
  val = fields.priority;
  if (void 0 != val) {
    if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'priority' is the wrong type; must be a number (but not NaN)");
    varyingSize += 1;
  }
  val = fields.correlationId;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'correlationId' is the wrong type; must be a string (up to 255 chars)");
    var correlationId_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += correlationId_len;
  }
  val = fields.replyTo;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'replyTo' is the wrong type; must be a string (up to 255 chars)");
    var replyTo_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += replyTo_len;
  }
  val = fields.expiration;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'expiration' is the wrong type; must be a string (up to 255 chars)");
    var expiration_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += expiration_len;
  }
  val = fields.messageId;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'messageId' is the wrong type; must be a string (up to 255 chars)");
    var messageId_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += messageId_len;
  }
  val = fields.timestamp;
  if (void 0 != val) {
    if ('number' != typeof val || isNaN(val)) throw new TypeError("Field 'timestamp' is the wrong type; must be a number (but not NaN)");
    varyingSize += 8;
  }
  val = fields.type;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'type' is the wrong type; must be a string (up to 255 chars)");
    var type_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += type_len;
  }
  val = fields.userId;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'userId' is the wrong type; must be a string (up to 255 chars)");
    var userId_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += userId_len;
  }
  val = fields.appId;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'appId' is the wrong type; must be a string (up to 255 chars)");
    var appId_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += appId_len;
  }
  val = fields.clusterId;
  if (void 0 != val) {
    if (!('string' == typeof val && Buffer.byteLength(val) < 256))
      throw new TypeError("Field 'clusterId' is the wrong type; must be a string (up to 255 chars)");
    var clusterId_len = Buffer.byteLength(val, 'utf8');
    varyingSize += 1;
    varyingSize += clusterId_len;
  }
  var buffer = Buffer.alloc(22 + varyingSize);
  buffer[0] = 2;
  buffer.writeUInt16BE(channel, 1);
  buffer.writeUInt32BE(3932160, 7);
  ints.writeUInt64BE(buffer, size, 11);
  flags = 0;
  offset = 21;
  val = fields.contentType;
  if (void 0 != val) {
    flags += 32768;
    buffer[offset] = contentType_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += contentType_len;
  }
  val = fields.contentEncoding;
  if (void 0 != val) {
    flags += 16384;
    buffer[offset] = contentEncoding_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += contentEncoding_len;
  }
  val = fields.headers;
  if (void 0 != val) {
    flags += 8192;
    offset += headers_encoded.copy(buffer, offset);
  }
  val = fields.deliveryMode;
  if (void 0 != val) {
    flags += 4096;
    buffer.writeUInt8(val, offset);
    offset++;
  }
  val = fields.priority;
  if (void 0 != val) {
    flags += 2048;
    buffer.writeUInt8(val, offset);
    offset++;
  }
  val = fields.correlationId;
  if (void 0 != val) {
    flags += 1024;
    buffer[offset] = correlationId_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += correlationId_len;
  }
  val = fields.replyTo;
  if (void 0 != val) {
    flags += 512;
    buffer[offset] = replyTo_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += replyTo_len;
  }
  val = fields.expiration;
  if (void 0 != val) {
    flags += 256;
    buffer[offset] = expiration_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += expiration_len;
  }
  val = fields.messageId;
  if (void 0 != val) {
    flags += 128;
    buffer[offset] = messageId_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += messageId_len;
  }
  val = fields.timestamp;
  if (void 0 != val) {
    flags += 64;
    ints.writeUInt64BE(buffer, val, offset);
    offset += 8;
  }
  val = fields.type;
  if (void 0 != val) {
    flags += 32;
    buffer[offset] = type_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += type_len;
  }
  val = fields.userId;
  if (void 0 != val) {
    flags += 16;
    buffer[offset] = userId_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += userId_len;
  }
  val = fields.appId;
  if (void 0 != val) {
    flags += 8;
    buffer[offset] = appId_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += appId_len;
  }
  val = fields.clusterId;
  if (void 0 != val) {
    flags += 4;
    buffer[offset] = clusterId_len;
    offset++;
    buffer.write(val, offset, 'utf8');
    offset += clusterId_len;
  }
  buffer[offset] = 206;
  buffer.writeUInt32BE(offset - 7, 3);
  buffer.writeUInt16BE(flags, 19);
  return buffer.subarray(0, offset + 1);
}

function decodeBasicProperties(buffer) {
  var flags,
    val,
    len,
    offset = 2;
  flags = buffer.readUInt16BE(0);
  if (0 === flags) return {};
  var fields = {
    contentType: void 0,
    contentEncoding: void 0,
    headers: void 0,
    deliveryMode: void 0,
    priority: void 0,
    correlationId: void 0,
    replyTo: void 0,
    expiration: void 0,
    messageId: void 0,
    timestamp: void 0,
    type: void 0,
    userId: void 0,
    appId: void 0,
    clusterId: void 0,
  };
  if (32768 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.contentType = val;
  }
  if (16384 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.contentEncoding = val;
  }
  if (8192 & flags) {
    len = buffer.readUInt32BE(offset);
    offset += 4;
    val = decodeFields(buffer.subarray(offset, offset + len));
    offset += len;
    fields.headers = val;
  }
  if (4096 & flags) {
    val = buffer[offset];
    offset++;
    fields.deliveryMode = val;
  }
  if (2048 & flags) {
    val = buffer[offset];
    offset++;
    fields.priority = val;
  }
  if (1024 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.correlationId = val;
  }
  if (512 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.replyTo = val;
  }
  if (256 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.expiration = val;
  }
  if (128 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.messageId = val;
  }
  if (64 & flags) {
    val = ints.readUInt64BE(buffer, offset);
    offset += 8;
    fields.timestamp = val;
  }
  if (32 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.type = val;
  }
  if (16 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.userId = val;
  }
  if (8 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.appId = val;
  }
  if (4 & flags) {
    len = buffer.readUInt8(offset);
    offset++;
    val = buffer.toString('utf8', offset, offset + len);
    offset += len;
    fields.clusterId = val;
  }
  return fields;
}

var codec = require('./codec'),
  ints = require('buffer-more-ints'),
  encodeTable = codec.encodeTable,
  decodeFields = codec.decodeFields,
  SCRATCH = Buffer.alloc(65536),
  EMPTY_OBJECT = Object.freeze({});

module.exports.constants = {
  FRAME_METHOD: 1,
  FRAME_HEADER: 2,
  FRAME_BODY: 3,
  FRAME_HEARTBEAT: 8,
  FRAME_MIN_SIZE: 4096,
  FRAME_END: 206,
  REPLY_SUCCESS: 200,
  CONTENT_TOO_LARGE: 311,
  NO_ROUTE: 312,
  NO_CONSUMERS: 313,
  ACCESS_REFUSED: 403,
  NOT_FOUND: 404,
  RESOURCE_LOCKED: 405,
  PRECONDITION_FAILED: 406,
  CONNECTION_FORCED: 320,
  INVALID_PATH: 402,
  FRAME_ERROR: 501,
  SYNTAX_ERROR: 502,
  COMMAND_INVALID: 503,
  CHANNEL_ERROR: 504,
  UNEXPECTED_FRAME: 505,
  RESOURCE_ERROR: 506,
  NOT_ALLOWED: 530,
  NOT_IMPLEMENTED: 540,
  INTERNAL_ERROR: 541,
};

module.exports.constant_strs = {
  1: 'FRAME-METHOD',
  2: 'FRAME-HEADER',
  3: 'FRAME-BODY',
  8: 'FRAME-HEARTBEAT',
  200: 'REPLY-SUCCESS',
  206: 'FRAME-END',
  311: 'CONTENT-TOO-LARGE',
  312: 'NO-ROUTE',
  313: 'NO-CONSUMERS',
  320: 'CONNECTION-FORCED',
  402: 'INVALID-PATH',
  403: 'ACCESS-REFUSED',
  404: 'NOT-FOUND',
  405: 'RESOURCE-LOCKED',
  406: 'PRECONDITION-FAILED',
  501: 'FRAME-ERROR',
  502: 'SYNTAX-ERROR',
  503: 'COMMAND-INVALID',
  504: 'CHANNEL-ERROR',
  505: 'UNEXPECTED-FRAME',
  506: 'RESOURCE-ERROR',
  530: 'NOT-ALLOWED',
  540: 'NOT-IMPLEMENTED',
  541: 'INTERNAL-ERROR',
  4096: 'FRAME-MIN-SIZE',
};

module.exports.FRAME_OVERHEAD = 8;

module.exports.decode = function (id, buf) {
  switch (id) {
    case 3932170:
      return decodeBasicQos(buf);

    case 3932171:
      return decodeBasicQosOk(buf);

    case 3932180:
      return decodeBasicConsume(buf);

    case 3932181:
      return decodeBasicConsumeOk(buf);

    case 3932190:
      return decodeBasicCancel(buf);

    case 3932191:
      return decodeBasicCancelOk(buf);

    case 3932200:
      return decodeBasicPublish(buf);

    case 3932210:
      return decodeBasicReturn(buf);

    case 3932220:
      return decodeBasicDeliver(buf);

    case 3932230:
      return decodeBasicGet(buf);

    case 3932231:
      return decodeBasicGetOk(buf);

    case 3932232:
      return decodeBasicGetEmpty(buf);

    case 3932240:
      return decodeBasicAck(buf);

    case 3932250:
      return decodeBasicReject(buf);

    case 3932260:
      return decodeBasicRecoverAsync(buf);

    case 3932270:
      return decodeBasicRecover(buf);

    case 3932271:
      return decodeBasicRecoverOk(buf);

    case 3932280:
      return decodeBasicNack(buf);

    case 655370:
      return decodeConnectionStart(buf);

    case 655371:
      return decodeConnectionStartOk(buf);

    case 655380:
      return decodeConnectionSecure(buf);

    case 655381:
      return decodeConnectionSecureOk(buf);

    case 655390:
      return decodeConnectionTune(buf);

    case 655391:
      return decodeConnectionTuneOk(buf);

    case 655400:
      return decodeConnectionOpen(buf);

    case 655401:
      return decodeConnectionOpenOk(buf);

    case 655410:
      return decodeConnectionClose(buf);

    case 655411:
      return decodeConnectionCloseOk(buf);

    case 655420:
      return decodeConnectionBlocked(buf);

    case 655421:
      return decodeConnectionUnblocked(buf);

    case 655430:
      return decodeConnectionUpdateSecret(buf);

    case 655431:
      return decodeConnectionUpdateSecretOk(buf);

    case 1310730:
      return decodeChannelOpen(buf);

    case 1310731:
      return decodeChannelOpenOk(buf);

    case 1310740:
      return decodeChannelFlow(buf);

    case 1310741:
      return decodeChannelFlowOk(buf);

    case 1310760:
      return decodeChannelClose(buf);

    case 1310761:
      return decodeChannelCloseOk(buf);

    case 1966090:
      return decodeAccessRequest(buf);

    case 1966091:
      return decodeAccessRequestOk(buf);

    case 2621450:
      return decodeExchangeDeclare(buf);

    case 2621451:
      return decodeExchangeDeclareOk(buf);

    case 2621460:
      return decodeExchangeDelete(buf);

    case 2621461:
      return decodeExchangeDeleteOk(buf);

    case 2621470:
      return decodeExchangeBind(buf);

    case 2621471:
      return decodeExchangeBindOk(buf);

    case 2621480:
      return decodeExchangeUnbind(buf);

    case 2621491:
      return decodeExchangeUnbindOk(buf);

    case 3276810:
      return decodeQueueDeclare(buf);

    case 3276811:
      return decodeQueueDeclareOk(buf);

    case 3276820:
      return decodeQueueBind(buf);

    case 3276821:
      return decodeQueueBindOk(buf);

    case 3276830:
      return decodeQueuePurge(buf);

    case 3276831:
      return decodeQueuePurgeOk(buf);

    case 3276840:
      return decodeQueueDelete(buf);

    case 3276841:
      return decodeQueueDeleteOk(buf);

    case 3276850:
      return decodeQueueUnbind(buf);

    case 3276851:
      return decodeQueueUnbindOk(buf);

    case 5898250:
      return decodeTxSelect(buf);

    case 5898251:
      return decodeTxSelectOk(buf);

    case 5898260:
      return decodeTxCommit(buf);

    case 5898261:
      return decodeTxCommitOk(buf);

    case 5898270:
      return decodeTxRollback(buf);

    case 5898271:
      return decodeTxRollbackOk(buf);

    case 5570570:
      return decodeConfirmSelect(buf);

    case 5570571:
      return decodeConfirmSelectOk(buf);

    case 60:
      return decodeBasicProperties(buf);

    default:
      throw new Error('Unknown class/method ID');
  }
};

module.exports.encodeMethod = function (id, channel, fields) {
  switch (id) {
    case 3932170:
      return encodeBasicQos(channel, fields);

    case 3932171:
      return encodeBasicQosOk(channel, fields);

    case 3932180:
      return encodeBasicConsume(channel, fields);

    case 3932181:
      return encodeBasicConsumeOk(channel, fields);

    case 3932190:
      return encodeBasicCancel(channel, fields);

    case 3932191:
      return encodeBasicCancelOk(channel, fields);

    case 3932200:
      return encodeBasicPublish(channel, fields);

    case 3932210:
      return encodeBasicReturn(channel, fields);

    case 3932220:
      return encodeBasicDeliver(channel, fields);

    case 3932230:
      return encodeBasicGet(channel, fields);

    case 3932231:
      return encodeBasicGetOk(channel, fields);

    case 3932232:
      return encodeBasicGetEmpty(channel, fields);

    case 3932240:
      return encodeBasicAck(channel, fields);

    case 3932250:
      return encodeBasicReject(channel, fields);

    case 3932260:
      return encodeBasicRecoverAsync(channel, fields);

    case 3932270:
      return encodeBasicRecover(channel, fields);

    case 3932271:
      return encodeBasicRecoverOk(channel, fields);

    case 3932280:
      return encodeBasicNack(channel, fields);

    case 655370:
      return encodeConnectionStart(channel, fields);

    case 655371:
      return encodeConnectionStartOk(channel, fields);

    case 655380:
      return encodeConnectionSecure(channel, fields);

    case 655381:
      return encodeConnectionSecureOk(channel, fields);

    case 655390:
      return encodeConnectionTune(channel, fields);

    case 655391:
      return encodeConnectionTuneOk(channel, fields);

    case 655400:
      return encodeConnectionOpen(channel, fields);

    case 655401:
      return encodeConnectionOpenOk(channel, fields);

    case 655410:
      return encodeConnectionClose(channel, fields);

    case 655411:
      return encodeConnectionCloseOk(channel, fields);

    case 655420:
      return encodeConnectionBlocked(channel, fields);

    case 655421:
      return encodeConnectionUnblocked(channel, fields);

    case 655430:
      return encodeConnectionUpdateSecret(channel, fields);

    case 655431:
      return encodeConnectionUpdateSecretOk(channel, fields);

    case 1310730:
      return encodeChannelOpen(channel, fields);

    case 1310731:
      return encodeChannelOpenOk(channel, fields);

    case 1310740:
      return encodeChannelFlow(channel, fields);

    case 1310741:
      return encodeChannelFlowOk(channel, fields);

    case 1310760:
      return encodeChannelClose(channel, fields);

    case 1310761:
      return encodeChannelCloseOk(channel, fields);

    case 1966090:
      return encodeAccessRequest(channel, fields);

    case 1966091:
      return encodeAccessRequestOk(channel, fields);

    case 2621450:
      return encodeExchangeDeclare(channel, fields);

    case 2621451:
      return encodeExchangeDeclareOk(channel, fields);

    case 2621460:
      return encodeExchangeDelete(channel, fields);

    case 2621461:
      return encodeExchangeDeleteOk(channel, fields);

    case 2621470:
      return encodeExchangeBind(channel, fields);

    case 2621471:
      return encodeExchangeBindOk(channel, fields);

    case 2621480:
      return encodeExchangeUnbind(channel, fields);

    case 2621491:
      return encodeExchangeUnbindOk(channel, fields);

    case 3276810:
      return encodeQueueDeclare(channel, fields);

    case 3276811:
      return encodeQueueDeclareOk(channel, fields);

    case 3276820:
      return encodeQueueBind(channel, fields);

    case 3276821:
      return encodeQueueBindOk(channel, fields);

    case 3276830:
      return encodeQueuePurge(channel, fields);

    case 3276831:
      return encodeQueuePurgeOk(channel, fields);

    case 3276840:
      return encodeQueueDelete(channel, fields);

    case 3276841:
      return encodeQueueDeleteOk(channel, fields);

    case 3276850:
      return encodeQueueUnbind(channel, fields);

    case 3276851:
      return encodeQueueUnbindOk(channel, fields);

    case 5898250:
      return encodeTxSelect(channel, fields);

    case 5898251:
      return encodeTxSelectOk(channel, fields);

    case 5898260:
      return encodeTxCommit(channel, fields);

    case 5898261:
      return encodeTxCommitOk(channel, fields);

    case 5898270:
      return encodeTxRollback(channel, fields);

    case 5898271:
      return encodeTxRollbackOk(channel, fields);

    case 5570570:
      return encodeConfirmSelect(channel, fields);

    case 5570571:
      return encodeConfirmSelectOk(channel, fields);

    default:
      throw new Error('Unknown class/method ID');
  }
};

module.exports.encodeProperties = function (id, channel, size, fields) {
  switch (id) {
    case 60:
      return encodeBasicProperties(channel, size, fields);

    default:
      throw new Error('Unknown class/properties ID');
  }
};

module.exports.info = function (id) {
  switch (id) {
    case 3932170:
      return methodInfoBasicQos;

    case 3932171:
      return methodInfoBasicQosOk;

    case 3932180:
      return methodInfoBasicConsume;

    case 3932181:
      return methodInfoBasicConsumeOk;

    case 3932190:
      return methodInfoBasicCancel;

    case 3932191:
      return methodInfoBasicCancelOk;

    case 3932200:
      return methodInfoBasicPublish;

    case 3932210:
      return methodInfoBasicReturn;

    case 3932220:
      return methodInfoBasicDeliver;

    case 3932230:
      return methodInfoBasicGet;

    case 3932231:
      return methodInfoBasicGetOk;

    case 3932232:
      return methodInfoBasicGetEmpty;

    case 3932240:
      return methodInfoBasicAck;

    case 3932250:
      return methodInfoBasicReject;

    case 3932260:
      return methodInfoBasicRecoverAsync;

    case 3932270:
      return methodInfoBasicRecover;

    case 3932271:
      return methodInfoBasicRecoverOk;

    case 3932280:
      return methodInfoBasicNack;

    case 655370:
      return methodInfoConnectionStart;

    case 655371:
      return methodInfoConnectionStartOk;

    case 655380:
      return methodInfoConnectionSecure;

    case 655381:
      return methodInfoConnectionSecureOk;

    case 655390:
      return methodInfoConnectionTune;

    case 655391:
      return methodInfoConnectionTuneOk;

    case 655400:
      return methodInfoConnectionOpen;

    case 655401:
      return methodInfoConnectionOpenOk;

    case 655410:
      return methodInfoConnectionClose;

    case 655411:
      return methodInfoConnectionCloseOk;

    case 655420:
      return methodInfoConnectionBlocked;

    case 655421:
      return methodInfoConnectionUnblocked;

    case 655430:
      return methodInfoConnectionUpdateSecret;

    case 655431:
      return methodInfoConnectionUpdateSecretOk;

    case 1310730:
      return methodInfoChannelOpen;

    case 1310731:
      return methodInfoChannelOpenOk;

    case 1310740:
      return methodInfoChannelFlow;

    case 1310741:
      return methodInfoChannelFlowOk;

    case 1310760:
      return methodInfoChannelClose;

    case 1310761:
      return methodInfoChannelCloseOk;

    case 1966090:
      return methodInfoAccessRequest;

    case 1966091:
      return methodInfoAccessRequestOk;

    case 2621450:
      return methodInfoExchangeDeclare;

    case 2621451:
      return methodInfoExchangeDeclareOk;

    case 2621460:
      return methodInfoExchangeDelete;

    case 2621461:
      return methodInfoExchangeDeleteOk;

    case 2621470:
      return methodInfoExchangeBind;

    case 2621471:
      return methodInfoExchangeBindOk;

    case 2621480:
      return methodInfoExchangeUnbind;

    case 2621491:
      return methodInfoExchangeUnbindOk;

    case 3276810:
      return methodInfoQueueDeclare;

    case 3276811:
      return methodInfoQueueDeclareOk;

    case 3276820:
      return methodInfoQueueBind;

    case 3276821:
      return methodInfoQueueBindOk;

    case 3276830:
      return methodInfoQueuePurge;

    case 3276831:
      return methodInfoQueuePurgeOk;

    case 3276840:
      return methodInfoQueueDelete;

    case 3276841:
      return methodInfoQueueDeleteOk;

    case 3276850:
      return methodInfoQueueUnbind;

    case 3276851:
      return methodInfoQueueUnbindOk;

    case 5898250:
      return methodInfoTxSelect;

    case 5898251:
      return methodInfoTxSelectOk;

    case 5898260:
      return methodInfoTxCommit;

    case 5898261:
      return methodInfoTxCommitOk;

    case 5898270:
      return methodInfoTxRollback;

    case 5898271:
      return methodInfoTxRollbackOk;

    case 5570570:
      return methodInfoConfirmSelect;

    case 5570571:
      return methodInfoConfirmSelectOk;

    case 60:
      return propertiesInfoBasicProperties;

    default:
      throw new Error('Unknown class/method ID');
  }
};

module.exports.BasicQos = 3932170;

var methodInfoBasicQos = (module.exports.methodInfoBasicQos = {
  id: 3932170,
  classId: 60,
  methodId: 10,
  name: 'BasicQos',
  args: [
    {
      type: 'long',
      name: 'prefetchSize',
      default: 0,
    },
    {
      type: 'short',
      name: 'prefetchCount',
      default: 0,
    },
    {
      type: 'bit',
      name: 'global',
      default: !1,
    },
  ],
});

module.exports.BasicQosOk = 3932171;

var methodInfoBasicQosOk = (module.exports.methodInfoBasicQosOk = {
  id: 3932171,
  classId: 60,
  methodId: 11,
  name: 'BasicQosOk',
  args: [],
});

module.exports.BasicConsume = 3932180;

var methodInfoBasicConsume = (module.exports.methodInfoBasicConsume = {
  id: 3932180,
  classId: 60,
  methodId: 20,
  name: 'BasicConsume',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'shortstr',
      name: 'consumerTag',
      default: '',
    },
    {
      type: 'bit',
      name: 'noLocal',
      default: !1,
    },
    {
      type: 'bit',
      name: 'noAck',
      default: !1,
    },
    {
      type: 'bit',
      name: 'exclusive',
      default: !1,
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.BasicConsumeOk = 3932181;

var methodInfoBasicConsumeOk = (module.exports.methodInfoBasicConsumeOk = {
  id: 3932181,
  classId: 60,
  methodId: 21,
  name: 'BasicConsumeOk',
  args: [
    {
      type: 'shortstr',
      name: 'consumerTag',
    },
  ],
});

module.exports.BasicCancel = 3932190;

var methodInfoBasicCancel = (module.exports.methodInfoBasicCancel = {
  id: 3932190,
  classId: 60,
  methodId: 30,
  name: 'BasicCancel',
  args: [
    {
      type: 'shortstr',
      name: 'consumerTag',
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
  ],
});

module.exports.BasicCancelOk = 3932191;

var methodInfoBasicCancelOk = (module.exports.methodInfoBasicCancelOk = {
  id: 3932191,
  classId: 60,
  methodId: 31,
  name: 'BasicCancelOk',
  args: [
    {
      type: 'shortstr',
      name: 'consumerTag',
    },
  ],
});

module.exports.BasicPublish = 3932200;

var methodInfoBasicPublish = (module.exports.methodInfoBasicPublish = {
  id: 3932200,
  classId: 60,
  methodId: 40,
  name: 'BasicPublish',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'exchange',
      default: '',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
      default: '',
    },
    {
      type: 'bit',
      name: 'mandatory',
      default: !1,
    },
    {
      type: 'bit',
      name: 'immediate',
      default: !1,
    },
  ],
});

module.exports.BasicReturn = 3932210;

var methodInfoBasicReturn = (module.exports.methodInfoBasicReturn = {
  id: 3932210,
  classId: 60,
  methodId: 50,
  name: 'BasicReturn',
  args: [
    {
      type: 'short',
      name: 'replyCode',
    },
    {
      type: 'shortstr',
      name: 'replyText',
      default: '',
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
    },
  ],
});

module.exports.BasicDeliver = 3932220;

var methodInfoBasicDeliver = (module.exports.methodInfoBasicDeliver = {
  id: 3932220,
  classId: 60,
  methodId: 60,
  name: 'BasicDeliver',
  args: [
    {
      type: 'shortstr',
      name: 'consumerTag',
    },
    {
      type: 'longlong',
      name: 'deliveryTag',
    },
    {
      type: 'bit',
      name: 'redelivered',
      default: !1,
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
    },
  ],
});

module.exports.BasicGet = 3932230;

var methodInfoBasicGet = (module.exports.methodInfoBasicGet = {
  id: 3932230,
  classId: 60,
  methodId: 70,
  name: 'BasicGet',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'bit',
      name: 'noAck',
      default: !1,
    },
  ],
});

module.exports.BasicGetOk = 3932231;

var methodInfoBasicGetOk = (module.exports.methodInfoBasicGetOk = {
  id: 3932231,
  classId: 60,
  methodId: 71,
  name: 'BasicGetOk',
  args: [
    {
      type: 'longlong',
      name: 'deliveryTag',
    },
    {
      type: 'bit',
      name: 'redelivered',
      default: !1,
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
    },
    {
      type: 'long',
      name: 'messageCount',
    },
  ],
});

module.exports.BasicGetEmpty = 3932232;

var methodInfoBasicGetEmpty = (module.exports.methodInfoBasicGetEmpty = {
  id: 3932232,
  classId: 60,
  methodId: 72,
  name: 'BasicGetEmpty',
  args: [
    {
      type: 'shortstr',
      name: 'clusterId',
      default: '',
    },
  ],
});

module.exports.BasicAck = 3932240;

var methodInfoBasicAck = (module.exports.methodInfoBasicAck = {
  id: 3932240,
  classId: 60,
  methodId: 80,
  name: 'BasicAck',
  args: [
    {
      type: 'longlong',
      name: 'deliveryTag',
      default: 0,
    },
    {
      type: 'bit',
      name: 'multiple',
      default: !1,
    },
  ],
});

module.exports.BasicReject = 3932250;

var methodInfoBasicReject = (module.exports.methodInfoBasicReject = {
  id: 3932250,
  classId: 60,
  methodId: 90,
  name: 'BasicReject',
  args: [
    {
      type: 'longlong',
      name: 'deliveryTag',
    },
    {
      type: 'bit',
      name: 'requeue',
      default: !0,
    },
  ],
});

module.exports.BasicRecoverAsync = 3932260;

var methodInfoBasicRecoverAsync = (module.exports.methodInfoBasicRecoverAsync = {
  id: 3932260,
  classId: 60,
  methodId: 100,
  name: 'BasicRecoverAsync',
  args: [
    {
      type: 'bit',
      name: 'requeue',
      default: !1,
    },
  ],
});

module.exports.BasicRecover = 3932270;

var methodInfoBasicRecover = (module.exports.methodInfoBasicRecover = {
  id: 3932270,
  classId: 60,
  methodId: 110,
  name: 'BasicRecover',
  args: [
    {
      type: 'bit',
      name: 'requeue',
      default: !1,
    },
  ],
});

module.exports.BasicRecoverOk = 3932271;

var methodInfoBasicRecoverOk = (module.exports.methodInfoBasicRecoverOk = {
  id: 3932271,
  classId: 60,
  methodId: 111,
  name: 'BasicRecoverOk',
  args: [],
});

module.exports.BasicNack = 3932280;

var methodInfoBasicNack = (module.exports.methodInfoBasicNack = {
  id: 3932280,
  classId: 60,
  methodId: 120,
  name: 'BasicNack',
  args: [
    {
      type: 'longlong',
      name: 'deliveryTag',
      default: 0,
    },
    {
      type: 'bit',
      name: 'multiple',
      default: !1,
    },
    {
      type: 'bit',
      name: 'requeue',
      default: !0,
    },
  ],
});

module.exports.ConnectionStart = 655370;

var methodInfoConnectionStart = (module.exports.methodInfoConnectionStart = {
  id: 655370,
  classId: 10,
  methodId: 10,
  name: 'ConnectionStart',
  args: [
    {
      type: 'octet',
      name: 'versionMajor',
      default: 0,
    },
    {
      type: 'octet',
      name: 'versionMinor',
      default: 9,
    },
    {
      type: 'table',
      name: 'serverProperties',
    },
    {
      type: 'longstr',
      name: 'mechanisms',
      default: 'PLAIN',
    },
    {
      type: 'longstr',
      name: 'locales',
      default: 'en_US',
    },
  ],
});

module.exports.ConnectionStartOk = 655371;

var methodInfoConnectionStartOk = (module.exports.methodInfoConnectionStartOk = {
  id: 655371,
  classId: 10,
  methodId: 11,
  name: 'ConnectionStartOk',
  args: [
    {
      type: 'table',
      name: 'clientProperties',
    },
    {
      type: 'shortstr',
      name: 'mechanism',
      default: 'PLAIN',
    },
    {
      type: 'longstr',
      name: 'response',
    },
    {
      type: 'shortstr',
      name: 'locale',
      default: 'en_US',
    },
  ],
});

module.exports.ConnectionSecure = 655380;

var methodInfoConnectionSecure = (module.exports.methodInfoConnectionSecure = {
  id: 655380,
  classId: 10,
  methodId: 20,
  name: 'ConnectionSecure',
  args: [
    {
      type: 'longstr',
      name: 'challenge',
    },
  ],
});

module.exports.ConnectionSecureOk = 655381;

var methodInfoConnectionSecureOk = (module.exports.methodInfoConnectionSecureOk = {
  id: 655381,
  classId: 10,
  methodId: 21,
  name: 'ConnectionSecureOk',
  args: [
    {
      type: 'longstr',
      name: 'response',
    },
  ],
});

module.exports.ConnectionTune = 655390;

var methodInfoConnectionTune = (module.exports.methodInfoConnectionTune = {
  id: 655390,
  classId: 10,
  methodId: 30,
  name: 'ConnectionTune',
  args: [
    {
      type: 'short',
      name: 'channelMax',
      default: 0,
    },
    {
      type: 'long',
      name: 'frameMax',
      default: 0,
    },
    {
      type: 'short',
      name: 'heartbeat',
      default: 0,
    },
  ],
});

module.exports.ConnectionTuneOk = 655391;

var methodInfoConnectionTuneOk = (module.exports.methodInfoConnectionTuneOk = {
  id: 655391,
  classId: 10,
  methodId: 31,
  name: 'ConnectionTuneOk',
  args: [
    {
      type: 'short',
      name: 'channelMax',
      default: 0,
    },
    {
      type: 'long',
      name: 'frameMax',
      default: 0,
    },
    {
      type: 'short',
      name: 'heartbeat',
      default: 0,
    },
  ],
});

module.exports.ConnectionOpen = 655400;

var methodInfoConnectionOpen = (module.exports.methodInfoConnectionOpen = {
  id: 655400,
  classId: 10,
  methodId: 40,
  name: 'ConnectionOpen',
  args: [
    {
      type: 'shortstr',
      name: 'virtualHost',
      default: '/',
    },
    {
      type: 'shortstr',
      name: 'capabilities',
      default: '',
    },
    {
      type: 'bit',
      name: 'insist',
      default: !1,
    },
  ],
});

module.exports.ConnectionOpenOk = 655401;

var methodInfoConnectionOpenOk = (module.exports.methodInfoConnectionOpenOk = {
  id: 655401,
  classId: 10,
  methodId: 41,
  name: 'ConnectionOpenOk',
  args: [
    {
      type: 'shortstr',
      name: 'knownHosts',
      default: '',
    },
  ],
});

module.exports.ConnectionClose = 655410;

var methodInfoConnectionClose = (module.exports.methodInfoConnectionClose = {
  id: 655410,
  classId: 10,
  methodId: 50,
  name: 'ConnectionClose',
  args: [
    {
      type: 'short',
      name: 'replyCode',
    },
    {
      type: 'shortstr',
      name: 'replyText',
      default: '',
    },
    {
      type: 'short',
      name: 'classId',
    },
    {
      type: 'short',
      name: 'methodId',
    },
  ],
});

module.exports.ConnectionCloseOk = 655411;

var methodInfoConnectionCloseOk = (module.exports.methodInfoConnectionCloseOk = {
  id: 655411,
  classId: 10,
  methodId: 51,
  name: 'ConnectionCloseOk',
  args: [],
});

module.exports.ConnectionBlocked = 655420;

var methodInfoConnectionBlocked = (module.exports.methodInfoConnectionBlocked = {
  id: 655420,
  classId: 10,
  methodId: 60,
  name: 'ConnectionBlocked',
  args: [
    {
      type: 'shortstr',
      name: 'reason',
      default: '',
    },
  ],
});

module.exports.ConnectionUnblocked = 655421;

var methodInfoConnectionUnblocked = (module.exports.methodInfoConnectionUnblocked = {
  id: 655421,
  classId: 10,
  methodId: 61,
  name: 'ConnectionUnblocked',
  args: [],
});

module.exports.ConnectionUpdateSecret = 655430;

var methodInfoConnectionUpdateSecret = (module.exports.methodInfoConnectionUpdateSecret = {
  id: 655430,
  classId: 10,
  methodId: 70,
  name: 'ConnectionUpdateSecret',
  args: [
    {
      type: 'longstr',
      name: 'newSecret',
    },
    {
      type: 'shortstr',
      name: 'reason',
    },
  ],
});

module.exports.ConnectionUpdateSecretOk = 655431;

var methodInfoConnectionUpdateSecretOk = (module.exports.methodInfoConnectionUpdateSecretOk = {
  id: 655431,
  classId: 10,
  methodId: 71,
  name: 'ConnectionUpdateSecretOk',
  args: [],
});

module.exports.ChannelOpen = 1310730;

var methodInfoChannelOpen = (module.exports.methodInfoChannelOpen = {
  id: 1310730,
  classId: 20,
  methodId: 10,
  name: 'ChannelOpen',
  args: [
    {
      type: 'shortstr',
      name: 'outOfBand',
      default: '',
    },
  ],
});

module.exports.ChannelOpenOk = 1310731;

var methodInfoChannelOpenOk = (module.exports.methodInfoChannelOpenOk = {
  id: 1310731,
  classId: 20,
  methodId: 11,
  name: 'ChannelOpenOk',
  args: [
    {
      type: 'longstr',
      name: 'channelId',
      default: '',
    },
  ],
});

module.exports.ChannelFlow = 1310740;

var methodInfoChannelFlow = (module.exports.methodInfoChannelFlow = {
  id: 1310740,
  classId: 20,
  methodId: 20,
  name: 'ChannelFlow',
  args: [
    {
      type: 'bit',
      name: 'active',
    },
  ],
});

module.exports.ChannelFlowOk = 1310741;

var methodInfoChannelFlowOk = (module.exports.methodInfoChannelFlowOk = {
  id: 1310741,
  classId: 20,
  methodId: 21,
  name: 'ChannelFlowOk',
  args: [
    {
      type: 'bit',
      name: 'active',
    },
  ],
});

module.exports.ChannelClose = 1310760;

var methodInfoChannelClose = (module.exports.methodInfoChannelClose = {
  id: 1310760,
  classId: 20,
  methodId: 40,
  name: 'ChannelClose',
  args: [
    {
      type: 'short',
      name: 'replyCode',
    },
    {
      type: 'shortstr',
      name: 'replyText',
      default: '',
    },
    {
      type: 'short',
      name: 'classId',
    },
    {
      type: 'short',
      name: 'methodId',
    },
  ],
});

module.exports.ChannelCloseOk = 1310761;

var methodInfoChannelCloseOk = (module.exports.methodInfoChannelCloseOk = {
  id: 1310761,
  classId: 20,
  methodId: 41,
  name: 'ChannelCloseOk',
  args: [],
});

module.exports.AccessRequest = 1966090;

var methodInfoAccessRequest = (module.exports.methodInfoAccessRequest = {
  id: 1966090,
  classId: 30,
  methodId: 10,
  name: 'AccessRequest',
  args: [
    {
      type: 'shortstr',
      name: 'realm',
      default: '/data',
    },
    {
      type: 'bit',
      name: 'exclusive',
      default: !1,
    },
    {
      type: 'bit',
      name: 'passive',
      default: !0,
    },
    {
      type: 'bit',
      name: 'active',
      default: !0,
    },
    {
      type: 'bit',
      name: 'write',
      default: !0,
    },
    {
      type: 'bit',
      name: 'read',
      default: !0,
    },
  ],
});

module.exports.AccessRequestOk = 1966091;

var methodInfoAccessRequestOk = (module.exports.methodInfoAccessRequestOk = {
  id: 1966091,
  classId: 30,
  methodId: 11,
  name: 'AccessRequestOk',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 1,
    },
  ],
});

module.exports.ExchangeDeclare = 2621450;

var methodInfoExchangeDeclare = (module.exports.methodInfoExchangeDeclare = {
  id: 2621450,
  classId: 40,
  methodId: 10,
  name: 'ExchangeDeclare',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'type',
      default: 'direct',
    },
    {
      type: 'bit',
      name: 'passive',
      default: !1,
    },
    {
      type: 'bit',
      name: 'durable',
      default: !1,
    },
    {
      type: 'bit',
      name: 'autoDelete',
      default: !1,
    },
    {
      type: 'bit',
      name: 'internal',
      default: !1,
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.ExchangeDeclareOk = 2621451;

var methodInfoExchangeDeclareOk = (module.exports.methodInfoExchangeDeclareOk = {
  id: 2621451,
  classId: 40,
  methodId: 11,
  name: 'ExchangeDeclareOk',
  args: [],
});

module.exports.ExchangeDelete = 2621460;

var methodInfoExchangeDelete = (module.exports.methodInfoExchangeDelete = {
  id: 2621460,
  classId: 40,
  methodId: 20,
  name: 'ExchangeDelete',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'bit',
      name: 'ifUnused',
      default: !1,
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
  ],
});

module.exports.ExchangeDeleteOk = 2621461;

var methodInfoExchangeDeleteOk = (module.exports.methodInfoExchangeDeleteOk = {
  id: 2621461,
  classId: 40,
  methodId: 21,
  name: 'ExchangeDeleteOk',
  args: [],
});

module.exports.ExchangeBind = 2621470;

var methodInfoExchangeBind = (module.exports.methodInfoExchangeBind = {
  id: 2621470,
  classId: 40,
  methodId: 30,
  name: 'ExchangeBind',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'destination',
    },
    {
      type: 'shortstr',
      name: 'source',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
      default: '',
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.ExchangeBindOk = 2621471;

var methodInfoExchangeBindOk = (module.exports.methodInfoExchangeBindOk = {
  id: 2621471,
  classId: 40,
  methodId: 31,
  name: 'ExchangeBindOk',
  args: [],
});

module.exports.ExchangeUnbind = 2621480;

var methodInfoExchangeUnbind = (module.exports.methodInfoExchangeUnbind = {
  id: 2621480,
  classId: 40,
  methodId: 40,
  name: 'ExchangeUnbind',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'destination',
    },
    {
      type: 'shortstr',
      name: 'source',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
      default: '',
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.ExchangeUnbindOk = 2621491;

var methodInfoExchangeUnbindOk = (module.exports.methodInfoExchangeUnbindOk = {
  id: 2621491,
  classId: 40,
  methodId: 51,
  name: 'ExchangeUnbindOk',
  args: [],
});

module.exports.QueueDeclare = 3276810;

var methodInfoQueueDeclare = (module.exports.methodInfoQueueDeclare = {
  id: 3276810,
  classId: 50,
  methodId: 10,
  name: 'QueueDeclare',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'bit',
      name: 'passive',
      default: !1,
    },
    {
      type: 'bit',
      name: 'durable',
      default: !1,
    },
    {
      type: 'bit',
      name: 'exclusive',
      default: !1,
    },
    {
      type: 'bit',
      name: 'autoDelete',
      default: !1,
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.QueueDeclareOk = 3276811;

var methodInfoQueueDeclareOk = (module.exports.methodInfoQueueDeclareOk = {
  id: 3276811,
  classId: 50,
  methodId: 11,
  name: 'QueueDeclareOk',
  args: [
    {
      type: 'shortstr',
      name: 'queue',
    },
    {
      type: 'long',
      name: 'messageCount',
    },
    {
      type: 'long',
      name: 'consumerCount',
    },
  ],
});

module.exports.QueueBind = 3276820;

var methodInfoQueueBind = (module.exports.methodInfoQueueBind = {
  id: 3276820,
  classId: 50,
  methodId: 20,
  name: 'QueueBind',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
      default: '',
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.QueueBindOk = 3276821;

var methodInfoQueueBindOk = (module.exports.methodInfoQueueBindOk = {
  id: 3276821,
  classId: 50,
  methodId: 21,
  name: 'QueueBindOk',
  args: [],
});

module.exports.QueuePurge = 3276830;

var methodInfoQueuePurge = (module.exports.methodInfoQueuePurge = {
  id: 3276830,
  classId: 50,
  methodId: 30,
  name: 'QueuePurge',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
  ],
});

module.exports.QueuePurgeOk = 3276831;

var methodInfoQueuePurgeOk = (module.exports.methodInfoQueuePurgeOk = {
  id: 3276831,
  classId: 50,
  methodId: 31,
  name: 'QueuePurgeOk',
  args: [
    {
      type: 'long',
      name: 'messageCount',
    },
  ],
});

module.exports.QueueDelete = 3276840;

var methodInfoQueueDelete = (module.exports.methodInfoQueueDelete = {
  id: 3276840,
  classId: 50,
  methodId: 40,
  name: 'QueueDelete',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'bit',
      name: 'ifUnused',
      default: !1,
    },
    {
      type: 'bit',
      name: 'ifEmpty',
      default: !1,
    },
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
  ],
});

module.exports.QueueDeleteOk = 3276841;

var methodInfoQueueDeleteOk = (module.exports.methodInfoQueueDeleteOk = {
  id: 3276841,
  classId: 50,
  methodId: 41,
  name: 'QueueDeleteOk',
  args: [
    {
      type: 'long',
      name: 'messageCount',
    },
  ],
});

module.exports.QueueUnbind = 3276850;

var methodInfoQueueUnbind = (module.exports.methodInfoQueueUnbind = {
  id: 3276850,
  classId: 50,
  methodId: 50,
  name: 'QueueUnbind',
  args: [
    {
      type: 'short',
      name: 'ticket',
      default: 0,
    },
    {
      type: 'shortstr',
      name: 'queue',
      default: '',
    },
    {
      type: 'shortstr',
      name: 'exchange',
    },
    {
      type: 'shortstr',
      name: 'routingKey',
      default: '',
    },
    {
      type: 'table',
      name: 'arguments',
      default: {},
    },
  ],
});

module.exports.QueueUnbindOk = 3276851;

var methodInfoQueueUnbindOk = (module.exports.methodInfoQueueUnbindOk = {
  id: 3276851,
  classId: 50,
  methodId: 51,
  name: 'QueueUnbindOk',
  args: [],
});

module.exports.TxSelect = 5898250;

var methodInfoTxSelect = (module.exports.methodInfoTxSelect = {
  id: 5898250,
  classId: 90,
  methodId: 10,
  name: 'TxSelect',
  args: [],
});

module.exports.TxSelectOk = 5898251;

var methodInfoTxSelectOk = (module.exports.methodInfoTxSelectOk = {
  id: 5898251,
  classId: 90,
  methodId: 11,
  name: 'TxSelectOk',
  args: [],
});

module.exports.TxCommit = 5898260;

var methodInfoTxCommit = (module.exports.methodInfoTxCommit = {
  id: 5898260,
  classId: 90,
  methodId: 20,
  name: 'TxCommit',
  args: [],
});

module.exports.TxCommitOk = 5898261;

var methodInfoTxCommitOk = (module.exports.methodInfoTxCommitOk = {
  id: 5898261,
  classId: 90,
  methodId: 21,
  name: 'TxCommitOk',
  args: [],
});

module.exports.TxRollback = 5898270;

var methodInfoTxRollback = (module.exports.methodInfoTxRollback = {
  id: 5898270,
  classId: 90,
  methodId: 30,
  name: 'TxRollback',
  args: [],
});

module.exports.TxRollbackOk = 5898271;

var methodInfoTxRollbackOk = (module.exports.methodInfoTxRollbackOk = {
  id: 5898271,
  classId: 90,
  methodId: 31,
  name: 'TxRollbackOk',
  args: [],
});

module.exports.ConfirmSelect = 5570570;

var methodInfoConfirmSelect = (module.exports.methodInfoConfirmSelect = {
  id: 5570570,
  classId: 85,
  methodId: 10,
  name: 'ConfirmSelect',
  args: [
    {
      type: 'bit',
      name: 'nowait',
      default: !1,
    },
  ],
});

module.exports.ConfirmSelectOk = 5570571;

var methodInfoConfirmSelectOk = (module.exports.methodInfoConfirmSelectOk = {
  id: 5570571,
  classId: 85,
  methodId: 11,
  name: 'ConfirmSelectOk',
  args: [],
});

module.exports.BasicProperties = 60;

var propertiesInfoBasicProperties = (module.exports.propertiesInfoBasicProperties = {
  id: 60,
  name: 'BasicProperties',
  args: [
    {
      type: 'shortstr',
      name: 'contentType',
    },
    {
      type: 'shortstr',
      name: 'contentEncoding',
    },
    {
      type: 'table',
      name: 'headers',
    },
    {
      type: 'octet',
      name: 'deliveryMode',
    },
    {
      type: 'octet',
      name: 'priority',
    },
    {
      type: 'shortstr',
      name: 'correlationId',
    },
    {
      type: 'shortstr',
      name: 'replyTo',
    },
    {
      type: 'shortstr',
      name: 'expiration',
    },
    {
      type: 'shortstr',
      name: 'messageId',
    },
    {
      type: 'timestamp',
      name: 'timestamp',
    },
    {
      type: 'shortstr',
      name: 'type',
    },
    {
      type: 'shortstr',
      name: 'userId',
    },
    {
      type: 'shortstr',
      name: 'appId',
    },
    {
      type: 'shortstr',
      name: 'clusterId',
    },
  ],
});
