amqplib/lib/defs.js

var codec = require("./codec");
var encodeTable = codec.encodeTable;
var decodeFields = codec.decodeFields;

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.decode = function(id, buf) {
    switch (id) {
    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 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 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 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);
    }
}

module.exports.encodeMethod = function(id, channel, fields) {
    switch (id) {
    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 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 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 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);
    }
}
module.exports.encodeProperties = function(id, channel, size, fields) {
    switch (id) {
    case 60: return encodeBasicProperties(channel, size, fields);
    }
}
module.exports.info = function(id) {
    switch(id) {
    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 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 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 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();
    }
}


module.exports.ConnectionStart = 655370;

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

function encodeConnectionStart(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655370, 7);
    offset = 11;
    if (fields['versionMajor'] === undefined)
        throw new Error("Missing value for versionMajor");
    val = fields['versionMajor'];
    buffer.writeUInt8(val, offset); offset++;
    val = fields['versionMinor']; val = (val === undefined) ? 9 : val;
    buffer.writeUInt8(val, offset); offset++;
    if (fields['serverProperties'] === undefined)
        throw new Error("Missing value for serverProperties");
    val = fields['serverProperties'];
    offset += encodeTable(buffer, val, offset);
    val = fields['mechanisms']; val = (val === undefined) ? "PLAIN" : val;
    len = val.length;
    buffer.writeUInt32BE(len, offset); offset += 4;
    val.copy(buffer, offset); offset += len;
    val = fields['locales']; val = (val === undefined) ? "en_US" : val;
    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.slice(0, offset + 1);
}

module.exports.methodInfoConnectionStart = methodInfoConnectionStart = {
  "id": 655370,
  "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;

function decodeConnectionStartOk(buffer) {
    var fields = {}, offset = 0, val, len;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(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.slice(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 offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655371, 7);
    offset = 11;
    if (fields['clientProperties'] === undefined)
        throw new Error("Missing value for clientProperties");
    val = fields['clientProperties'];
    offset += encodeTable(buffer, val, offset);
    val = fields['mechanism']; val = (val === undefined) ? "PLAIN" : val;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['response'] === undefined)
        throw new Error("Missing value for response");
    val = fields['response'];
    len = val.length;
    buffer.writeUInt32BE(len, offset); offset += 4;
    val.copy(buffer, offset); offset += len;
    val = fields['locale']; val = (val === undefined) ? "en_US" : val;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoConnectionStartOk = methodInfoConnectionStartOk = {
  "id": 655371,
  "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;

function decodeConnectionSecure(buffer) {
    var fields = {}, offset = 0, val, len;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = buffer.slice(offset, offset + len);
    offset += len;
    fields['challenge'] = val;
    return fields;
}

function encodeConnectionSecure(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655380, 7);
    offset = 11;
    if (fields['challenge'] === undefined)
        throw new Error("Missing value for challenge");
    val = fields['challenge'];
    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.slice(0, offset + 1);
}

module.exports.methodInfoConnectionSecure = methodInfoConnectionSecure = {
  "id": 655380,
  "name": "ConnectionSecure",
  "args": [
    {
      "type": "longstr",
      "name": "challenge"
    }
  ]
}

module.exports.ConnectionSecureOk = 655381;

function decodeConnectionSecureOk(buffer) {
    var fields = {}, offset = 0, val, len;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = buffer.slice(offset, offset + len);
    offset += len;
    fields['response'] = val;
    return fields;
}

function encodeConnectionSecureOk(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655381, 7);
    offset = 11;
    if (fields['response'] === undefined)
        throw new Error("Missing value for response");
    val = fields['response'];
    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.slice(0, offset + 1);
}

module.exports.methodInfoConnectionSecureOk = methodInfoConnectionSecureOk = {
  "id": 655381,
  "name": "ConnectionSecureOk",
  "args": [
    {
      "type": "longstr",
      "name": "response"
    }
  ]
}

module.exports.ConnectionTune = 655390;

function decodeConnectionTune(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(20);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655390, 7);
    offset = 11;
    if (fields['channelMax'] === undefined)
        throw new Error("Missing value for channelMax");
    val = fields['channelMax'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['frameMax'] === undefined)
        throw new Error("Missing value for frameMax");
    val = fields['frameMax'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    if (fields['heartbeat'] === undefined)
        throw new Error("Missing value for heartbeat");
    val = fields['heartbeat'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoConnectionTune = methodInfoConnectionTune = {
  "id": 655390,
  "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;

function decodeConnectionTuneOk(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(20);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655391, 7);
    offset = 11;
    if (fields['channelMax'] === undefined)
        throw new Error("Missing value for channelMax");
    val = fields['channelMax'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['frameMax'] === undefined)
        throw new Error("Missing value for frameMax");
    val = fields['frameMax'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    if (fields['heartbeat'] === undefined)
        throw new Error("Missing value for heartbeat");
    val = fields['heartbeat'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoConnectionTuneOk = methodInfoConnectionTuneOk = {
  "id": 655391,
  "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;

function decodeConnectionOpen(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['insist'] = val;
    return fields;
}

function encodeConnectionOpen(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655400, 7);
    offset = 11;
    val = fields['virtualHost']; val = (val === undefined) ? "/" : val;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['capabilities'] === undefined)
        throw new Error("Missing value for capabilities");
    val = fields['capabilities'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['insist'] === undefined)
        throw new Error("Missing value for insist");
    val = fields['insist'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoConnectionOpen = methodInfoConnectionOpen = {
  "id": 655400,
  "name": "ConnectionOpen",
  "args": [
    {
      "type": "shortstr",
      "name": "virtualHost",
      "default": "/"
    },
    {
      "type": "shortstr",
      "name": "capabilities",
      "default": ""
    },
    {
      "type": "bit",
      "name": "insist",
      "default": false
    }
  ]
}

module.exports.ConnectionOpenOk = 655401;

function decodeConnectionOpenOk(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655401, 7);
    offset = 11;
    if (fields['knownHosts'] === undefined)
        throw new Error("Missing value for knownHosts");
    val = fields['knownHosts'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoConnectionOpenOk = methodInfoConnectionOpenOk = {
  "id": 655401,
  "name": "ConnectionOpenOk",
  "args": [
    {
      "type": "shortstr",
      "name": "knownHosts",
      "default": ""
    }
  ]
}

module.exports.ConnectionClose = 655410;

function decodeConnectionClose(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(655410, 7);
    offset = 11;
    if (fields['replyCode'] === undefined)
        throw new Error("Missing value for replyCode");
    val = fields['replyCode'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['replyText'] === undefined)
        throw new Error("Missing value for replyText");
    val = fields['replyText'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['classId'] === undefined)
        throw new Error("Missing value for classId");
    val = fields['classId'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['methodId'] === undefined)
        throw new Error("Missing value for methodId");
    val = fields['methodId'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoConnectionClose = methodInfoConnectionClose = {
  "id": 655410,
  "name": "ConnectionClose",
  "args": [
    {
      "type": "short",
      "name": "replyCode"
    },
    {
      "type": "shortstr",
      "name": "replyText",
      "default": ""
    },
    {
      "type": "short",
      "name": "classId"
    },
    {
      "type": "short",
      "name": "methodId"
    }
  ]
}

module.exports.ConnectionCloseOk = 655411;

function decodeConnectionCloseOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoConnectionCloseOk = methodInfoConnectionCloseOk = {
  "id": 655411,
  "name": "ConnectionCloseOk",
  "args": []
}

module.exports.ChannelOpen = 1310730;

function decodeChannelOpen(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(1310730, 7);
    offset = 11;
    if (fields['outOfBand'] === undefined)
        throw new Error("Missing value for outOfBand");
    val = fields['outOfBand'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoChannelOpen = methodInfoChannelOpen = {
  "id": 1310730,
  "name": "ChannelOpen",
  "args": [
    {
      "type": "shortstr",
      "name": "outOfBand",
      "default": ""
    }
  ]
}

module.exports.ChannelOpenOk = 1310731;

function decodeChannelOpenOk(buffer) {
    var fields = {}, offset = 0, val, len;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = buffer.slice(offset, offset + len);
    offset += len;
    fields['channelId'] = val;
    return fields;
}

function encodeChannelOpenOk(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(1310731, 7);
    offset = 11;
    if (fields['channelId'] === undefined)
        throw new Error("Missing value for channelId");
    val = fields['channelId'];
    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.slice(0, offset + 1);
}

module.exports.methodInfoChannelOpenOk = methodInfoChannelOpenOk = {
  "id": 1310731,
  "name": "ChannelOpenOk",
  "args": [
    {
      "type": "longstr",
      "name": "channelId",
      "default": ""
    }
  ]
}

module.exports.ChannelFlow = 1310740;

function decodeChannelFlow(buffer) {
    var fields = {}, offset = 0, val, len;
    val = !!(buffer[offset] & 1);
    fields['active'] = val;
    return fields;
}

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

module.exports.methodInfoChannelFlow = methodInfoChannelFlow = {
  "id": 1310740,
  "name": "ChannelFlow",
  "args": [
    {
      "type": "bit",
      "name": "active"
    }
  ]
}

module.exports.ChannelFlowOk = 1310741;

function decodeChannelFlowOk(buffer) {
    var fields = {}, offset = 0, val, len;
    val = !!(buffer[offset] & 1);
    fields['active'] = val;
    return fields;
}

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

module.exports.methodInfoChannelFlowOk = methodInfoChannelFlowOk = {
  "id": 1310741,
  "name": "ChannelFlowOk",
  "args": [
    {
      "type": "bit",
      "name": "active"
    }
  ]
}

module.exports.ChannelClose = 1310760;

function decodeChannelClose(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(1310760, 7);
    offset = 11;
    if (fields['replyCode'] === undefined)
        throw new Error("Missing value for replyCode");
    val = fields['replyCode'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['replyText'] === undefined)
        throw new Error("Missing value for replyText");
    val = fields['replyText'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['classId'] === undefined)
        throw new Error("Missing value for classId");
    val = fields['classId'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['methodId'] === undefined)
        throw new Error("Missing value for methodId");
    val = fields['methodId'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoChannelClose = methodInfoChannelClose = {
  "id": 1310760,
  "name": "ChannelClose",
  "args": [
    {
      "type": "short",
      "name": "replyCode"
    },
    {
      "type": "shortstr",
      "name": "replyText",
      "default": ""
    },
    {
      "type": "short",
      "name": "classId"
    },
    {
      "type": "short",
      "name": "methodId"
    }
  ]
}

module.exports.ChannelCloseOk = 1310761;

function decodeChannelCloseOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoChannelCloseOk = methodInfoChannelCloseOk = {
  "id": 1310761,
  "name": "ChannelCloseOk",
  "args": []
}

module.exports.AccessRequest = 1966090;

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

function encodeAccessRequest(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(1966090, 7);
    offset = 11;
    val = fields['realm']; val = (val === undefined) ? "/data" : val;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['exclusive'] === undefined)
        throw new Error("Missing value for exclusive");
    val = fields['exclusive'];
    if (val) bits += 1;
    val = fields['passive']; val = (val === undefined) ? true : val;
    if (val) bits += 2;
    val = fields['active']; val = (val === undefined) ? true : val;
    if (val) bits += 4;
    val = fields['write']; val = (val === undefined) ? true : val;
    if (val) bits += 8;
    val = fields['read']; val = (val === undefined) ? true : val;
    if (val) bits += 16;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoAccessRequest = methodInfoAccessRequest = {
  "id": 1966090,
  "name": "AccessRequest",
  "args": [
    {
      "type": "shortstr",
      "name": "realm",
      "default": "/data"
    },
    {
      "type": "bit",
      "name": "exclusive",
      "default": false
    },
    {
      "type": "bit",
      "name": "passive",
      "default": true
    },
    {
      "type": "bit",
      "name": "active",
      "default": true
    },
    {
      "type": "bit",
      "name": "write",
      "default": true
    },
    {
      "type": "bit",
      "name": "read",
      "default": true
    }
  ]
}

module.exports.AccessRequestOk = 1966091;

function decodeAccessRequestOk(buffer) {
    var fields = {}, offset = 0, val, len;
    val = buffer.readUInt16BE(offset); offset += 2;
    fields['ticket'] = val;
    return fields;
}

function encodeAccessRequestOk(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(14);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(1966091, 7);
    offset = 11;
    val = fields['ticket']; val = (val === undefined) ? 1 : val;
    buffer.writeUInt16BE(val, offset); offset += 2;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoAccessRequestOk = methodInfoAccessRequestOk = {
  "id": 1966091,
  "name": "AccessRequestOk",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 1
    }
  ]
}

module.exports.ExchangeDeclare = 2621450;

function decodeExchangeDeclare(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['passive'] = val;
    val = !!(buffer[offset] & 2);
    fields['durable'] = val;
    val = !!(buffer[offset] & 4);
    fields['autoDelete'] = val;
    val = !!(buffer[offset] & 8);
    fields['internal'] = val;
    val = !!(buffer[offset] & 16);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeExchangeDeclare(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(2621450, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    val = fields['type']; val = (val === undefined) ? "direct" : val;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['passive'] === undefined)
        throw new Error("Missing value for passive");
    val = fields['passive'];
    if (val) bits += 1;
    if (fields['durable'] === undefined)
        throw new Error("Missing value for durable");
    val = fields['durable'];
    if (val) bits += 2;
    if (fields['autoDelete'] === undefined)
        throw new Error("Missing value for autoDelete");
    val = fields['autoDelete'];
    if (val) bits += 4;
    if (fields['internal'] === undefined)
        throw new Error("Missing value for internal");
    val = fields['internal'];
    if (val) bits += 8;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 16;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoExchangeDeclare = methodInfoExchangeDeclare = {
  "id": 2621450,
  "name": "ExchangeDeclare",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "exchange"
    },
    {
      "type": "shortstr",
      "name": "type",
      "default": "direct"
    },
    {
      "type": "bit",
      "name": "passive",
      "default": false
    },
    {
      "type": "bit",
      "name": "durable",
      "default": false
    },
    {
      "type": "bit",
      "name": "autoDelete",
      "default": false
    },
    {
      "type": "bit",
      "name": "internal",
      "default": false
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.ExchangeDeclareOk = 2621451;

function decodeExchangeDeclareOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoExchangeDeclareOk = methodInfoExchangeDeclareOk = {
  "id": 2621451,
  "name": "ExchangeDeclareOk",
  "args": []
}

module.exports.ExchangeDelete = 2621460;

function decodeExchangeDelete(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['ifUnused'] = val;
    val = !!(buffer[offset] & 2);
    fields['nowait'] = val;
    return fields;
}

function encodeExchangeDelete(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(2621460, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['ifUnused'] === undefined)
        throw new Error("Missing value for ifUnused");
    val = fields['ifUnused'];
    if (val) bits += 1;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 2;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoExchangeDelete = methodInfoExchangeDelete = {
  "id": 2621460,
  "name": "ExchangeDelete",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "exchange"
    },
    {
      "type": "bit",
      "name": "ifUnused",
      "default": false
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    }
  ]
}

module.exports.ExchangeDeleteOk = 2621461;

function decodeExchangeDeleteOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoExchangeDeleteOk = methodInfoExchangeDeleteOk = {
  "id": 2621461,
  "name": "ExchangeDeleteOk",
  "args": []
}

module.exports.ExchangeBind = 2621470;

function decodeExchangeBind(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeExchangeBind(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(2621470, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['destination'] === undefined)
        throw new Error("Missing value for destination");
    val = fields['destination'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['source'] === undefined)
        throw new Error("Missing value for source");
    val = fields['source'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoExchangeBind = methodInfoExchangeBind = {
  "id": 2621470,
  "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": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.ExchangeBindOk = 2621471;

function decodeExchangeBindOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoExchangeBindOk = methodInfoExchangeBindOk = {
  "id": 2621471,
  "name": "ExchangeBindOk",
  "args": []
}

module.exports.ExchangeUnbind = 2621480;

function decodeExchangeUnbind(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeExchangeUnbind(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(2621480, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['destination'] === undefined)
        throw new Error("Missing value for destination");
    val = fields['destination'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['source'] === undefined)
        throw new Error("Missing value for source");
    val = fields['source'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoExchangeUnbind = methodInfoExchangeUnbind = {
  "id": 2621480,
  "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": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.ExchangeUnbindOk = 2621491;

function decodeExchangeUnbindOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoExchangeUnbindOk = methodInfoExchangeUnbindOk = {
  "id": 2621491,
  "name": "ExchangeUnbindOk",
  "args": []
}

module.exports.QueueDeclare = 3276810;

function decodeQueueDeclare(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['passive'] = val;
    val = !!(buffer[offset] & 2);
    fields['durable'] = val;
    val = !!(buffer[offset] & 4);
    fields['exclusive'] = val;
    val = !!(buffer[offset] & 8);
    fields['autoDelete'] = val;
    val = !!(buffer[offset] & 16);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeQueueDeclare(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276810, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['passive'] === undefined)
        throw new Error("Missing value for passive");
    val = fields['passive'];
    if (val) bits += 1;
    if (fields['durable'] === undefined)
        throw new Error("Missing value for durable");
    val = fields['durable'];
    if (val) bits += 2;
    if (fields['exclusive'] === undefined)
        throw new Error("Missing value for exclusive");
    val = fields['exclusive'];
    if (val) bits += 4;
    if (fields['autoDelete'] === undefined)
        throw new Error("Missing value for autoDelete");
    val = fields['autoDelete'];
    if (val) bits += 8;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 16;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueueDeclare = methodInfoQueueDeclare = {
  "id": 3276810,
  "name": "QueueDeclare",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "queue",
      "default": ""
    },
    {
      "type": "bit",
      "name": "passive",
      "default": false
    },
    {
      "type": "bit",
      "name": "durable",
      "default": false
    },
    {
      "type": "bit",
      "name": "exclusive",
      "default": false
    },
    {
      "type": "bit",
      "name": "autoDelete",
      "default": false
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.QueueDeclareOk = 3276811;

function decodeQueueDeclareOk(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276811, 7);
    offset = 11;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['messageCount'] === undefined)
        throw new Error("Missing value for messageCount");
    val = fields['messageCount'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    if (fields['consumerCount'] === undefined)
        throw new Error("Missing value for consumerCount");
    val = fields['consumerCount'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueueDeclareOk = methodInfoQueueDeclareOk = {
  "id": 3276811,
  "name": "QueueDeclareOk",
  "args": [
    {
      "type": "shortstr",
      "name": "queue"
    },
    {
      "type": "long",
      "name": "messageCount"
    },
    {
      "type": "long",
      "name": "consumerCount"
    }
  ]
}

module.exports.QueueBind = 3276820;

function decodeQueueBind(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeQueueBind(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276820, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueueBind = methodInfoQueueBind = {
  "id": 3276820,
  "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": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.QueueBindOk = 3276821;

function decodeQueueBindOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoQueueBindOk = methodInfoQueueBindOk = {
  "id": 3276821,
  "name": "QueueBindOk",
  "args": []
}

module.exports.QueuePurge = 3276830;

function decodeQueuePurge(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['nowait'] = val;
    return fields;
}

function encodeQueuePurge(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276830, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueuePurge = methodInfoQueuePurge = {
  "id": 3276830,
  "name": "QueuePurge",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "queue",
      "default": ""
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    }
  ]
}

module.exports.QueuePurgeOk = 3276831;

function decodeQueuePurgeOk(buffer) {
    var fields = {}, offset = 0, val, len;
    val = buffer.readUInt32BE(offset); offset += 4;
    fields['messageCount'] = val;
    return fields;
}

function encodeQueuePurgeOk(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(16);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276831, 7);
    offset = 11;
    if (fields['messageCount'] === undefined)
        throw new Error("Missing value for messageCount");
    val = fields['messageCount'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoQueuePurgeOk = methodInfoQueuePurgeOk = {
  "id": 3276831,
  "name": "QueuePurgeOk",
  "args": [
    {
      "type": "long",
      "name": "messageCount"
    }
  ]
}

module.exports.QueueDelete = 3276840;

function decodeQueueDelete(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['ifUnused'] = val;
    val = !!(buffer[offset] & 2);
    fields['ifEmpty'] = val;
    val = !!(buffer[offset] & 4);
    fields['nowait'] = val;
    return fields;
}

function encodeQueueDelete(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276840, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['ifUnused'] === undefined)
        throw new Error("Missing value for ifUnused");
    val = fields['ifUnused'];
    if (val) bits += 1;
    if (fields['ifEmpty'] === undefined)
        throw new Error("Missing value for ifEmpty");
    val = fields['ifEmpty'];
    if (val) bits += 2;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 4;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueueDelete = methodInfoQueueDelete = {
  "id": 3276840,
  "name": "QueueDelete",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "queue",
      "default": ""
    },
    {
      "type": "bit",
      "name": "ifUnused",
      "default": false
    },
    {
      "type": "bit",
      "name": "ifEmpty",
      "default": false
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    }
  ]
}

module.exports.QueueDeleteOk = 3276841;

function decodeQueueDeleteOk(buffer) {
    var fields = {}, offset = 0, val, len;
    val = buffer.readUInt32BE(offset); offset += 4;
    fields['messageCount'] = val;
    return fields;
}

function encodeQueueDeleteOk(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(16);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276841, 7);
    offset = 11;
    if (fields['messageCount'] === undefined)
        throw new Error("Missing value for messageCount");
    val = fields['messageCount'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoQueueDeleteOk = methodInfoQueueDeleteOk = {
  "id": 3276841,
  "name": "QueueDeleteOk",
  "args": [
    {
      "type": "long",
      "name": "messageCount"
    }
  ]
}

module.exports.QueueUnbind = 3276850;

function decodeQueueUnbind(buffer) {
    var fields = {}, offset = 0, val, len;
    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.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeQueueUnbind(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3276850, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoQueueUnbind = methodInfoQueueUnbind = {
  "id": 3276850,
  "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;

function decodeQueueUnbindOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoQueueUnbindOk = methodInfoQueueUnbindOk = {
  "id": 3276851,
  "name": "QueueUnbindOk",
  "args": []
}

module.exports.BasicQos = 3932170;

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

function encodeBasicQos(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(19);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932170, 7);
    offset = 11;
    if (fields['prefetchSize'] === undefined)
        throw new Error("Missing value for prefetchSize");
    val = fields['prefetchSize'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    if (fields['prefetchCount'] === undefined)
        throw new Error("Missing value for prefetchCount");
    val = fields['prefetchCount'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['global'] === undefined)
        throw new Error("Missing value for global");
    val = fields['global'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicQos = methodInfoBasicQos = {
  "id": 3932170,
  "name": "BasicQos",
  "args": [
    {
      "type": "long",
      "name": "prefetchSize",
      "default": 0
    },
    {
      "type": "short",
      "name": "prefetchCount",
      "default": 0
    },
    {
      "type": "bit",
      "name": "global",
      "default": false
    }
  ]
}

module.exports.BasicQosOk = 3932171;

function decodeBasicQosOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoBasicQosOk = methodInfoBasicQosOk = {
  "id": 3932171,
  "name": "BasicQosOk",
  "args": []
}

module.exports.BasicConsume = 3932180;

function decodeBasicConsume(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['noLocal'] = val;
    val = !!(buffer[offset] & 2);
    fields['noAck'] = val;
    val = !!(buffer[offset] & 4);
    fields['exclusive'] = val;
    val = !!(buffer[offset] & 8);
    fields['nowait'] = val;
    offset++;
    len = buffer.readUInt32BE(offset); offset += 4;
    val = decodeFields(buffer.slice(offset, offset + len));
    offset += len;
    fields['arguments'] = val;
    return fields;
}

function encodeBasicConsume(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932180, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['consumerTag'] === undefined)
        throw new Error("Missing value for consumerTag");
    val = fields['consumerTag'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['noLocal'] === undefined)
        throw new Error("Missing value for noLocal");
    val = fields['noLocal'];
    if (val) bits += 1;
    if (fields['noAck'] === undefined)
        throw new Error("Missing value for noAck");
    val = fields['noAck'];
    if (val) bits += 2;
    if (fields['exclusive'] === undefined)
        throw new Error("Missing value for exclusive");
    val = fields['exclusive'];
    if (val) bits += 4;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 8;
    val = fields['arguments']; val = (val === undefined) ? {} : val;
    buffer[offset] = bits; offset++; bits = 0;
    offset += encodeTable(buffer, val, offset);
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicConsume = methodInfoBasicConsume = {
  "id": 3932180,
  "name": "BasicConsume",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "queue",
      "default": ""
    },
    {
      "type": "shortstr",
      "name": "consumerTag",
      "default": ""
    },
    {
      "type": "bit",
      "name": "noLocal",
      "default": false
    },
    {
      "type": "bit",
      "name": "noAck",
      "default": false
    },
    {
      "type": "bit",
      "name": "exclusive",
      "default": false
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    },
    {
      "type": "table",
      "name": "arguments",
      "default": {}
    }
  ]
}

module.exports.BasicConsumeOk = 3932181;

function decodeBasicConsumeOk(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932181, 7);
    offset = 11;
    if (fields['consumerTag'] === undefined)
        throw new Error("Missing value for consumerTag");
    val = fields['consumerTag'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicConsumeOk = methodInfoBasicConsumeOk = {
  "id": 3932181,
  "name": "BasicConsumeOk",
  "args": [
    {
      "type": "shortstr",
      "name": "consumerTag"
    }
  ]
}

module.exports.BasicCancel = 3932190;

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

function encodeBasicCancel(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932190, 7);
    offset = 11;
    if (fields['consumerTag'] === undefined)
        throw new Error("Missing value for consumerTag");
    val = fields['consumerTag'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicCancel = methodInfoBasicCancel = {
  "id": 3932190,
  "name": "BasicCancel",
  "args": [
    {
      "type": "shortstr",
      "name": "consumerTag"
    },
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    }
  ]
}

module.exports.BasicCancelOk = 3932191;

function decodeBasicCancelOk(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932191, 7);
    offset = 11;
    if (fields['consumerTag'] === undefined)
        throw new Error("Missing value for consumerTag");
    val = fields['consumerTag'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicCancelOk = methodInfoBasicCancelOk = {
  "id": 3932191,
  "name": "BasicCancelOk",
  "args": [
    {
      "type": "shortstr",
      "name": "consumerTag"
    }
  ]
}

module.exports.BasicPublish = 3932200;

function decodeBasicPublish(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['mandatory'] = val;
    val = !!(buffer[offset] & 2);
    fields['immediate'] = val;
    return fields;
}

function encodeBasicPublish(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932200, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['mandatory'] === undefined)
        throw new Error("Missing value for mandatory");
    val = fields['mandatory'];
    if (val) bits += 1;
    if (fields['immediate'] === undefined)
        throw new Error("Missing value for immediate");
    val = fields['immediate'];
    if (val) bits += 2;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicPublish = methodInfoBasicPublish = {
  "id": 3932200,
  "name": "BasicPublish",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "exchange",
      "default": ""
    },
    {
      "type": "shortstr",
      "name": "routingKey",
      "default": ""
    },
    {
      "type": "bit",
      "name": "mandatory",
      "default": false
    },
    {
      "type": "bit",
      "name": "immediate",
      "default": false
    }
  ]
}

module.exports.BasicReturn = 3932210;

function decodeBasicReturn(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932210, 7);
    offset = 11;
    if (fields['replyCode'] === undefined)
        throw new Error("Missing value for replyCode");
    val = fields['replyCode'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['replyText'] === undefined)
        throw new Error("Missing value for replyText");
    val = fields['replyText'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicReturn = methodInfoBasicReturn = {
  "id": 3932210,
  "name": "BasicReturn",
  "args": [
    {
      "type": "short",
      "name": "replyCode"
    },
    {
      "type": "shortstr",
      "name": "replyText",
      "default": ""
    },
    {
      "type": "shortstr",
      "name": "exchange"
    },
    {
      "type": "shortstr",
      "name": "routingKey"
    }
  ]
}

module.exports.BasicDeliver = 3932220;

function decodeBasicDeliver(buffer) {
    var fields = {}, offset = 0, val, len;
    len = buffer.readUInt8(offset); offset++;
    val = buffer.toString("utf8", offset, offset + len);
    offset += len;
    fields['consumerTag'] = val;
    val = buffer.readUInt64BE(offset); offset += 8;
    fields['deliveryTag'] = val;
    val = !!(buffer[offset] & 1);
    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, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932220, 7);
    offset = 11;
    if (fields['consumerTag'] === undefined)
        throw new Error("Missing value for consumerTag");
    val = fields['consumerTag'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['deliveryTag'] === undefined)
        throw new Error("Missing value for deliveryTag");
    val = fields['deliveryTag'];
    buffer.writeUInt64BE(val, offset); offset += 8;
    if (fields['redelivered'] === undefined)
        throw new Error("Missing value for redelivered");
    val = fields['redelivered'];
    if (val) bits += 1;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    buffer[offset] = bits; offset++; bits = 0;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicDeliver = methodInfoBasicDeliver = {
  "id": 3932220,
  "name": "BasicDeliver",
  "args": [
    {
      "type": "shortstr",
      "name": "consumerTag"
    },
    {
      "type": "longlong",
      "name": "deliveryTag"
    },
    {
      "type": "bit",
      "name": "redelivered",
      "default": false
    },
    {
      "type": "shortstr",
      "name": "exchange"
    },
    {
      "type": "shortstr",
      "name": "routingKey"
    }
  ]
}

module.exports.BasicGet = 3932230;

function decodeBasicGet(buffer) {
    var fields = {}, offset = 0, val, len;
    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 = !!(buffer[offset] & 1);
    fields['noAck'] = val;
    return fields;
}

function encodeBasicGet(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932230, 7);
    offset = 11;
    if (fields['ticket'] === undefined)
        throw new Error("Missing value for ticket");
    val = fields['ticket'];
    buffer.writeUInt16BE(val, offset); offset += 2;
    if (fields['queue'] === undefined)
        throw new Error("Missing value for queue");
    val = fields['queue'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['noAck'] === undefined)
        throw new Error("Missing value for noAck");
    val = fields['noAck'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicGet = methodInfoBasicGet = {
  "id": 3932230,
  "name": "BasicGet",
  "args": [
    {
      "type": "short",
      "name": "ticket",
      "default": 0
    },
    {
      "type": "shortstr",
      "name": "queue",
      "default": ""
    },
    {
      "type": "bit",
      "name": "noAck",
      "default": false
    }
  ]
}

module.exports.BasicGetOk = 3932231;

function decodeBasicGetOk(buffer) {
    var fields = {}, offset = 0, val, len;
    val = buffer.readUInt64BE(offset); offset += 8;
    fields['deliveryTag'] = val;
    val = !!(buffer[offset] & 1);
    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, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932231, 7);
    offset = 11;
    if (fields['deliveryTag'] === undefined)
        throw new Error("Missing value for deliveryTag");
    val = fields['deliveryTag'];
    buffer.writeUInt64BE(val, offset); offset += 8;
    if (fields['redelivered'] === undefined)
        throw new Error("Missing value for redelivered");
    val = fields['redelivered'];
    if (val) bits += 1;
    if (fields['exchange'] === undefined)
        throw new Error("Missing value for exchange");
    val = fields['exchange'];
    buffer[offset] = bits; offset++; bits = 0;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['routingKey'] === undefined)
        throw new Error("Missing value for routingKey");
    val = fields['routingKey'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    if (fields['messageCount'] === undefined)
        throw new Error("Missing value for messageCount");
    val = fields['messageCount'];
    buffer.writeUInt32BE(val, offset); offset += 4;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicGetOk = methodInfoBasicGetOk = {
  "id": 3932231,
  "name": "BasicGetOk",
  "args": [
    {
      "type": "longlong",
      "name": "deliveryTag"
    },
    {
      "type": "bit",
      "name": "redelivered",
      "default": false
    },
    {
      "type": "shortstr",
      "name": "exchange"
    },
    {
      "type": "shortstr",
      "name": "routingKey"
    },
    {
      "type": "long",
      "name": "messageCount"
    }
  ]
}

module.exports.BasicGetEmpty = 3932232;

function decodeBasicGetEmpty(buffer) {
    var fields = {}, offset = 0, val, len;
    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, bits = 0, len;
    var buffer = new Buffer(2048);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932232, 7);
    offset = 11;
    if (fields['clusterId'] === undefined)
        throw new Error("Missing value for clusterId");
    val = fields['clusterId'];
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer.slice(0, offset + 1);
}

module.exports.methodInfoBasicGetEmpty = methodInfoBasicGetEmpty = {
  "id": 3932232,
  "name": "BasicGetEmpty",
  "args": [
    {
      "type": "shortstr",
      "name": "clusterId",
      "default": ""
    }
  ]
}

module.exports.BasicAck = 3932240;

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

function encodeBasicAck(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(21);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932240, 7);
    offset = 11;
    if (fields['deliveryTag'] === undefined)
        throw new Error("Missing value for deliveryTag");
    val = fields['deliveryTag'];
    buffer.writeUInt64BE(val, offset); offset += 8;
    if (fields['multiple'] === undefined)
        throw new Error("Missing value for multiple");
    val = fields['multiple'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicAck = methodInfoBasicAck = {
  "id": 3932240,
  "name": "BasicAck",
  "args": [
    {
      "type": "longlong",
      "name": "deliveryTag",
      "default": 0
    },
    {
      "type": "bit",
      "name": "multiple",
      "default": false
    }
  ]
}

module.exports.BasicReject = 3932250;

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

function encodeBasicReject(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(21);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932250, 7);
    offset = 11;
    if (fields['deliveryTag'] === undefined)
        throw new Error("Missing value for deliveryTag");
    val = fields['deliveryTag'];
    buffer.writeUInt64BE(val, offset); offset += 8;
    val = fields['requeue']; val = (val === undefined) ? true : val;
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicReject = methodInfoBasicReject = {
  "id": 3932250,
  "name": "BasicReject",
  "args": [
    {
      "type": "longlong",
      "name": "deliveryTag"
    },
    {
      "type": "bit",
      "name": "requeue",
      "default": true
    }
  ]
}

module.exports.BasicRecoverAsync = 3932260;

function decodeBasicRecoverAsync(buffer) {
    var fields = {}, offset = 0, val, len;
    val = !!(buffer[offset] & 1);
    fields['requeue'] = val;
    return fields;
}

function encodeBasicRecoverAsync(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(13);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932260, 7);
    offset = 11;
    if (fields['requeue'] === undefined)
        throw new Error("Missing value for requeue");
    val = fields['requeue'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicRecoverAsync = methodInfoBasicRecoverAsync = {
  "id": 3932260,
  "name": "BasicRecoverAsync",
  "args": [
    {
      "type": "bit",
      "name": "requeue",
      "default": false
    }
  ]
}

module.exports.BasicRecover = 3932270;

function decodeBasicRecover(buffer) {
    var fields = {}, offset = 0, val, len;
    val = !!(buffer[offset] & 1);
    fields['requeue'] = val;
    return fields;
}

function encodeBasicRecover(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(13);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932270, 7);
    offset = 11;
    if (fields['requeue'] === undefined)
        throw new Error("Missing value for requeue");
    val = fields['requeue'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicRecover = methodInfoBasicRecover = {
  "id": 3932270,
  "name": "BasicRecover",
  "args": [
    {
      "type": "bit",
      "name": "requeue",
      "default": false
    }
  ]
}

module.exports.BasicRecoverOk = 3932271;

function decodeBasicRecoverOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoBasicRecoverOk = methodInfoBasicRecoverOk = {
  "id": 3932271,
  "name": "BasicRecoverOk",
  "args": []
}

module.exports.BasicNack = 3932280;

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

function encodeBasicNack(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(21);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932280, 7);
    offset = 11;
    if (fields['deliveryTag'] === undefined)
        throw new Error("Missing value for deliveryTag");
    val = fields['deliveryTag'];
    buffer.writeUInt64BE(val, offset); offset += 8;
    if (fields['multiple'] === undefined)
        throw new Error("Missing value for multiple");
    val = fields['multiple'];
    if (val) bits += 1;
    val = fields['requeue']; val = (val === undefined) ? true : val;
    if (val) bits += 2;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoBasicNack = methodInfoBasicNack = {
  "id": 3932280,
  "name": "BasicNack",
  "args": [
    {
      "type": "longlong",
      "name": "deliveryTag",
      "default": 0
    },
    {
      "type": "bit",
      "name": "multiple",
      "default": false
    },
    {
      "type": "bit",
      "name": "requeue",
      "default": true
    }
  ]
}

module.exports.TxSelect = 5898250;

function decodeTxSelect(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxSelect = methodInfoTxSelect = {
  "id": 5898250,
  "name": "TxSelect",
  "args": []
}

module.exports.TxSelectOk = 5898251;

function decodeTxSelectOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxSelectOk = methodInfoTxSelectOk = {
  "id": 5898251,
  "name": "TxSelectOk",
  "args": []
}

module.exports.TxCommit = 5898260;

function decodeTxCommit(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxCommit = methodInfoTxCommit = {
  "id": 5898260,
  "name": "TxCommit",
  "args": []
}

module.exports.TxCommitOk = 5898261;

function decodeTxCommitOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxCommitOk = methodInfoTxCommitOk = {
  "id": 5898261,
  "name": "TxCommitOk",
  "args": []
}

module.exports.TxRollback = 5898270;

function decodeTxRollback(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxRollback = methodInfoTxRollback = {
  "id": 5898270,
  "name": "TxRollback",
  "args": []
}

module.exports.TxRollbackOk = 5898271;

function decodeTxRollbackOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoTxRollbackOk = methodInfoTxRollbackOk = {
  "id": 5898271,
  "name": "TxRollbackOk",
  "args": []
}

module.exports.ConfirmSelect = 5570570;

function decodeConfirmSelect(buffer) {
    var fields = {}, offset = 0, val, len;
    val = !!(buffer[offset] & 1);
    fields['nowait'] = val;
    return fields;
}

function encodeConfirmSelect(channel, fields) {
    var offset = 0, val = null, bits = 0, len;
    var buffer = new Buffer(13);
    buffer[0] = 1;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(5570570, 7);
    offset = 11;
    if (fields['nowait'] === undefined)
        throw new Error("Missing value for nowait");
    val = fields['nowait'];
    if (val) bits += 1;
    buffer[offset] = bits; offset++;
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    return buffer;
}

module.exports.methodInfoConfirmSelect = methodInfoConfirmSelect = {
  "id": 5570570,
  "name": "ConfirmSelect",
  "args": [
    {
      "type": "bit",
      "name": "nowait",
      "default": false
    }
  ]
}

module.exports.ConfirmSelectOk = 5570571;

function decodeConfirmSelectOk(buffer) {
    var fields = {}, offset = 0, val, len;
    return fields;
}

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

module.exports.methodInfoConfirmSelectOk = methodInfoConfirmSelectOk = {
  "id": 5570571,
  "name": "ConfirmSelectOk",
  "args": []
}

module.exports.BasicProperties = 60;
function encodeBasicProperties(channel, size, fields) {
    var offset = 0, flags = 0, val, len;
    var buffer = new Buffer(2048);
    buffer[0] = 2;
    buffer.writeUInt16BE(channel, 1);
    buffer.writeUInt32BE(3932160, 7);
    buffer.writeUInt64BE(size, 11);
    flags = 0;
    offset = 21;
    if (fields['contentType'] !== undefined) {
        val = fields['contentType'];
    flags += 32768;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['contentEncoding'] !== undefined) {
        val = fields['contentEncoding'];
    flags += 16384;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['headers'] !== undefined) {
        val = fields['headers'];
    flags += 8192;
    offset += encodeTable(buffer, val, offset);
    }
    if (fields['deliveryMode'] !== undefined) {
        val = fields['deliveryMode'];
    flags += 4096;
    buffer.writeUInt8(val, offset); offset++;
    }
    if (fields['priority'] !== undefined) {
        val = fields['priority'];
    flags += 2048;
    buffer.writeUInt8(val, offset); offset++;
    }
    if (fields['correlationId'] !== undefined) {
        val = fields['correlationId'];
    flags += 1024;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['replyTo'] !== undefined) {
        val = fields['replyTo'];
    flags += 512;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['expiration'] !== undefined) {
        val = fields['expiration'];
    flags += 256;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['messageId'] !== undefined) {
        val = fields['messageId'];
    flags += 128;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['timestamp'] !== undefined) {
        val = fields['timestamp'];
    flags += 64;
    buffer.writeUInt64BE(val, offset); offset += 8;
    }
    if (fields['type'] !== undefined) {
        val = fields['type'];
    flags += 32;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['userId'] !== undefined) {
        val = fields['userId'];
    flags += 16;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['appId'] !== undefined) {
        val = fields['appId'];
    flags += 8;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    if (fields['clusterId'] !== undefined) {
        val = fields['clusterId'];
    flags += 4;
    len = Buffer.byteLength(val, "utf8");
    buffer[offset] = len; offset++;
    buffer.write(val, offset, "utf8"); offset += len;
    }
    buffer[offset] = 206; 
    buffer.writeUInt32BE(offset - 7, 3);
    buffer.writeUInt16BE(flags, 19);
    return buffer.slice(0, offset + 1);
}

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

module.exports.propertiesInfoBasicProperties = 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"
    }
  ]
}