From ea94541eb51ee06fab60267ee53f13702ff33a6f Mon Sep 17 00:00:00 2001 From: Stephen Cresswell <229672+cressie176@users.noreply.github.com> Date: Thu, 11 Apr 2024 21:02:25 +0100 Subject: [PATCH 1/2] Commit defs --- .gitignore | 2 - .npmignore | 1 - Makefile | 35 +- bin/amqp-rabbitmq-0.9.1.json | 483 ++++ lib/defs.js | 5077 ++++++++++++++++++++++++++++++++++ 5 files changed, 5579 insertions(+), 19 deletions(-) create mode 100644 bin/amqp-rabbitmq-0.9.1.json create mode 100644 lib/defs.js diff --git a/.gitignore b/.gitignore index 266a9a78..d1964000 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,6 @@ *~ -lib/defs.js scratch node_modules/ -bin/amqp-rabbitmq-0.9.1.json etc/ coverage/ /.idea/ diff --git a/.npmignore b/.npmignore index 4ec93971..1db5f675 100644 --- a/.npmignore +++ b/.npmignore @@ -3,6 +3,5 @@ scratch # do not ignore lib/defs.js, we need that # node_modules is ignored anyway .travis.yml -bin/amqp-rabbitmq-0.9.1.json etc/ coverage/ diff --git a/Makefile b/Makefile index a3d87428..41f212f8 100644 --- a/Makefile +++ b/Makefile @@ -9,33 +9,36 @@ _MOCHA=./node_modules/.bin/_mocha UGLIFY=./node_modules/.bin/uglifyjs NYC=./node_modules/.bin/nyc -.PHONY: test test-all-nodejs all clean coverage +.PHONY: test test-all-nodejs coverage lib/defs.js -all: lib/defs.js +error: + @echo "Please choose one of the following targets: test, test-all-nodejs, coverage, lib/defs.js" + @exit 1 -clean: - rm lib/defs.js bin/amqp-rabbitmq-0.9.1.json - rm -rf ./coverage - -lib/defs.js: $(UGLIFY) bin/generate-defs.js bin/amqp-rabbitmq-0.9.1.json - (cd bin; node ./generate-defs.js > ../lib/defs.js) - $(UGLIFY) ./lib/defs.js -o ./lib/defs.js \ - -c 'sequences=false' --comments \ - -b 'indent-level=2' 2>&1 | (grep -v 'WARN' || true) - -test: lib/defs.js +test: $(MOCHA) --check-leaks -u tdd --exit test/ -test-all-nodejs: lib/defs.js +test-all-nodejs: for v in $(NODEJS_VERSIONS); \ do echo "-- Node version $$v --"; \ nave use $$v $(MOCHA) -u tdd --exit -R progress test; \ done -coverage: $(NYC) lib/defs.js - $(NYC) --reporter=lcov --reporter=text $(_MOCHA) -u tdd -R progress test/ +coverage: $(NYC) + $(NYC) --clean --reporter=lcov --reporter=text $(_MOCHA) -u tdd --exit -R progress test/ @echo "HTML report at file://$$(pwd)/coverage/lcov-report/index.html" +lib/defs.js: clean bin/generate-defs test + +clean: + rm -f lib/defs.js bin/amqp-rabbitmq-0.9.1.json + +bin/generate-defs: $(UGLIFY) bin/generate-defs.js bin/amqp-rabbitmq-0.9.1.json + (cd bin; node ./generate-defs.js > ../lib/defs.js) + $(UGLIFY) ./lib/defs.js -o ./lib/defs.js \ + -c 'sequences=false' --comments \ + -b 'indent-level=2' 2>&1 | (grep -v 'WARN' || true) + bin/amqp-rabbitmq-0.9.1.json: curl -L $(AMQP_JSON) > $@ diff --git a/bin/amqp-rabbitmq-0.9.1.json b/bin/amqp-rabbitmq-0.9.1.json new file mode 100644 index 00000000..43f3cf64 --- /dev/null +++ b/bin/amqp-rabbitmq-0.9.1.json @@ -0,0 +1,483 @@ +{ + "name": "AMQP", + "major-version": 0, + "minor-version": 9, + "revision": 1, + "port": 5672, + "copyright": [ + "Copyright (C) 2008-2020 VMware, Inc. or its affiliates.\n", + "\n", + "Permission is hereby granted, free of charge, to any person\n", + "obtaining a copy of this file (the \"Software\"), to deal in the\n", + "Software without restriction, including without limitation the \n", + "rights to use, copy, modify, merge, publish, distribute, \n", + "sublicense, and/or sell copies of the Software, and to permit \n", + "persons to whom the Software is furnished to do so, subject to \n", + "the following conditions:\n", + "\n", + "The above copyright notice and this permission notice shall be\n", + "included in all copies or substantial portions of the Software.\n", + "\n", + "THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n", + "EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n", + "OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n", + "NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n", + "HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n", + "WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n", + "FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n", + "OTHER DEALINGS IN THE SOFTWARE.\n", + "\n", + "Class information entered from amqp_xml0-8.pdf and domain types from amqp-xml-doc0-9.pdf\n", + "Updated for 0-9-1 by Tony Garnock-Jones\n", + "\n", + "b3cb053f15e7b98808c0ccc67f23cb3e amqp_xml0-8.pdf\n", + "http://twiststandards.org/?option=com_docman&task=cat_view&gid=28&Itemid=90\n", + "8444db91e2949dbecfb2585e9eef6d64 amqp-xml-doc0-9.pdf\n", + "https://jira.amqp.org/confluence/download/attachments/720900/amqp-xml-doc0-9.pdf?version=1\n"], + + "domains": [ + ["bit", "bit"], + ["channel-id", "longstr"], + ["class-id", "short"], + ["consumer-tag", "shortstr"], + ["delivery-tag", "longlong"], + ["destination", "shortstr"], + ["duration", "longlong"], + ["exchange-name", "shortstr"], + ["long", "long"], + ["longlong", "longlong"], + ["longstr", "longstr"], + ["message-count", "long"], + ["method-id", "short"], + ["no-ack", "bit"], + ["no-local", "bit"], + ["octet", "octet"], + ["offset", "longlong"], + ["path", "shortstr"], + ["peer-properties", "table"], + ["queue-name", "shortstr"], + ["redelivered", "bit"], + ["reference", "longstr"], + ["reject-code", "short"], + ["reject-text", "shortstr"], + ["reply-code", "short"], + ["reply-text", "shortstr"], + ["security-token", "longstr"], + ["short", "short"], + ["shortstr", "shortstr"], + ["table", "table"], + ["timestamp", "timestamp"] + ], + + "constants": [ + {"name": "FRAME-METHOD", "value": 1}, + {"name": "FRAME-HEADER", "value": 2}, + {"name": "FRAME-BODY", "value": 3}, + {"name": "FRAME-HEARTBEAT", "value": 8}, + {"name": "FRAME-MIN-SIZE", "value": 4096}, + {"name": "FRAME-END", "value": 206}, + {"name": "REPLY-SUCCESS", "value": 200}, + {"name": "CONTENT-TOO-LARGE", "value": 311, "class": "soft-error"}, + {"name": "NO-ROUTE", "value": 312, "class": "soft-error"}, + {"name": "NO-CONSUMERS", "value": 313, "class": "soft-error"}, + {"name": "ACCESS-REFUSED", "value": 403, "class": "soft-error"}, + {"name": "NOT-FOUND", "value": 404, "class": "soft-error"}, + {"name": "RESOURCE-LOCKED", "value": 405, "class": "soft-error"}, + {"name": "PRECONDITION-FAILED", "value": 406, "class": "soft-error"}, + {"name": "CONNECTION-FORCED", "value": 320, "class": "hard-error"}, + {"name": "INVALID-PATH", "value": 402, "class": "hard-error"}, + {"name": "FRAME-ERROR", "value": 501, "class": "hard-error"}, + {"name": "SYNTAX-ERROR", "value": 502, "class": "hard-error"}, + {"name": "COMMAND-INVALID", "value": 503, "class": "hard-error"}, + {"name": "CHANNEL-ERROR", "value": 504, "class": "hard-error"}, + {"name": "UNEXPECTED-FRAME", "value": 505, "class": "hard-error"}, + {"name": "RESOURCE-ERROR", "value": 506, "class": "hard-error"}, + {"name": "NOT-ALLOWED", "value": 530, "class": "hard-error"}, + {"name": "NOT-IMPLEMENTED", "value": 540, "class": "hard-error"}, + {"name": "INTERNAL-ERROR", "value": 541, "class": "hard-error"} + ], + + "classes": [ + { + "id": 60, + "methods": [{"id": 10, + "arguments": [{"type": "long", "name": "prefetch-size", "default-value": 0}, + {"type": "short", "name": "prefetch-count", "default-value": 0}, + {"type": "bit", "name": "global", "default-value": false}], + "name": "qos", + "synchronous" : true}, + {"id": 11, + "arguments": [], + "name": "qos-ok"}, + {"id": 20, + "arguments": [{"domain": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"type": "shortstr", "name": "consumer-tag", "default-value": ""}, + {"type": "bit", "name": "no-local", "default-value": false}, + {"type": "bit", "name": "no-ack", "default-value": false}, + {"type": "bit", "name": "exclusive", "default-value": false}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "consume", + "synchronous" : true}, + {"id": 21, + "arguments": [{"type": "shortstr", "name": "consumer-tag"}], + "name": "consume-ok"}, + {"id": 30, + "arguments": [{"type": "shortstr", "name": "consumer-tag"}, + {"type": "bit", "name": "nowait", "default-value": false}], + "name": "cancel", + "synchronous" : true}, + {"id": 31, + "arguments": [{"type": "shortstr", "name": "consumer-tag"}], + "name": "cancel-ok"}, + {"content": true, + "id": 40, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "exchange-name", "name": "exchange", "default-value": ""}, + {"type": "shortstr", "name": "routing-key", "default-value": ""}, + {"type": "bit", "name": "mandatory", "default-value": false}, + {"type": "bit", "name": "immediate", "default-value": false}], + "name": "publish"}, + {"content": true, + "id": 50, + "arguments": [{"type": "short", "name": "reply-code"}, + {"type": "shortstr", "name": "reply-text", "default-value": ""}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "routing-key"}], + "name": "return"}, + {"content": true, + "id": 60, + "arguments": [{"type": "shortstr", "name": "consumer-tag"}, + {"type": "longlong", "name": "delivery-tag"}, + {"type": "bit", "name": "redelivered", "default-value": false}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "routing-key"}], + "name": "deliver"}, + {"id": 70, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"type": "bit", "name": "no-ack", "default-value": false}], + "name": "get", + "synchronous" : true}, + {"content": true, + "id": 71, + "arguments": [{"type": "longlong", "name": "delivery-tag"}, + {"type": "bit", "name": "redelivered", "default-value": false}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "routing-key"}, + {"domain": "message-count", "name": "message-count"}], + "name": "get-ok"}, + {"id": 72, + "arguments": [{"type": "shortstr", "name": "cluster-id", "default-value": ""}], + "name": "get-empty"}, + {"id": 80, + "arguments": [{"type": "longlong", "name": "delivery-tag", "default-value": 0}, + {"type": "bit", "name": "multiple", "default-value": false}], + "name": "ack"}, + {"id": 90, + "arguments": [{"type": "longlong", "name": "delivery-tag"}, + {"type": "bit", "name": "requeue", "default-value": true}], + "name": "reject"}, + {"id": 100, + "arguments": [{"type": "bit", "name": "requeue", "default-value": false}], + "name": "recover-async"}, + {"id": 110, + "arguments": [{"type": "bit", "name": "requeue", "default-value": false}], + "name": "recover", + "synchronous" : true}, + {"id": 111, + "arguments": [], + "name": "recover-ok"}, + {"id": 120, + "arguments": [{"type": "longlong", "name": "delivery-tag", "default-value": 0}, + {"type": "bit", "name": "multiple", "default-value": false}, + {"type": "bit", "name": "requeue", "default-value": true}], + "name": "nack"}], + "name": "basic", + "properties": [{"type": "shortstr", "name": "content-type"}, + {"type": "shortstr", "name": "content-encoding"}, + {"type": "table", "name": "headers"}, + {"type": "octet", "name": "delivery-mode"}, + {"type": "octet", "name": "priority"}, + {"type": "shortstr", "name": "correlation-id"}, + {"type": "shortstr", "name": "reply-to"}, + {"type": "shortstr", "name": "expiration"}, + {"type": "shortstr", "name": "message-id"}, + {"type": "timestamp", "name": "timestamp"}, + {"type": "shortstr", "name": "type"}, + {"type": "shortstr", "name": "user-id"}, + {"type": "shortstr", "name": "app-id"}, + {"type": "shortstr", "name": "cluster-id"}] + }, + { + "id": 10, + "methods": [{"id": 10, + "arguments": [{"type": "octet", "name": "version-major", "default-value": 0}, + {"type": "octet", "name": "version-minor", "default-value": 9}, + {"domain": "peer-properties", "name": "server-properties"}, + {"type": "longstr", "name": "mechanisms", "default-value": "PLAIN"}, + {"type": "longstr", "name": "locales", "default-value": "en_US"}], + "name": "start", + "synchronous" : true}, + {"id": 11, + "arguments": [{"domain": "peer-properties", "name": "client-properties"}, + {"type": "shortstr", "name": "mechanism", "default-value": "PLAIN"}, + {"type": "longstr", "name": "response"}, + {"type": "shortstr", "name": "locale", "default-value": "en_US"}], + "name": "start-ok"}, + {"id": 20, + "arguments": [{"type": "longstr", "name": "challenge"}], + "name": "secure", + "synchronous" : true}, + {"id": 21, + "arguments": [{"type": "longstr", "name": "response"}], + "name": "secure-ok"}, + {"id": 30, + "arguments": [{"type": "short", "name": "channel-max", "default-value": 0}, + {"type": "long", "name": "frame-max", "default-value": 0}, + {"type": "short", "name": "heartbeat", "default-value": 0}], + "name": "tune", + "synchronous" : true}, + {"id": 31, + "arguments": [{"type": "short", "name": "channel-max", "default-value": 0}, + {"type": "long", "name": "frame-max", "default-value": 0}, + {"type": "short", "name": "heartbeat", "default-value": 0}], + "name": "tune-ok"}, + {"id": 40, + "arguments": [{"type": "shortstr", "name": "virtual-host", "default-value": "/"}, + {"type": "shortstr", "name": "capabilities", "default-value": ""}, + {"type": "bit", "name": "insist", "default-value": false}], + "name": "open", + "synchronous" : true}, + {"id": 41, + "arguments": [{"type": "shortstr", "name": "known-hosts", "default-value": ""}], + "name": "open-ok"}, + {"id": 50, + "arguments": [{"type": "short", "name": "reply-code"}, + {"type": "shortstr", "name": "reply-text", "default-value": ""}, + {"type": "short", "name": "class-id"}, + {"type": "short", "name": "method-id"}], + "name": "close", + "synchronous" : true}, + {"id": 51, + "arguments": [], + "name": "close-ok"}, + {"id": 60, + "arguments": [{"type": "shortstr", "name": "reason", "default-value": ""}], + "name": "blocked"}, + {"id": 61, + "arguments": [], + "name": "unblocked"}, + {"id": 70, + "arguments": [{"type": "longstr", "name": "new-secret"}, + {"type": "shortstr", "name": "reason"}], + "name": "update-secret", + "synchronous" : true}, + {"id": 71, + "arguments": [], + "name": "update-secret-ok"} + ], + "name": "connection", + "properties": [] + }, + { + "id": 20, + "methods": [{"id": 10, + "arguments": [{"type": "shortstr", "name": "out-of-band", "default-value": ""}], + "name": "open", + "synchronous" : true}, + {"id": 11, + "arguments": [{"type": "longstr", "name": "channel-id", "default-value": ""}], + "name": "open-ok"}, + {"id": 20, + "arguments": [{"type": "bit", "name": "active"}], + "name": "flow", + "synchronous" : true}, + {"id": 21, + "arguments": [{"type": "bit", "name": "active"}], + "name": "flow-ok"}, + {"id": 40, + "arguments": [{"type": "short", "name": "reply-code"}, + {"type": "shortstr", "name": "reply-text", "default-value": ""}, + {"type": "short", "name": "class-id"}, + {"type": "short", "name": "method-id"}], + "name": "close", + "synchronous" : true}, + {"id": 41, + "arguments": [], + "name": "close-ok"}], + "name": "channel" + }, + { + "id": 30, + "methods": [{"id": 10, + "arguments": [{"type": "shortstr", "name": "realm", "default-value": "/data"}, + {"type": "bit", "name": "exclusive", "default-value": false}, + {"type": "bit", "name": "passive", "default-value": true}, + {"type": "bit", "name": "active", "default-value": true}, + {"type": "bit", "name": "write", "default-value": true}, + {"type": "bit", "name": "read", "default-value": true}], + "name": "request", + "synchronous" : true}, + {"id": 11, + "arguments": [{"type": "short", "name": "ticket", "default-value": 1}], + "name": "request-ok"}], + "name": "access" + }, + { + "id": 40, + "methods": [{"id": 10, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "type", "default-value": "direct"}, + {"type": "bit", "name": "passive", "default-value": false}, + {"type": "bit", "name": "durable", "default-value": false}, + {"type": "bit", "name": "auto-delete", "default-value": false}, + {"type": "bit", "name": "internal", "default-value": false}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "declare", + "synchronous" : true}, + {"id": 11, + "arguments": [], + "name": "declare-ok"}, + {"id": 20, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "bit", "name": "if-unused", "default-value": false}, + {"type": "bit", "name": "nowait", "default-value": false}], + "name": "delete", + "synchronous" : true}, + {"id": 21, + "arguments": [], + "name": "delete-ok"}, + {"id": 30, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "exchange-name", "name": "destination"}, + {"domain": "exchange-name", "name": "source"}, + {"type": "shortstr", "name": "routing-key", "default-value": ""}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "bind", + "synchronous" : true}, + {"id": 31, + "arguments": [], + "name": "bind-ok"}, + {"id": 40, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "exchange-name", "name": "destination"}, + {"domain": "exchange-name", "name": "source"}, + {"type": "shortstr", "name": "routing-key", "default-value": ""}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "unbind", + "synchronous" : true}, + {"id": 51, + "arguments": [], + "name": "unbind-ok"}], + "name": "exchange" + }, + { + "id": 50, + "methods": [{"id": 10, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"type": "bit", "name": "passive", "default-value": false}, + {"type": "bit", "name": "durable", "default-value": false}, + {"type": "bit", "name": "exclusive", "default-value": false}, + {"type": "bit", "name": "auto-delete", "default-value": false}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "declare", + "synchronous" : true}, + {"id": 11, + "arguments": [{"domain": "queue-name", "name": "queue"}, + {"domain": "message-count", "name": "message-count"}, + {"type": "long", "name": "consumer-count"}], + "name": "declare-ok"}, + {"id": 20, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "routing-key", "default-value": ""}, + {"type": "bit", "name": "nowait", "default-value": false}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "bind", + "synchronous" : true}, + {"id": 21, + "arguments": [], + "name": "bind-ok"}, + {"id": 30, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"type": "bit", "name": "nowait", "default-value": false}], + "name": "purge", + "synchronous" : true}, + {"id": 31, + "arguments": [{"domain": "message-count", "name": "message-count"}], + "name": "purge-ok"}, + {"id": 40, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"type": "bit", "name": "if-unused", "default-value": false}, + {"type": "bit", "name": "if-empty", "default-value": false}, + {"type": "bit", "name": "nowait", "default-value": false}], + "name": "delete", + "synchronous" : true}, + {"id": 41, + "arguments": [{"domain": "message-count", "name": "message-count"}], + "name": "delete-ok"}, + {"id": 50, + "arguments": [{"type": "short", "name": "ticket", "default-value": 0}, + {"domain": "queue-name", "name": "queue", "default-value": ""}, + {"domain": "exchange-name", "name": "exchange"}, + {"type": "shortstr", "name": "routing-key", "default-value": ""}, + {"type": "table", "name": "arguments", "default-value": {}}], + "name": "unbind", + "synchronous" : true}, + {"id": 51, + "arguments": [], + "name": "unbind-ok"} + ], + "name": "queue" + }, + { + "id": 90, + "methods": [{"id": 10, + "arguments": [], + "name": "select", + "synchronous" : true}, + {"id": 11, + "arguments": [], + "name": "select-ok"}, + {"id": 20, + "arguments": [], + "name": "commit", + "synchronous" : true}, + {"id": 21, + "arguments": [], + "name": "commit-ok"}, + {"id": 30, + "arguments": [], + "name": "rollback", + "synchronous" : true}, + {"id": 31, + "arguments": [], + "name": "rollback-ok"}], + "name": "tx" + }, + { + "id": 85, + "methods": [{"id": 10, + "arguments": [ + {"type": "bit", "name": "nowait", "default-value": false}], + "name": "select", + "synchronous": true}, + {"id": 11, + "arguments": [], + "name": "select-ok"}], + "name": "confirm" + } + ] +} diff --git a/lib/defs.js b/lib/defs.js new file mode 100644 index 00000000..6b3102dc --- /dev/null +++ b/lib/defs.js @@ -0,0 +1,5077 @@ +/** @preserve This file is generated by the script + * ../bin/generate-defs.js, which is not in general included in a + * distribution, but is available in the source repository e.g. at + * https://github.com/squaremo/amqp.node/ + */ +"use strict"; + +function decodeBasicQos(buffer) { + var val, offset = 0, fields = { + prefetchSize: void 0, + prefetchCount: void 0, + global: void 0 + }; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.prefetchSize = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.prefetchCount = val; + val = !!(1 & buffer[offset]); + fields.global = val; + return fields; +} + +function encodeBasicQos(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(19); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932170, 7); + offset = 11; + val = fields.prefetchSize; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'prefetchSize' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + val = fields.prefetchCount; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'prefetchCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.global; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicQosOk(buffer) { + return {}; +} + +function encodeBasicQosOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932171, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicConsume(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + consumerTag: void 0, + noLocal: void 0, + noAck: void 0, + exclusive: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.consumerTag = val; + val = !!(1 & buffer[offset]); + fields.noLocal = val; + val = !!(2 & buffer[offset]); + fields.noAck = val; + val = !!(4 & buffer[offset]); + fields.exclusive = val; + val = !!(8 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeBasicConsume(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + val = fields.consumerTag; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)"); + var consumerTag_len = Buffer.byteLength(val, "utf8"); + varyingSize += consumerTag_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932180, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.consumerTag; + void 0 === val && (val = ""); + buffer[offset] = consumerTag_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += consumerTag_len; + val = fields.noLocal; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.noAck; + void 0 === val && (val = !1); + val && (bits += 2); + val = fields.exclusive; + void 0 === val && (val = !1); + val && (bits += 4); + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 8); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicConsumeOk(buffer) { + var val, len, offset = 0, fields = { + consumerTag: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.consumerTag = val; + return fields; +} + +function encodeBasicConsumeOk(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.consumerTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)"); + var consumerTag_len = Buffer.byteLength(val, "utf8"); + varyingSize += consumerTag_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932181, 7); + offset = 11; + val = fields.consumerTag; + void 0 === val && (val = void 0); + buffer[offset] = consumerTag_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += consumerTag_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicCancel(buffer) { + var val, len, offset = 0, fields = { + consumerTag: void 0, + nowait: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.consumerTag = val; + val = !!(1 & buffer[offset]); + fields.nowait = val; + return fields; +} + +function encodeBasicCancel(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.consumerTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)"); + var consumerTag_len = Buffer.byteLength(val, "utf8"); + varyingSize += consumerTag_len; + var buffer = Buffer.alloc(14 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932190, 7); + offset = 11; + val = fields.consumerTag; + void 0 === val && (val = void 0); + buffer[offset] = consumerTag_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += consumerTag_len; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicCancelOk(buffer) { + var val, len, offset = 0, fields = { + consumerTag: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.consumerTag = val; + return fields; +} + +function encodeBasicCancelOk(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.consumerTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)"); + var consumerTag_len = Buffer.byteLength(val, "utf8"); + varyingSize += consumerTag_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932191, 7); + offset = 11; + val = fields.consumerTag; + void 0 === val && (val = void 0); + buffer[offset] = consumerTag_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += consumerTag_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicPublish(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + exchange: void 0, + routingKey: void 0, + mandatory: void 0, + immediate: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + val = !!(1 & buffer[offset]); + fields.mandatory = val; + val = !!(2 & buffer[offset]); + fields.immediate = val; + return fields; +} + +function encodeBasicPublish(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.exchange; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932200, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.exchange; + void 0 === val && (val = ""); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = ""); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + val = fields.mandatory; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.immediate; + void 0 === val && (val = !1); + val && (bits += 2); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicReturn(buffer) { + var val, len, offset = 0, fields = { + replyCode: void 0, + replyText: void 0, + exchange: void 0, + routingKey: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.replyCode = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.replyText = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + return fields; +} + +function encodeBasicReturn(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.replyText; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)"); + var replyText_len = Buffer.byteLength(val, "utf8"); + varyingSize += replyText_len; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932210, 7); + offset = 11; + val = fields.replyCode; + if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.replyText; + void 0 === val && (val = ""); + buffer[offset] = replyText_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += replyText_len; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = void 0); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicDeliver(buffer) { + var val, len, offset = 0, fields = { + consumerTag: void 0, + deliveryTag: void 0, + redelivered: void 0, + exchange: void 0, + routingKey: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.consumerTag = val; + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.deliveryTag = val; + val = !!(1 & buffer[offset]); + fields.redelivered = val; + offset++; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + return fields; +} + +function encodeBasicDeliver(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.consumerTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerTag'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'consumerTag' is the wrong type; must be a string (up to 255 chars)"); + var consumerTag_len = Buffer.byteLength(val, "utf8"); + varyingSize += consumerTag_len; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + var buffer = Buffer.alloc(24 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932220, 7); + offset = 11; + val = fields.consumerTag; + void 0 === val && (val = void 0); + buffer[offset] = consumerTag_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += consumerTag_len; + val = fields.deliveryTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)"); + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + val = fields.redelivered; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + bits = 0; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = void 0); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicGet(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + noAck: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + val = !!(1 & buffer[offset]); + fields.noAck = val; + return fields; +} + +function encodeBasicGet(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932230, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.noAck; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicGetOk(buffer) { + var val, len, offset = 0, fields = { + deliveryTag: void 0, + redelivered: void 0, + exchange: void 0, + routingKey: void 0, + messageCount: void 0 + }; + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.deliveryTag = val; + val = !!(1 & buffer[offset]); + fields.redelivered = val; + offset++; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.messageCount = val; + return fields; +} + +function encodeBasicGetOk(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) throw new Error("Missing value for mandatory field 'routingKey'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + var buffer = Buffer.alloc(27 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932231, 7); + offset = 11; + val = fields.deliveryTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)"); + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + val = fields.redelivered; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + bits = 0; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = void 0); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + val = fields.messageCount; + if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicGetEmpty(buffer) { + var val, len, offset = 0, fields = { + clusterId: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.clusterId = val; + return fields; +} + +function encodeBasicGetEmpty(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.clusterId; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'clusterId' is the wrong type; must be a string (up to 255 chars)"); + var clusterId_len = Buffer.byteLength(val, "utf8"); + varyingSize += clusterId_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932232, 7); + offset = 11; + val = fields.clusterId; + void 0 === val && (val = ""); + buffer[offset] = clusterId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += clusterId_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicAck(buffer) { + var val, offset = 0, fields = { + deliveryTag: void 0, + multiple: void 0 + }; + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.deliveryTag = val; + val = !!(1 & buffer[offset]); + fields.multiple = val; + return fields; +} + +function encodeBasicAck(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(21); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932240, 7); + offset = 11; + val = fields.deliveryTag; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)"); + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + val = fields.multiple; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicReject(buffer) { + var val, offset = 0, fields = { + deliveryTag: void 0, + requeue: void 0 + }; + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.deliveryTag = val; + val = !!(1 & buffer[offset]); + fields.requeue = val; + return fields; +} + +function encodeBasicReject(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(21); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932250, 7); + offset = 11; + val = fields.deliveryTag; + if (void 0 === val) throw new Error("Missing value for mandatory field 'deliveryTag'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)"); + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + val = fields.requeue; + void 0 === val && (val = !0); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicRecoverAsync(buffer) { + var val, fields = { + requeue: void 0 + }; + val = !!(1 & buffer[0]); + fields.requeue = val; + return fields; +} + +function encodeBasicRecoverAsync(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(13); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932260, 7); + offset = 11; + val = fields.requeue; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicRecover(buffer) { + var val, fields = { + requeue: void 0 + }; + val = !!(1 & buffer[0]); + fields.requeue = val; + return fields; +} + +function encodeBasicRecover(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(13); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932270, 7); + offset = 11; + val = fields.requeue; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicRecoverOk(buffer) { + return {}; +} + +function encodeBasicRecoverOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932271, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeBasicNack(buffer) { + var val, offset = 0, fields = { + deliveryTag: void 0, + multiple: void 0, + requeue: void 0 + }; + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.deliveryTag = val; + val = !!(1 & buffer[offset]); + fields.multiple = val; + val = !!(2 & buffer[offset]); + fields.requeue = val; + return fields; +} + +function encodeBasicNack(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(21); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932280, 7); + offset = 11; + val = fields.deliveryTag; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryTag' is the wrong type; must be a number (but not NaN)"); + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + val = fields.multiple; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.requeue; + void 0 === val && (val = !0); + val && (bits += 2); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionStart(buffer) { + var val, len, offset = 0, fields = { + versionMajor: void 0, + versionMinor: void 0, + serverProperties: void 0, + mechanisms: void 0, + locales: void 0 + }; + val = buffer[offset]; + offset++; + fields.versionMajor = val; + val = buffer[offset]; + offset++; + fields.versionMinor = val; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.serverProperties = val; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.mechanisms = val; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.locales = val; + return fields; +} + +function encodeConnectionStart(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0, scratchOffset = 0; + val = fields.serverProperties; + if (void 0 === val) throw new Error("Missing value for mandatory field 'serverProperties'"); + if ("object" != typeof val) throw new TypeError("Field 'serverProperties' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var serverProperties_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += serverProperties_encoded.length; + val = fields.mechanisms; + if (void 0 === val) val = Buffer.from("PLAIN"); else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'mechanisms' is the wrong type; must be a Buffer"); + varyingSize += val.length; + val = fields.locales; + if (void 0 === val) val = Buffer.from("en_US"); else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'locales' is the wrong type; must be a Buffer"); + varyingSize += val.length; + var buffer = Buffer.alloc(22 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655370, 7); + offset = 11; + val = fields.versionMajor; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'versionMajor' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt8(val, offset); + offset++; + val = fields.versionMinor; + if (void 0 === val) val = 9; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'versionMinor' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt8(val, offset); + offset++; + offset += serverProperties_encoded.copy(buffer, offset); + val = fields.mechanisms; + void 0 === val && (val = Buffer.from("PLAIN")); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + val = fields.locales; + void 0 === val && (val = Buffer.from("en_US")); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionStartOk(buffer) { + var val, len, offset = 0, fields = { + clientProperties: void 0, + mechanism: void 0, + response: void 0, + locale: void 0 + }; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.clientProperties = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.mechanism = val; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.response = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.locale = val; + return fields; +} + +function encodeConnectionStartOk(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0, scratchOffset = 0; + val = fields.clientProperties; + if (void 0 === val) throw new Error("Missing value for mandatory field 'clientProperties'"); + if ("object" != typeof val) throw new TypeError("Field 'clientProperties' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var clientProperties_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += clientProperties_encoded.length; + val = fields.mechanism; + if (void 0 === val) val = "PLAIN"; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'mechanism' is the wrong type; must be a string (up to 255 chars)"); + var mechanism_len = Buffer.byteLength(val, "utf8"); + varyingSize += mechanism_len; + val = fields.response; + if (void 0 === val) throw new Error("Missing value for mandatory field 'response'"); + if (!Buffer.isBuffer(val)) throw new TypeError("Field 'response' is the wrong type; must be a Buffer"); + varyingSize += val.length; + val = fields.locale; + if (void 0 === val) val = "en_US"; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'locale' is the wrong type; must be a string (up to 255 chars)"); + var locale_len = Buffer.byteLength(val, "utf8"); + varyingSize += locale_len; + var buffer = Buffer.alloc(18 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655371, 7); + offset = 11; + offset += clientProperties_encoded.copy(buffer, offset); + val = fields.mechanism; + void 0 === val && (val = "PLAIN"); + buffer[offset] = mechanism_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += mechanism_len; + val = fields.response; + void 0 === val && (val = Buffer.from(void 0)); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + val = fields.locale; + void 0 === val && (val = "en_US"); + buffer[offset] = locale_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += locale_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionSecure(buffer) { + var val, len, offset = 0, fields = { + challenge: void 0 + }; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.challenge = val; + return fields; +} + +function encodeConnectionSecure(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0; + val = fields.challenge; + if (void 0 === val) throw new Error("Missing value for mandatory field 'challenge'"); + if (!Buffer.isBuffer(val)) throw new TypeError("Field 'challenge' is the wrong type; must be a Buffer"); + varyingSize += val.length; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655380, 7); + offset = 11; + val = fields.challenge; + void 0 === val && (val = Buffer.from(void 0)); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionSecureOk(buffer) { + var val, len, offset = 0, fields = { + response: void 0 + }; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.response = val; + return fields; +} + +function encodeConnectionSecureOk(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0; + val = fields.response; + if (void 0 === val) throw new Error("Missing value for mandatory field 'response'"); + if (!Buffer.isBuffer(val)) throw new TypeError("Field 'response' is the wrong type; must be a Buffer"); + varyingSize += val.length; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655381, 7); + offset = 11; + val = fields.response; + void 0 === val && (val = Buffer.from(void 0)); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionTune(buffer) { + var val, offset = 0, fields = { + channelMax: void 0, + frameMax: void 0, + heartbeat: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.channelMax = val; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.frameMax = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.heartbeat = val; + return fields; +} + +function encodeConnectionTune(channel, fields) { + var offset = 0, val = null, buffer = Buffer.alloc(20); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655390, 7); + offset = 11; + val = fields.channelMax; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'channelMax' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.frameMax; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'frameMax' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + val = fields.heartbeat; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'heartbeat' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionTuneOk(buffer) { + var val, offset = 0, fields = { + channelMax: void 0, + frameMax: void 0, + heartbeat: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.channelMax = val; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.frameMax = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.heartbeat = val; + return fields; +} + +function encodeConnectionTuneOk(channel, fields) { + var offset = 0, val = null, buffer = Buffer.alloc(20); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655391, 7); + offset = 11; + val = fields.channelMax; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'channelMax' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.frameMax; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'frameMax' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + val = fields.heartbeat; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'heartbeat' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionOpen(buffer) { + var val, len, offset = 0, fields = { + virtualHost: void 0, + capabilities: void 0, + insist: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.virtualHost = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.capabilities = val; + val = !!(1 & buffer[offset]); + fields.insist = val; + return fields; +} + +function encodeConnectionOpen(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.virtualHost; + if (void 0 === val) val = "/"; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'virtualHost' is the wrong type; must be a string (up to 255 chars)"); + var virtualHost_len = Buffer.byteLength(val, "utf8"); + varyingSize += virtualHost_len; + val = fields.capabilities; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'capabilities' is the wrong type; must be a string (up to 255 chars)"); + var capabilities_len = Buffer.byteLength(val, "utf8"); + varyingSize += capabilities_len; + var buffer = Buffer.alloc(15 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655400, 7); + offset = 11; + val = fields.virtualHost; + void 0 === val && (val = "/"); + buffer[offset] = virtualHost_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += virtualHost_len; + val = fields.capabilities; + void 0 === val && (val = ""); + buffer[offset] = capabilities_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += capabilities_len; + val = fields.insist; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionOpenOk(buffer) { + var val, len, offset = 0, fields = { + knownHosts: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.knownHosts = val; + return fields; +} + +function encodeConnectionOpenOk(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.knownHosts; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'knownHosts' is the wrong type; must be a string (up to 255 chars)"); + var knownHosts_len = Buffer.byteLength(val, "utf8"); + varyingSize += knownHosts_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655401, 7); + offset = 11; + val = fields.knownHosts; + void 0 === val && (val = ""); + buffer[offset] = knownHosts_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += knownHosts_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionClose(buffer) { + var val, len, offset = 0, fields = { + replyCode: void 0, + replyText: void 0, + classId: void 0, + methodId: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.replyCode = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.replyText = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.classId = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.methodId = val; + return fields; +} + +function encodeConnectionClose(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.replyText; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)"); + var replyText_len = Buffer.byteLength(val, "utf8"); + varyingSize += replyText_len; + var buffer = Buffer.alloc(19 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655410, 7); + offset = 11; + val = fields.replyCode; + if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.replyText; + void 0 === val && (val = ""); + buffer[offset] = replyText_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += replyText_len; + val = fields.classId; + if (void 0 === val) throw new Error("Missing value for mandatory field 'classId'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'classId' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.methodId; + if (void 0 === val) throw new Error("Missing value for mandatory field 'methodId'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'methodId' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionCloseOk(buffer) { + return {}; +} + +function encodeConnectionCloseOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655411, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionBlocked(buffer) { + var val, len, offset = 0, fields = { + reason: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.reason = val; + return fields; +} + +function encodeConnectionBlocked(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.reason; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'reason' is the wrong type; must be a string (up to 255 chars)"); + var reason_len = Buffer.byteLength(val, "utf8"); + varyingSize += reason_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655420, 7); + offset = 11; + val = fields.reason; + void 0 === val && (val = ""); + buffer[offset] = reason_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += reason_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionUnblocked(buffer) { + return {}; +} + +function encodeConnectionUnblocked(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655421, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionUpdateSecret(buffer) { + var val, len, offset = 0, fields = { + newSecret: void 0, + reason: void 0 + }; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.newSecret = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.reason = val; + return fields; +} + +function encodeConnectionUpdateSecret(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0; + val = fields.newSecret; + if (void 0 === val) throw new Error("Missing value for mandatory field 'newSecret'"); + if (!Buffer.isBuffer(val)) throw new TypeError("Field 'newSecret' is the wrong type; must be a Buffer"); + varyingSize += val.length; + val = fields.reason; + if (void 0 === val) throw new Error("Missing value for mandatory field 'reason'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'reason' is the wrong type; must be a string (up to 255 chars)"); + var reason_len = Buffer.byteLength(val, "utf8"); + varyingSize += reason_len; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655430, 7); + offset = 11; + val = fields.newSecret; + void 0 === val && (val = Buffer.from(void 0)); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + val = fields.reason; + void 0 === val && (val = void 0); + buffer[offset] = reason_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += reason_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConnectionUpdateSecretOk(buffer) { + return {}; +} + +function encodeConnectionUpdateSecretOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(655431, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelOpen(buffer) { + var val, len, offset = 0, fields = { + outOfBand: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.outOfBand = val; + return fields; +} + +function encodeChannelOpen(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.outOfBand; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'outOfBand' is the wrong type; must be a string (up to 255 chars)"); + var outOfBand_len = Buffer.byteLength(val, "utf8"); + varyingSize += outOfBand_len; + var buffer = Buffer.alloc(13 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310730, 7); + offset = 11; + val = fields.outOfBand; + void 0 === val && (val = ""); + buffer[offset] = outOfBand_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += outOfBand_len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelOpenOk(buffer) { + var val, len, offset = 0, fields = { + channelId: void 0 + }; + len = buffer.readUInt32BE(offset); + offset += 4; + val = buffer.subarray(offset, offset + len); + offset += len; + fields.channelId = val; + return fields; +} + +function encodeChannelOpenOk(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0; + val = fields.channelId; + if (void 0 === val) val = Buffer.from(""); else if (!Buffer.isBuffer(val)) throw new TypeError("Field 'channelId' is the wrong type; must be a Buffer"); + varyingSize += val.length; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310731, 7); + offset = 11; + val = fields.channelId; + void 0 === val && (val = Buffer.from("")); + len = val.length; + buffer.writeUInt32BE(len, offset); + offset += 4; + val.copy(buffer, offset); + offset += len; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelFlow(buffer) { + var val, fields = { + active: void 0 + }; + val = !!(1 & buffer[0]); + fields.active = val; + return fields; +} + +function encodeChannelFlow(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(13); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310740, 7); + offset = 11; + val = fields.active; + if (void 0 === val) throw new Error("Missing value for mandatory field 'active'"); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelFlowOk(buffer) { + var val, fields = { + active: void 0 + }; + val = !!(1 & buffer[0]); + fields.active = val; + return fields; +} + +function encodeChannelFlowOk(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(13); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310741, 7); + offset = 11; + val = fields.active; + if (void 0 === val) throw new Error("Missing value for mandatory field 'active'"); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelClose(buffer) { + var val, len, offset = 0, fields = { + replyCode: void 0, + replyText: void 0, + classId: void 0, + methodId: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.replyCode = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.replyText = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.classId = val; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.methodId = val; + return fields; +} + +function encodeChannelClose(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.replyText; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'replyText' is the wrong type; must be a string (up to 255 chars)"); + var replyText_len = Buffer.byteLength(val, "utf8"); + varyingSize += replyText_len; + var buffer = Buffer.alloc(19 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310760, 7); + offset = 11; + val = fields.replyCode; + if (void 0 === val) throw new Error("Missing value for mandatory field 'replyCode'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'replyCode' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.replyText; + void 0 === val && (val = ""); + buffer[offset] = replyText_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += replyText_len; + val = fields.classId; + if (void 0 === val) throw new Error("Missing value for mandatory field 'classId'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'classId' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.methodId; + if (void 0 === val) throw new Error("Missing value for mandatory field 'methodId'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'methodId' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeChannelCloseOk(buffer) { + return {}; +} + +function encodeChannelCloseOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1310761, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeAccessRequest(buffer) { + var val, len, offset = 0, fields = { + realm: void 0, + exclusive: void 0, + passive: void 0, + active: void 0, + write: void 0, + read: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.realm = val; + val = !!(1 & buffer[offset]); + fields.exclusive = val; + val = !!(2 & buffer[offset]); + fields.passive = val; + val = !!(4 & buffer[offset]); + fields.active = val; + val = !!(8 & buffer[offset]); + fields.write = val; + val = !!(16 & buffer[offset]); + fields.read = val; + return fields; +} + +function encodeAccessRequest(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.realm; + if (void 0 === val) val = "/data"; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'realm' is the wrong type; must be a string (up to 255 chars)"); + var realm_len = Buffer.byteLength(val, "utf8"); + varyingSize += realm_len; + var buffer = Buffer.alloc(14 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1966090, 7); + offset = 11; + val = fields.realm; + void 0 === val && (val = "/data"); + buffer[offset] = realm_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += realm_len; + val = fields.exclusive; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.passive; + void 0 === val && (val = !0); + val && (bits += 2); + val = fields.active; + void 0 === val && (val = !0); + val && (bits += 4); + val = fields.write; + void 0 === val && (val = !0); + val && (bits += 8); + val = fields.read; + void 0 === val && (val = !0); + val && (bits += 16); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeAccessRequestOk(buffer) { + var val, offset = 0, fields = { + ticket: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + return fields; +} + +function encodeAccessRequestOk(channel, fields) { + var offset = 0, val = null, buffer = Buffer.alloc(14); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(1966091, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 1; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeDeclare(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + exchange: void 0, + type: void 0, + passive: void 0, + durable: void 0, + autoDelete: void 0, + internal: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.type = val; + val = !!(1 & buffer[offset]); + fields.passive = val; + val = !!(2 & buffer[offset]); + fields.durable = val; + val = !!(4 & buffer[offset]); + fields.autoDelete = val; + val = !!(8 & buffer[offset]); + fields.internal = val; + val = !!(16 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeExchangeDeclare(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.type; + if (void 0 === val) val = "direct"; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'type' is the wrong type; must be a string (up to 255 chars)"); + var type_len = Buffer.byteLength(val, "utf8"); + varyingSize += type_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621450, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.type; + void 0 === val && (val = "direct"); + buffer[offset] = type_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += type_len; + val = fields.passive; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.durable; + void 0 === val && (val = !1); + val && (bits += 2); + val = fields.autoDelete; + void 0 === val && (val = !1); + val && (bits += 4); + val = fields.internal; + void 0 === val && (val = !1); + val && (bits += 8); + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 16); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeDeclareOk(buffer) { + return {}; +} + +function encodeExchangeDeclareOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621451, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeDelete(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + exchange: void 0, + ifUnused: void 0, + nowait: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + val = !!(1 & buffer[offset]); + fields.ifUnused = val; + val = !!(2 & buffer[offset]); + fields.nowait = val; + return fields; +} + +function encodeExchangeDelete(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621460, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.ifUnused; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 2); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeDeleteOk(buffer) { + return {}; +} + +function encodeExchangeDeleteOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621461, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeBind(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + destination: void 0, + source: void 0, + routingKey: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.destination = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.source = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + val = !!(1 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeExchangeBind(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.destination; + if (void 0 === val) throw new Error("Missing value for mandatory field 'destination'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'destination' is the wrong type; must be a string (up to 255 chars)"); + var destination_len = Buffer.byteLength(val, "utf8"); + varyingSize += destination_len; + val = fields.source; + if (void 0 === val) throw new Error("Missing value for mandatory field 'source'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'source' is the wrong type; must be a string (up to 255 chars)"); + var source_len = Buffer.byteLength(val, "utf8"); + varyingSize += source_len; + val = fields.routingKey; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(18 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621470, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.destination; + void 0 === val && (val = void 0); + buffer[offset] = destination_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += destination_len; + val = fields.source; + void 0 === val && (val = void 0); + buffer[offset] = source_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += source_len; + val = fields.routingKey; + void 0 === val && (val = ""); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeBindOk(buffer) { + return {}; +} + +function encodeExchangeBindOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621471, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeUnbind(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + destination: void 0, + source: void 0, + routingKey: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.destination = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.source = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + val = !!(1 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeExchangeUnbind(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.destination; + if (void 0 === val) throw new Error("Missing value for mandatory field 'destination'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'destination' is the wrong type; must be a string (up to 255 chars)"); + var destination_len = Buffer.byteLength(val, "utf8"); + varyingSize += destination_len; + val = fields.source; + if (void 0 === val) throw new Error("Missing value for mandatory field 'source'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'source' is the wrong type; must be a string (up to 255 chars)"); + var source_len = Buffer.byteLength(val, "utf8"); + varyingSize += source_len; + val = fields.routingKey; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(18 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621480, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.destination; + void 0 === val && (val = void 0); + buffer[offset] = destination_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += destination_len; + val = fields.source; + void 0 === val && (val = void 0); + buffer[offset] = source_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += source_len; + val = fields.routingKey; + void 0 === val && (val = ""); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeExchangeUnbindOk(buffer) { + return {}; +} + +function encodeExchangeUnbindOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(2621491, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueDeclare(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + passive: void 0, + durable: void 0, + exclusive: void 0, + autoDelete: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + val = !!(1 & buffer[offset]); + fields.passive = val; + val = !!(2 & buffer[offset]); + fields.durable = val; + val = !!(4 & buffer[offset]); + fields.exclusive = val; + val = !!(8 & buffer[offset]); + fields.autoDelete = val; + val = !!(16 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeQueueDeclare(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276810, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.passive; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.durable; + void 0 === val && (val = !1); + val && (bits += 2); + val = fields.exclusive; + void 0 === val && (val = !1); + val && (bits += 4); + val = fields.autoDelete; + void 0 === val && (val = !1); + val && (bits += 8); + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 16); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueDeclareOk(buffer) { + var val, len, offset = 0, fields = { + queue: void 0, + messageCount: void 0, + consumerCount: void 0 + }; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.messageCount = val; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.consumerCount = val; + return fields; +} + +function encodeQueueDeclareOk(channel, fields) { + var offset = 0, val = null, varyingSize = 0; + val = fields.queue; + if (void 0 === val) throw new Error("Missing value for mandatory field 'queue'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + var buffer = Buffer.alloc(21 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276811, 7); + offset = 11; + val = fields.queue; + void 0 === val && (val = void 0); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.messageCount; + if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + val = fields.consumerCount; + if (void 0 === val) throw new Error("Missing value for mandatory field 'consumerCount'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'consumerCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueBind(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + exchange: void 0, + routingKey: void 0, + nowait: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + val = !!(1 & buffer[offset]); + fields.nowait = val; + offset++; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeQueueBind(channel, fields) { + var len, offset = 0, val = null, bits = 0, varyingSize = 0, scratchOffset = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(18 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276820, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = ""); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + bits = 0; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueBindOk(buffer) { + return {}; +} + +function encodeQueueBindOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276821, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueuePurge(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + nowait: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + val = !!(1 & buffer[offset]); + fields.nowait = val; + return fields; +} + +function encodeQueuePurge(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276830, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueuePurgeOk(buffer) { + var val, offset = 0, fields = { + messageCount: void 0 + }; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.messageCount = val; + return fields; +} + +function encodeQueuePurgeOk(channel, fields) { + var offset = 0, val = null, buffer = Buffer.alloc(16); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276831, 7); + offset = 11; + val = fields.messageCount; + if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueDelete(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + ifUnused: void 0, + ifEmpty: void 0, + nowait: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + val = !!(1 & buffer[offset]); + fields.ifUnused = val; + val = !!(2 & buffer[offset]); + fields.ifEmpty = val; + val = !!(4 & buffer[offset]); + fields.nowait = val; + return fields; +} + +function encodeQueueDelete(channel, fields) { + var offset = 0, val = null, bits = 0, varyingSize = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + var buffer = Buffer.alloc(16 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276840, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.ifUnused; + void 0 === val && (val = !1); + val && (bits += 1); + val = fields.ifEmpty; + void 0 === val && (val = !1); + val && (bits += 2); + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 4); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueDeleteOk(buffer) { + var val, offset = 0, fields = { + messageCount: void 0 + }; + val = buffer.readUInt32BE(offset); + offset += 4; + fields.messageCount = val; + return fields; +} + +function encodeQueueDeleteOk(channel, fields) { + var offset = 0, val = null, buffer = Buffer.alloc(16); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276841, 7); + offset = 11; + val = fields.messageCount; + if (void 0 === val) throw new Error("Missing value for mandatory field 'messageCount'"); + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'messageCount' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt32BE(val, offset); + offset += 4; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueUnbind(buffer) { + var val, len, offset = 0, fields = { + ticket: void 0, + queue: void 0, + exchange: void 0, + routingKey: void 0, + arguments: void 0 + }; + val = buffer.readUInt16BE(offset); + offset += 2; + fields.ticket = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.queue = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.exchange = val; + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.routingKey = val; + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.arguments = val; + return fields; +} + +function encodeQueueUnbind(channel, fields) { + var len, offset = 0, val = null, varyingSize = 0, scratchOffset = 0; + val = fields.queue; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'queue' is the wrong type; must be a string (up to 255 chars)"); + var queue_len = Buffer.byteLength(val, "utf8"); + varyingSize += queue_len; + val = fields.exchange; + if (void 0 === val) throw new Error("Missing value for mandatory field 'exchange'"); + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'exchange' is the wrong type; must be a string (up to 255 chars)"); + var exchange_len = Buffer.byteLength(val, "utf8"); + varyingSize += exchange_len; + val = fields.routingKey; + if (void 0 === val) val = ""; else if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'routingKey' is the wrong type; must be a string (up to 255 chars)"); + var routingKey_len = Buffer.byteLength(val, "utf8"); + varyingSize += routingKey_len; + val = fields.arguments; + if (void 0 === val) val = {}; else if ("object" != typeof val) throw new TypeError("Field 'arguments' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var arguments_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += arguments_encoded.length; + var buffer = Buffer.alloc(17 + varyingSize); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276850, 7); + offset = 11; + val = fields.ticket; + if (void 0 === val) val = 0; else if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'ticket' is the wrong type; must be a number (but not NaN)"); + buffer.writeUInt16BE(val, offset); + offset += 2; + val = fields.queue; + void 0 === val && (val = ""); + buffer[offset] = queue_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += queue_len; + val = fields.exchange; + void 0 === val && (val = void 0); + buffer[offset] = exchange_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += exchange_len; + val = fields.routingKey; + void 0 === val && (val = ""); + buffer[offset] = routingKey_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += routingKey_len; + offset += arguments_encoded.copy(buffer, offset); + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeQueueUnbindOk(buffer) { + return {}; +} + +function encodeQueueUnbindOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3276851, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxSelect(buffer) { + return {}; +} + +function encodeTxSelect(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898250, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxSelectOk(buffer) { + return {}; +} + +function encodeTxSelectOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898251, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxCommit(buffer) { + return {}; +} + +function encodeTxCommit(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898260, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxCommitOk(buffer) { + return {}; +} + +function encodeTxCommitOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898261, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxRollback(buffer) { + return {}; +} + +function encodeTxRollback(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898270, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeTxRollbackOk(buffer) { + return {}; +} + +function encodeTxRollbackOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5898271, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConfirmSelect(buffer) { + var val, fields = { + nowait: void 0 + }; + val = !!(1 & buffer[0]); + fields.nowait = val; + return fields; +} + +function encodeConfirmSelect(channel, fields) { + var offset = 0, val = null, bits = 0, buffer = Buffer.alloc(13); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5570570, 7); + offset = 11; + val = fields.nowait; + void 0 === val && (val = !1); + val && (bits += 1); + buffer[offset] = bits; + offset++; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function decodeConfirmSelectOk(buffer) { + return {}; +} + +function encodeConfirmSelectOk(channel, fields) { + var offset = 0, buffer = Buffer.alloc(12); + buffer[0] = 1; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(5570571, 7); + offset = 11; + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + return buffer; +} + +function encodeBasicProperties(channel, size, fields) { + var val, len, offset = 0, flags = 0, scratchOffset = 0, varyingSize = 0; + val = fields.contentType; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'contentType' is the wrong type; must be a string (up to 255 chars)"); + var contentType_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += contentType_len; + } + val = fields.contentEncoding; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'contentEncoding' is the wrong type; must be a string (up to 255 chars)"); + var contentEncoding_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += contentEncoding_len; + } + val = fields.headers; + if (void 0 != val) { + if ("object" != typeof val) throw new TypeError("Field 'headers' is the wrong type; must be an object"); + len = encodeTable(SCRATCH, val, scratchOffset); + var headers_encoded = SCRATCH.slice(scratchOffset, scratchOffset + len); + scratchOffset += len; + varyingSize += headers_encoded.length; + } + val = fields.deliveryMode; + if (void 0 != val) { + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'deliveryMode' is the wrong type; must be a number (but not NaN)"); + varyingSize += 1; + } + val = fields.priority; + if (void 0 != val) { + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'priority' is the wrong type; must be a number (but not NaN)"); + varyingSize += 1; + } + val = fields.correlationId; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'correlationId' is the wrong type; must be a string (up to 255 chars)"); + var correlationId_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += correlationId_len; + } + val = fields.replyTo; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'replyTo' is the wrong type; must be a string (up to 255 chars)"); + var replyTo_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += replyTo_len; + } + val = fields.expiration; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'expiration' is the wrong type; must be a string (up to 255 chars)"); + var expiration_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += expiration_len; + } + val = fields.messageId; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'messageId' is the wrong type; must be a string (up to 255 chars)"); + var messageId_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += messageId_len; + } + val = fields.timestamp; + if (void 0 != val) { + if ("number" != typeof val || isNaN(val)) throw new TypeError("Field 'timestamp' is the wrong type; must be a number (but not NaN)"); + varyingSize += 8; + } + val = fields.type; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'type' is the wrong type; must be a string (up to 255 chars)"); + var type_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += type_len; + } + val = fields.userId; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'userId' is the wrong type; must be a string (up to 255 chars)"); + var userId_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += userId_len; + } + val = fields.appId; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'appId' is the wrong type; must be a string (up to 255 chars)"); + var appId_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += appId_len; + } + val = fields.clusterId; + if (void 0 != val) { + if (!("string" == typeof val && Buffer.byteLength(val) < 256)) throw new TypeError("Field 'clusterId' is the wrong type; must be a string (up to 255 chars)"); + var clusterId_len = Buffer.byteLength(val, "utf8"); + varyingSize += 1; + varyingSize += clusterId_len; + } + var buffer = Buffer.alloc(22 + varyingSize); + buffer[0] = 2; + buffer.writeUInt16BE(channel, 1); + buffer.writeUInt32BE(3932160, 7); + ints.writeUInt64BE(buffer, size, 11); + flags = 0; + offset = 21; + val = fields.contentType; + if (void 0 != val) { + flags += 32768; + buffer[offset] = contentType_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += contentType_len; + } + val = fields.contentEncoding; + if (void 0 != val) { + flags += 16384; + buffer[offset] = contentEncoding_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += contentEncoding_len; + } + val = fields.headers; + if (void 0 != val) { + flags += 8192; + offset += headers_encoded.copy(buffer, offset); + } + val = fields.deliveryMode; + if (void 0 != val) { + flags += 4096; + buffer.writeUInt8(val, offset); + offset++; + } + val = fields.priority; + if (void 0 != val) { + flags += 2048; + buffer.writeUInt8(val, offset); + offset++; + } + val = fields.correlationId; + if (void 0 != val) { + flags += 1024; + buffer[offset] = correlationId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += correlationId_len; + } + val = fields.replyTo; + if (void 0 != val) { + flags += 512; + buffer[offset] = replyTo_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += replyTo_len; + } + val = fields.expiration; + if (void 0 != val) { + flags += 256; + buffer[offset] = expiration_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += expiration_len; + } + val = fields.messageId; + if (void 0 != val) { + flags += 128; + buffer[offset] = messageId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += messageId_len; + } + val = fields.timestamp; + if (void 0 != val) { + flags += 64; + ints.writeUInt64BE(buffer, val, offset); + offset += 8; + } + val = fields.type; + if (void 0 != val) { + flags += 32; + buffer[offset] = type_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += type_len; + } + val = fields.userId; + if (void 0 != val) { + flags += 16; + buffer[offset] = userId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += userId_len; + } + val = fields.appId; + if (void 0 != val) { + flags += 8; + buffer[offset] = appId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += appId_len; + } + val = fields.clusterId; + if (void 0 != val) { + flags += 4; + buffer[offset] = clusterId_len; + offset++; + buffer.write(val, offset, "utf8"); + offset += clusterId_len; + } + buffer[offset] = 206; + buffer.writeUInt32BE(offset - 7, 3); + buffer.writeUInt16BE(flags, 19); + return buffer.subarray(0, offset + 1); +} + +function decodeBasicProperties(buffer) { + var flags, val, len, offset = 2; + flags = buffer.readUInt16BE(0); + if (0 === flags) return {}; + var fields = { + contentType: void 0, + contentEncoding: void 0, + headers: void 0, + deliveryMode: void 0, + priority: void 0, + correlationId: void 0, + replyTo: void 0, + expiration: void 0, + messageId: void 0, + timestamp: void 0, + type: void 0, + userId: void 0, + appId: void 0, + clusterId: void 0 + }; + if (32768 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.contentType = val; + } + if (16384 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.contentEncoding = val; + } + if (8192 & flags) { + len = buffer.readUInt32BE(offset); + offset += 4; + val = decodeFields(buffer.subarray(offset, offset + len)); + offset += len; + fields.headers = val; + } + if (4096 & flags) { + val = buffer[offset]; + offset++; + fields.deliveryMode = val; + } + if (2048 & flags) { + val = buffer[offset]; + offset++; + fields.priority = val; + } + if (1024 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.correlationId = val; + } + if (512 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.replyTo = val; + } + if (256 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.expiration = val; + } + if (128 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.messageId = val; + } + if (64 & flags) { + val = ints.readUInt64BE(buffer, offset); + offset += 8; + fields.timestamp = val; + } + if (32 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.type = val; + } + if (16 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.userId = val; + } + if (8 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.appId = val; + } + if (4 & flags) { + len = buffer.readUInt8(offset); + offset++; + val = buffer.toString("utf8", offset, offset + len); + offset += len; + fields.clusterId = val; + } + return fields; +} + +var codec = require("./codec"), ints = require("buffer-more-ints"), encodeTable = codec.encodeTable, decodeFields = codec.decodeFields, SCRATCH = Buffer.alloc(65536), EMPTY_OBJECT = Object.freeze({}); + +module.exports.constants = { + FRAME_METHOD: 1, + FRAME_HEADER: 2, + FRAME_BODY: 3, + FRAME_HEARTBEAT: 8, + FRAME_MIN_SIZE: 4096, + FRAME_END: 206, + REPLY_SUCCESS: 200, + CONTENT_TOO_LARGE: 311, + NO_ROUTE: 312, + NO_CONSUMERS: 313, + ACCESS_REFUSED: 403, + NOT_FOUND: 404, + RESOURCE_LOCKED: 405, + PRECONDITION_FAILED: 406, + CONNECTION_FORCED: 320, + INVALID_PATH: 402, + FRAME_ERROR: 501, + SYNTAX_ERROR: 502, + COMMAND_INVALID: 503, + CHANNEL_ERROR: 504, + UNEXPECTED_FRAME: 505, + RESOURCE_ERROR: 506, + NOT_ALLOWED: 530, + NOT_IMPLEMENTED: 540, + INTERNAL_ERROR: 541 +}; + +module.exports.constant_strs = { + "1": "FRAME-METHOD", + "2": "FRAME-HEADER", + "3": "FRAME-BODY", + "8": "FRAME-HEARTBEAT", + "200": "REPLY-SUCCESS", + "206": "FRAME-END", + "311": "CONTENT-TOO-LARGE", + "312": "NO-ROUTE", + "313": "NO-CONSUMERS", + "320": "CONNECTION-FORCED", + "402": "INVALID-PATH", + "403": "ACCESS-REFUSED", + "404": "NOT-FOUND", + "405": "RESOURCE-LOCKED", + "406": "PRECONDITION-FAILED", + "501": "FRAME-ERROR", + "502": "SYNTAX-ERROR", + "503": "COMMAND-INVALID", + "504": "CHANNEL-ERROR", + "505": "UNEXPECTED-FRAME", + "506": "RESOURCE-ERROR", + "530": "NOT-ALLOWED", + "540": "NOT-IMPLEMENTED", + "541": "INTERNAL-ERROR", + "4096": "FRAME-MIN-SIZE" +}; + +module.exports.FRAME_OVERHEAD = 8; + +module.exports.decode = function(id, buf) { + switch (id) { + case 3932170: + return decodeBasicQos(buf); + + case 3932171: + return decodeBasicQosOk(buf); + + case 3932180: + return decodeBasicConsume(buf); + + case 3932181: + return decodeBasicConsumeOk(buf); + + case 3932190: + return decodeBasicCancel(buf); + + case 3932191: + return decodeBasicCancelOk(buf); + + case 3932200: + return decodeBasicPublish(buf); + + case 3932210: + return decodeBasicReturn(buf); + + case 3932220: + return decodeBasicDeliver(buf); + + case 3932230: + return decodeBasicGet(buf); + + case 3932231: + return decodeBasicGetOk(buf); + + case 3932232: + return decodeBasicGetEmpty(buf); + + case 3932240: + return decodeBasicAck(buf); + + case 3932250: + return decodeBasicReject(buf); + + case 3932260: + return decodeBasicRecoverAsync(buf); + + case 3932270: + return decodeBasicRecover(buf); + + case 3932271: + return decodeBasicRecoverOk(buf); + + case 3932280: + return decodeBasicNack(buf); + + case 655370: + return decodeConnectionStart(buf); + + case 655371: + return decodeConnectionStartOk(buf); + + case 655380: + return decodeConnectionSecure(buf); + + case 655381: + return decodeConnectionSecureOk(buf); + + case 655390: + return decodeConnectionTune(buf); + + case 655391: + return decodeConnectionTuneOk(buf); + + case 655400: + return decodeConnectionOpen(buf); + + case 655401: + return decodeConnectionOpenOk(buf); + + case 655410: + return decodeConnectionClose(buf); + + case 655411: + return decodeConnectionCloseOk(buf); + + case 655420: + return decodeConnectionBlocked(buf); + + case 655421: + return decodeConnectionUnblocked(buf); + + case 655430: + return decodeConnectionUpdateSecret(buf); + + case 655431: + return decodeConnectionUpdateSecretOk(buf); + + case 1310730: + return decodeChannelOpen(buf); + + case 1310731: + return decodeChannelOpenOk(buf); + + case 1310740: + return decodeChannelFlow(buf); + + case 1310741: + return decodeChannelFlowOk(buf); + + case 1310760: + return decodeChannelClose(buf); + + case 1310761: + return decodeChannelCloseOk(buf); + + case 1966090: + return decodeAccessRequest(buf); + + case 1966091: + return decodeAccessRequestOk(buf); + + case 2621450: + return decodeExchangeDeclare(buf); + + case 2621451: + return decodeExchangeDeclareOk(buf); + + case 2621460: + return decodeExchangeDelete(buf); + + case 2621461: + return decodeExchangeDeleteOk(buf); + + case 2621470: + return decodeExchangeBind(buf); + + case 2621471: + return decodeExchangeBindOk(buf); + + case 2621480: + return decodeExchangeUnbind(buf); + + case 2621491: + return decodeExchangeUnbindOk(buf); + + case 3276810: + return decodeQueueDeclare(buf); + + case 3276811: + return decodeQueueDeclareOk(buf); + + case 3276820: + return decodeQueueBind(buf); + + case 3276821: + return decodeQueueBindOk(buf); + + case 3276830: + return decodeQueuePurge(buf); + + case 3276831: + return decodeQueuePurgeOk(buf); + + case 3276840: + return decodeQueueDelete(buf); + + case 3276841: + return decodeQueueDeleteOk(buf); + + case 3276850: + return decodeQueueUnbind(buf); + + case 3276851: + return decodeQueueUnbindOk(buf); + + case 5898250: + return decodeTxSelect(buf); + + case 5898251: + return decodeTxSelectOk(buf); + + case 5898260: + return decodeTxCommit(buf); + + case 5898261: + return decodeTxCommitOk(buf); + + case 5898270: + return decodeTxRollback(buf); + + case 5898271: + return decodeTxRollbackOk(buf); + + case 5570570: + return decodeConfirmSelect(buf); + + case 5570571: + return decodeConfirmSelectOk(buf); + + case 60: + return decodeBasicProperties(buf); + + default: + throw new Error("Unknown class/method ID"); + } +}; + +module.exports.encodeMethod = function(id, channel, fields) { + switch (id) { + case 3932170: + return encodeBasicQos(channel, fields); + + case 3932171: + return encodeBasicQosOk(channel, fields); + + case 3932180: + return encodeBasicConsume(channel, fields); + + case 3932181: + return encodeBasicConsumeOk(channel, fields); + + case 3932190: + return encodeBasicCancel(channel, fields); + + case 3932191: + return encodeBasicCancelOk(channel, fields); + + case 3932200: + return encodeBasicPublish(channel, fields); + + case 3932210: + return encodeBasicReturn(channel, fields); + + case 3932220: + return encodeBasicDeliver(channel, fields); + + case 3932230: + return encodeBasicGet(channel, fields); + + case 3932231: + return encodeBasicGetOk(channel, fields); + + case 3932232: + return encodeBasicGetEmpty(channel, fields); + + case 3932240: + return encodeBasicAck(channel, fields); + + case 3932250: + return encodeBasicReject(channel, fields); + + case 3932260: + return encodeBasicRecoverAsync(channel, fields); + + case 3932270: + return encodeBasicRecover(channel, fields); + + case 3932271: + return encodeBasicRecoverOk(channel, fields); + + case 3932280: + return encodeBasicNack(channel, fields); + + case 655370: + return encodeConnectionStart(channel, fields); + + case 655371: + return encodeConnectionStartOk(channel, fields); + + case 655380: + return encodeConnectionSecure(channel, fields); + + case 655381: + return encodeConnectionSecureOk(channel, fields); + + case 655390: + return encodeConnectionTune(channel, fields); + + case 655391: + return encodeConnectionTuneOk(channel, fields); + + case 655400: + return encodeConnectionOpen(channel, fields); + + case 655401: + return encodeConnectionOpenOk(channel, fields); + + case 655410: + return encodeConnectionClose(channel, fields); + + case 655411: + return encodeConnectionCloseOk(channel, fields); + + case 655420: + return encodeConnectionBlocked(channel, fields); + + case 655421: + return encodeConnectionUnblocked(channel, fields); + + case 655430: + return encodeConnectionUpdateSecret(channel, fields); + + case 655431: + return encodeConnectionUpdateSecretOk(channel, fields); + + case 1310730: + return encodeChannelOpen(channel, fields); + + case 1310731: + return encodeChannelOpenOk(channel, fields); + + case 1310740: + return encodeChannelFlow(channel, fields); + + case 1310741: + return encodeChannelFlowOk(channel, fields); + + case 1310760: + return encodeChannelClose(channel, fields); + + case 1310761: + return encodeChannelCloseOk(channel, fields); + + case 1966090: + return encodeAccessRequest(channel, fields); + + case 1966091: + return encodeAccessRequestOk(channel, fields); + + case 2621450: + return encodeExchangeDeclare(channel, fields); + + case 2621451: + return encodeExchangeDeclareOk(channel, fields); + + case 2621460: + return encodeExchangeDelete(channel, fields); + + case 2621461: + return encodeExchangeDeleteOk(channel, fields); + + case 2621470: + return encodeExchangeBind(channel, fields); + + case 2621471: + return encodeExchangeBindOk(channel, fields); + + case 2621480: + return encodeExchangeUnbind(channel, fields); + + case 2621491: + return encodeExchangeUnbindOk(channel, fields); + + case 3276810: + return encodeQueueDeclare(channel, fields); + + case 3276811: + return encodeQueueDeclareOk(channel, fields); + + case 3276820: + return encodeQueueBind(channel, fields); + + case 3276821: + return encodeQueueBindOk(channel, fields); + + case 3276830: + return encodeQueuePurge(channel, fields); + + case 3276831: + return encodeQueuePurgeOk(channel, fields); + + case 3276840: + return encodeQueueDelete(channel, fields); + + case 3276841: + return encodeQueueDeleteOk(channel, fields); + + case 3276850: + return encodeQueueUnbind(channel, fields); + + case 3276851: + return encodeQueueUnbindOk(channel, fields); + + case 5898250: + return encodeTxSelect(channel, fields); + + case 5898251: + return encodeTxSelectOk(channel, fields); + + case 5898260: + return encodeTxCommit(channel, fields); + + case 5898261: + return encodeTxCommitOk(channel, fields); + + case 5898270: + return encodeTxRollback(channel, fields); + + case 5898271: + return encodeTxRollbackOk(channel, fields); + + case 5570570: + return encodeConfirmSelect(channel, fields); + + case 5570571: + return encodeConfirmSelectOk(channel, fields); + + default: + throw new Error("Unknown class/method ID"); + } +}; + +module.exports.encodeProperties = function(id, channel, size, fields) { + switch (id) { + case 60: + return encodeBasicProperties(channel, size, fields); + + default: + throw new Error("Unknown class/properties ID"); + } +}; + +module.exports.info = function(id) { + switch (id) { + case 3932170: + return methodInfoBasicQos; + + case 3932171: + return methodInfoBasicQosOk; + + case 3932180: + return methodInfoBasicConsume; + + case 3932181: + return methodInfoBasicConsumeOk; + + case 3932190: + return methodInfoBasicCancel; + + case 3932191: + return methodInfoBasicCancelOk; + + case 3932200: + return methodInfoBasicPublish; + + case 3932210: + return methodInfoBasicReturn; + + case 3932220: + return methodInfoBasicDeliver; + + case 3932230: + return methodInfoBasicGet; + + case 3932231: + return methodInfoBasicGetOk; + + case 3932232: + return methodInfoBasicGetEmpty; + + case 3932240: + return methodInfoBasicAck; + + case 3932250: + return methodInfoBasicReject; + + case 3932260: + return methodInfoBasicRecoverAsync; + + case 3932270: + return methodInfoBasicRecover; + + case 3932271: + return methodInfoBasicRecoverOk; + + case 3932280: + return methodInfoBasicNack; + + case 655370: + return methodInfoConnectionStart; + + case 655371: + return methodInfoConnectionStartOk; + + case 655380: + return methodInfoConnectionSecure; + + case 655381: + return methodInfoConnectionSecureOk; + + case 655390: + return methodInfoConnectionTune; + + case 655391: + return methodInfoConnectionTuneOk; + + case 655400: + return methodInfoConnectionOpen; + + case 655401: + return methodInfoConnectionOpenOk; + + case 655410: + return methodInfoConnectionClose; + + case 655411: + return methodInfoConnectionCloseOk; + + case 655420: + return methodInfoConnectionBlocked; + + case 655421: + return methodInfoConnectionUnblocked; + + case 655430: + return methodInfoConnectionUpdateSecret; + + case 655431: + return methodInfoConnectionUpdateSecretOk; + + case 1310730: + return methodInfoChannelOpen; + + case 1310731: + return methodInfoChannelOpenOk; + + case 1310740: + return methodInfoChannelFlow; + + case 1310741: + return methodInfoChannelFlowOk; + + case 1310760: + return methodInfoChannelClose; + + case 1310761: + return methodInfoChannelCloseOk; + + case 1966090: + return methodInfoAccessRequest; + + case 1966091: + return methodInfoAccessRequestOk; + + case 2621450: + return methodInfoExchangeDeclare; + + case 2621451: + return methodInfoExchangeDeclareOk; + + case 2621460: + return methodInfoExchangeDelete; + + case 2621461: + return methodInfoExchangeDeleteOk; + + case 2621470: + return methodInfoExchangeBind; + + case 2621471: + return methodInfoExchangeBindOk; + + case 2621480: + return methodInfoExchangeUnbind; + + case 2621491: + return methodInfoExchangeUnbindOk; + + case 3276810: + return methodInfoQueueDeclare; + + case 3276811: + return methodInfoQueueDeclareOk; + + case 3276820: + return methodInfoQueueBind; + + case 3276821: + return methodInfoQueueBindOk; + + case 3276830: + return methodInfoQueuePurge; + + case 3276831: + return methodInfoQueuePurgeOk; + + case 3276840: + return methodInfoQueueDelete; + + case 3276841: + return methodInfoQueueDeleteOk; + + case 3276850: + return methodInfoQueueUnbind; + + case 3276851: + return methodInfoQueueUnbindOk; + + case 5898250: + return methodInfoTxSelect; + + case 5898251: + return methodInfoTxSelectOk; + + case 5898260: + return methodInfoTxCommit; + + case 5898261: + return methodInfoTxCommitOk; + + case 5898270: + return methodInfoTxRollback; + + case 5898271: + return methodInfoTxRollbackOk; + + case 5570570: + return methodInfoConfirmSelect; + + case 5570571: + return methodInfoConfirmSelectOk; + + case 60: + return propertiesInfoBasicProperties; + + default: + throw new Error("Unknown class/method ID"); + } +}; + +module.exports.BasicQos = 3932170; + +var methodInfoBasicQos = module.exports.methodInfoBasicQos = { + id: 3932170, + classId: 60, + methodId: 10, + name: "BasicQos", + args: [ { + type: "long", + name: "prefetchSize", + default: 0 + }, { + type: "short", + name: "prefetchCount", + default: 0 + }, { + type: "bit", + name: "global", + default: !1 + } ] +}; + +module.exports.BasicQosOk = 3932171; + +var methodInfoBasicQosOk = module.exports.methodInfoBasicQosOk = { + id: 3932171, + classId: 60, + methodId: 11, + name: "BasicQosOk", + args: [] +}; + +module.exports.BasicConsume = 3932180; + +var methodInfoBasicConsume = module.exports.methodInfoBasicConsume = { + id: 3932180, + classId: 60, + methodId: 20, + name: "BasicConsume", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "shortstr", + name: "consumerTag", + default: "" + }, { + type: "bit", + name: "noLocal", + default: !1 + }, { + type: "bit", + name: "noAck", + default: !1 + }, { + type: "bit", + name: "exclusive", + default: !1 + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.BasicConsumeOk = 3932181; + +var methodInfoBasicConsumeOk = module.exports.methodInfoBasicConsumeOk = { + id: 3932181, + classId: 60, + methodId: 21, + name: "BasicConsumeOk", + args: [ { + type: "shortstr", + name: "consumerTag" + } ] +}; + +module.exports.BasicCancel = 3932190; + +var methodInfoBasicCancel = module.exports.methodInfoBasicCancel = { + id: 3932190, + classId: 60, + methodId: 30, + name: "BasicCancel", + args: [ { + type: "shortstr", + name: "consumerTag" + }, { + type: "bit", + name: "nowait", + default: !1 + } ] +}; + +module.exports.BasicCancelOk = 3932191; + +var methodInfoBasicCancelOk = module.exports.methodInfoBasicCancelOk = { + id: 3932191, + classId: 60, + methodId: 31, + name: "BasicCancelOk", + args: [ { + type: "shortstr", + name: "consumerTag" + } ] +}; + +module.exports.BasicPublish = 3932200; + +var methodInfoBasicPublish = module.exports.methodInfoBasicPublish = { + id: 3932200, + classId: 60, + methodId: 40, + name: "BasicPublish", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "exchange", + default: "" + }, { + type: "shortstr", + name: "routingKey", + default: "" + }, { + type: "bit", + name: "mandatory", + default: !1 + }, { + type: "bit", + name: "immediate", + default: !1 + } ] +}; + +module.exports.BasicReturn = 3932210; + +var methodInfoBasicReturn = module.exports.methodInfoBasicReturn = { + id: 3932210, + classId: 60, + methodId: 50, + name: "BasicReturn", + args: [ { + type: "short", + name: "replyCode" + }, { + type: "shortstr", + name: "replyText", + default: "" + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "routingKey" + } ] +}; + +module.exports.BasicDeliver = 3932220; + +var methodInfoBasicDeliver = module.exports.methodInfoBasicDeliver = { + id: 3932220, + classId: 60, + methodId: 60, + name: "BasicDeliver", + args: [ { + type: "shortstr", + name: "consumerTag" + }, { + type: "longlong", + name: "deliveryTag" + }, { + type: "bit", + name: "redelivered", + default: !1 + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "routingKey" + } ] +}; + +module.exports.BasicGet = 3932230; + +var methodInfoBasicGet = module.exports.methodInfoBasicGet = { + id: 3932230, + classId: 60, + methodId: 70, + name: "BasicGet", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "bit", + name: "noAck", + default: !1 + } ] +}; + +module.exports.BasicGetOk = 3932231; + +var methodInfoBasicGetOk = module.exports.methodInfoBasicGetOk = { + id: 3932231, + classId: 60, + methodId: 71, + name: "BasicGetOk", + args: [ { + type: "longlong", + name: "deliveryTag" + }, { + type: "bit", + name: "redelivered", + default: !1 + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "routingKey" + }, { + type: "long", + name: "messageCount" + } ] +}; + +module.exports.BasicGetEmpty = 3932232; + +var methodInfoBasicGetEmpty = module.exports.methodInfoBasicGetEmpty = { + id: 3932232, + classId: 60, + methodId: 72, + name: "BasicGetEmpty", + args: [ { + type: "shortstr", + name: "clusterId", + default: "" + } ] +}; + +module.exports.BasicAck = 3932240; + +var methodInfoBasicAck = module.exports.methodInfoBasicAck = { + id: 3932240, + classId: 60, + methodId: 80, + name: "BasicAck", + args: [ { + type: "longlong", + name: "deliveryTag", + default: 0 + }, { + type: "bit", + name: "multiple", + default: !1 + } ] +}; + +module.exports.BasicReject = 3932250; + +var methodInfoBasicReject = module.exports.methodInfoBasicReject = { + id: 3932250, + classId: 60, + methodId: 90, + name: "BasicReject", + args: [ { + type: "longlong", + name: "deliveryTag" + }, { + type: "bit", + name: "requeue", + default: !0 + } ] +}; + +module.exports.BasicRecoverAsync = 3932260; + +var methodInfoBasicRecoverAsync = module.exports.methodInfoBasicRecoverAsync = { + id: 3932260, + classId: 60, + methodId: 100, + name: "BasicRecoverAsync", + args: [ { + type: "bit", + name: "requeue", + default: !1 + } ] +}; + +module.exports.BasicRecover = 3932270; + +var methodInfoBasicRecover = module.exports.methodInfoBasicRecover = { + id: 3932270, + classId: 60, + methodId: 110, + name: "BasicRecover", + args: [ { + type: "bit", + name: "requeue", + default: !1 + } ] +}; + +module.exports.BasicRecoverOk = 3932271; + +var methodInfoBasicRecoverOk = module.exports.methodInfoBasicRecoverOk = { + id: 3932271, + classId: 60, + methodId: 111, + name: "BasicRecoverOk", + args: [] +}; + +module.exports.BasicNack = 3932280; + +var methodInfoBasicNack = module.exports.methodInfoBasicNack = { + id: 3932280, + classId: 60, + methodId: 120, + name: "BasicNack", + args: [ { + type: "longlong", + name: "deliveryTag", + default: 0 + }, { + type: "bit", + name: "multiple", + default: !1 + }, { + type: "bit", + name: "requeue", + default: !0 + } ] +}; + +module.exports.ConnectionStart = 655370; + +var methodInfoConnectionStart = module.exports.methodInfoConnectionStart = { + id: 655370, + classId: 10, + methodId: 10, + name: "ConnectionStart", + args: [ { + type: "octet", + name: "versionMajor", + default: 0 + }, { + type: "octet", + name: "versionMinor", + default: 9 + }, { + type: "table", + name: "serverProperties" + }, { + type: "longstr", + name: "mechanisms", + default: "PLAIN" + }, { + type: "longstr", + name: "locales", + default: "en_US" + } ] +}; + +module.exports.ConnectionStartOk = 655371; + +var methodInfoConnectionStartOk = module.exports.methodInfoConnectionStartOk = { + id: 655371, + classId: 10, + methodId: 11, + name: "ConnectionStartOk", + args: [ { + type: "table", + name: "clientProperties" + }, { + type: "shortstr", + name: "mechanism", + default: "PLAIN" + }, { + type: "longstr", + name: "response" + }, { + type: "shortstr", + name: "locale", + default: "en_US" + } ] +}; + +module.exports.ConnectionSecure = 655380; + +var methodInfoConnectionSecure = module.exports.methodInfoConnectionSecure = { + id: 655380, + classId: 10, + methodId: 20, + name: "ConnectionSecure", + args: [ { + type: "longstr", + name: "challenge" + } ] +}; + +module.exports.ConnectionSecureOk = 655381; + +var methodInfoConnectionSecureOk = module.exports.methodInfoConnectionSecureOk = { + id: 655381, + classId: 10, + methodId: 21, + name: "ConnectionSecureOk", + args: [ { + type: "longstr", + name: "response" + } ] +}; + +module.exports.ConnectionTune = 655390; + +var methodInfoConnectionTune = module.exports.methodInfoConnectionTune = { + id: 655390, + classId: 10, + methodId: 30, + name: "ConnectionTune", + args: [ { + type: "short", + name: "channelMax", + default: 0 + }, { + type: "long", + name: "frameMax", + default: 0 + }, { + type: "short", + name: "heartbeat", + default: 0 + } ] +}; + +module.exports.ConnectionTuneOk = 655391; + +var methodInfoConnectionTuneOk = module.exports.methodInfoConnectionTuneOk = { + id: 655391, + classId: 10, + methodId: 31, + name: "ConnectionTuneOk", + args: [ { + type: "short", + name: "channelMax", + default: 0 + }, { + type: "long", + name: "frameMax", + default: 0 + }, { + type: "short", + name: "heartbeat", + default: 0 + } ] +}; + +module.exports.ConnectionOpen = 655400; + +var methodInfoConnectionOpen = module.exports.methodInfoConnectionOpen = { + id: 655400, + classId: 10, + methodId: 40, + name: "ConnectionOpen", + args: [ { + type: "shortstr", + name: "virtualHost", + default: "/" + }, { + type: "shortstr", + name: "capabilities", + default: "" + }, { + type: "bit", + name: "insist", + default: !1 + } ] +}; + +module.exports.ConnectionOpenOk = 655401; + +var methodInfoConnectionOpenOk = module.exports.methodInfoConnectionOpenOk = { + id: 655401, + classId: 10, + methodId: 41, + name: "ConnectionOpenOk", + args: [ { + type: "shortstr", + name: "knownHosts", + default: "" + } ] +}; + +module.exports.ConnectionClose = 655410; + +var methodInfoConnectionClose = module.exports.methodInfoConnectionClose = { + id: 655410, + classId: 10, + methodId: 50, + name: "ConnectionClose", + args: [ { + type: "short", + name: "replyCode" + }, { + type: "shortstr", + name: "replyText", + default: "" + }, { + type: "short", + name: "classId" + }, { + type: "short", + name: "methodId" + } ] +}; + +module.exports.ConnectionCloseOk = 655411; + +var methodInfoConnectionCloseOk = module.exports.methodInfoConnectionCloseOk = { + id: 655411, + classId: 10, + methodId: 51, + name: "ConnectionCloseOk", + args: [] +}; + +module.exports.ConnectionBlocked = 655420; + +var methodInfoConnectionBlocked = module.exports.methodInfoConnectionBlocked = { + id: 655420, + classId: 10, + methodId: 60, + name: "ConnectionBlocked", + args: [ { + type: "shortstr", + name: "reason", + default: "" + } ] +}; + +module.exports.ConnectionUnblocked = 655421; + +var methodInfoConnectionUnblocked = module.exports.methodInfoConnectionUnblocked = { + id: 655421, + classId: 10, + methodId: 61, + name: "ConnectionUnblocked", + args: [] +}; + +module.exports.ConnectionUpdateSecret = 655430; + +var methodInfoConnectionUpdateSecret = module.exports.methodInfoConnectionUpdateSecret = { + id: 655430, + classId: 10, + methodId: 70, + name: "ConnectionUpdateSecret", + args: [ { + type: "longstr", + name: "newSecret" + }, { + type: "shortstr", + name: "reason" + } ] +}; + +module.exports.ConnectionUpdateSecretOk = 655431; + +var methodInfoConnectionUpdateSecretOk = module.exports.methodInfoConnectionUpdateSecretOk = { + id: 655431, + classId: 10, + methodId: 71, + name: "ConnectionUpdateSecretOk", + args: [] +}; + +module.exports.ChannelOpen = 1310730; + +var methodInfoChannelOpen = module.exports.methodInfoChannelOpen = { + id: 1310730, + classId: 20, + methodId: 10, + name: "ChannelOpen", + args: [ { + type: "shortstr", + name: "outOfBand", + default: "" + } ] +}; + +module.exports.ChannelOpenOk = 1310731; + +var methodInfoChannelOpenOk = module.exports.methodInfoChannelOpenOk = { + id: 1310731, + classId: 20, + methodId: 11, + name: "ChannelOpenOk", + args: [ { + type: "longstr", + name: "channelId", + default: "" + } ] +}; + +module.exports.ChannelFlow = 1310740; + +var methodInfoChannelFlow = module.exports.methodInfoChannelFlow = { + id: 1310740, + classId: 20, + methodId: 20, + name: "ChannelFlow", + args: [ { + type: "bit", + name: "active" + } ] +}; + +module.exports.ChannelFlowOk = 1310741; + +var methodInfoChannelFlowOk = module.exports.methodInfoChannelFlowOk = { + id: 1310741, + classId: 20, + methodId: 21, + name: "ChannelFlowOk", + args: [ { + type: "bit", + name: "active" + } ] +}; + +module.exports.ChannelClose = 1310760; + +var methodInfoChannelClose = module.exports.methodInfoChannelClose = { + id: 1310760, + classId: 20, + methodId: 40, + name: "ChannelClose", + args: [ { + type: "short", + name: "replyCode" + }, { + type: "shortstr", + name: "replyText", + default: "" + }, { + type: "short", + name: "classId" + }, { + type: "short", + name: "methodId" + } ] +}; + +module.exports.ChannelCloseOk = 1310761; + +var methodInfoChannelCloseOk = module.exports.methodInfoChannelCloseOk = { + id: 1310761, + classId: 20, + methodId: 41, + name: "ChannelCloseOk", + args: [] +}; + +module.exports.AccessRequest = 1966090; + +var methodInfoAccessRequest = module.exports.methodInfoAccessRequest = { + id: 1966090, + classId: 30, + methodId: 10, + name: "AccessRequest", + args: [ { + type: "shortstr", + name: "realm", + default: "/data" + }, { + type: "bit", + name: "exclusive", + default: !1 + }, { + type: "bit", + name: "passive", + default: !0 + }, { + type: "bit", + name: "active", + default: !0 + }, { + type: "bit", + name: "write", + default: !0 + }, { + type: "bit", + name: "read", + default: !0 + } ] +}; + +module.exports.AccessRequestOk = 1966091; + +var methodInfoAccessRequestOk = module.exports.methodInfoAccessRequestOk = { + id: 1966091, + classId: 30, + methodId: 11, + name: "AccessRequestOk", + args: [ { + type: "short", + name: "ticket", + default: 1 + } ] +}; + +module.exports.ExchangeDeclare = 2621450; + +var methodInfoExchangeDeclare = module.exports.methodInfoExchangeDeclare = { + id: 2621450, + classId: 40, + methodId: 10, + name: "ExchangeDeclare", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "type", + default: "direct" + }, { + type: "bit", + name: "passive", + default: !1 + }, { + type: "bit", + name: "durable", + default: !1 + }, { + type: "bit", + name: "autoDelete", + default: !1 + }, { + type: "bit", + name: "internal", + default: !1 + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.ExchangeDeclareOk = 2621451; + +var methodInfoExchangeDeclareOk = module.exports.methodInfoExchangeDeclareOk = { + id: 2621451, + classId: 40, + methodId: 11, + name: "ExchangeDeclareOk", + args: [] +}; + +module.exports.ExchangeDelete = 2621460; + +var methodInfoExchangeDelete = module.exports.methodInfoExchangeDelete = { + id: 2621460, + classId: 40, + methodId: 20, + name: "ExchangeDelete", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "exchange" + }, { + type: "bit", + name: "ifUnused", + default: !1 + }, { + type: "bit", + name: "nowait", + default: !1 + } ] +}; + +module.exports.ExchangeDeleteOk = 2621461; + +var methodInfoExchangeDeleteOk = module.exports.methodInfoExchangeDeleteOk = { + id: 2621461, + classId: 40, + methodId: 21, + name: "ExchangeDeleteOk", + args: [] +}; + +module.exports.ExchangeBind = 2621470; + +var methodInfoExchangeBind = module.exports.methodInfoExchangeBind = { + id: 2621470, + classId: 40, + methodId: 30, + name: "ExchangeBind", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "destination" + }, { + type: "shortstr", + name: "source" + }, { + type: "shortstr", + name: "routingKey", + default: "" + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.ExchangeBindOk = 2621471; + +var methodInfoExchangeBindOk = module.exports.methodInfoExchangeBindOk = { + id: 2621471, + classId: 40, + methodId: 31, + name: "ExchangeBindOk", + args: [] +}; + +module.exports.ExchangeUnbind = 2621480; + +var methodInfoExchangeUnbind = module.exports.methodInfoExchangeUnbind = { + id: 2621480, + classId: 40, + methodId: 40, + name: "ExchangeUnbind", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "destination" + }, { + type: "shortstr", + name: "source" + }, { + type: "shortstr", + name: "routingKey", + default: "" + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.ExchangeUnbindOk = 2621491; + +var methodInfoExchangeUnbindOk = module.exports.methodInfoExchangeUnbindOk = { + id: 2621491, + classId: 40, + methodId: 51, + name: "ExchangeUnbindOk", + args: [] +}; + +module.exports.QueueDeclare = 3276810; + +var methodInfoQueueDeclare = module.exports.methodInfoQueueDeclare = { + id: 3276810, + classId: 50, + methodId: 10, + name: "QueueDeclare", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "bit", + name: "passive", + default: !1 + }, { + type: "bit", + name: "durable", + default: !1 + }, { + type: "bit", + name: "exclusive", + default: !1 + }, { + type: "bit", + name: "autoDelete", + default: !1 + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.QueueDeclareOk = 3276811; + +var methodInfoQueueDeclareOk = module.exports.methodInfoQueueDeclareOk = { + id: 3276811, + classId: 50, + methodId: 11, + name: "QueueDeclareOk", + args: [ { + type: "shortstr", + name: "queue" + }, { + type: "long", + name: "messageCount" + }, { + type: "long", + name: "consumerCount" + } ] +}; + +module.exports.QueueBind = 3276820; + +var methodInfoQueueBind = module.exports.methodInfoQueueBind = { + id: 3276820, + classId: 50, + methodId: 20, + name: "QueueBind", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "routingKey", + default: "" + }, { + type: "bit", + name: "nowait", + default: !1 + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.QueueBindOk = 3276821; + +var methodInfoQueueBindOk = module.exports.methodInfoQueueBindOk = { + id: 3276821, + classId: 50, + methodId: 21, + name: "QueueBindOk", + args: [] +}; + +module.exports.QueuePurge = 3276830; + +var methodInfoQueuePurge = module.exports.methodInfoQueuePurge = { + id: 3276830, + classId: 50, + methodId: 30, + name: "QueuePurge", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "bit", + name: "nowait", + default: !1 + } ] +}; + +module.exports.QueuePurgeOk = 3276831; + +var methodInfoQueuePurgeOk = module.exports.methodInfoQueuePurgeOk = { + id: 3276831, + classId: 50, + methodId: 31, + name: "QueuePurgeOk", + args: [ { + type: "long", + name: "messageCount" + } ] +}; + +module.exports.QueueDelete = 3276840; + +var methodInfoQueueDelete = module.exports.methodInfoQueueDelete = { + id: 3276840, + classId: 50, + methodId: 40, + name: "QueueDelete", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "bit", + name: "ifUnused", + default: !1 + }, { + type: "bit", + name: "ifEmpty", + default: !1 + }, { + type: "bit", + name: "nowait", + default: !1 + } ] +}; + +module.exports.QueueDeleteOk = 3276841; + +var methodInfoQueueDeleteOk = module.exports.methodInfoQueueDeleteOk = { + id: 3276841, + classId: 50, + methodId: 41, + name: "QueueDeleteOk", + args: [ { + type: "long", + name: "messageCount" + } ] +}; + +module.exports.QueueUnbind = 3276850; + +var methodInfoQueueUnbind = module.exports.methodInfoQueueUnbind = { + id: 3276850, + classId: 50, + methodId: 50, + name: "QueueUnbind", + args: [ { + type: "short", + name: "ticket", + default: 0 + }, { + type: "shortstr", + name: "queue", + default: "" + }, { + type: "shortstr", + name: "exchange" + }, { + type: "shortstr", + name: "routingKey", + default: "" + }, { + type: "table", + name: "arguments", + default: {} + } ] +}; + +module.exports.QueueUnbindOk = 3276851; + +var methodInfoQueueUnbindOk = module.exports.methodInfoQueueUnbindOk = { + id: 3276851, + classId: 50, + methodId: 51, + name: "QueueUnbindOk", + args: [] +}; + +module.exports.TxSelect = 5898250; + +var methodInfoTxSelect = module.exports.methodInfoTxSelect = { + id: 5898250, + classId: 90, + methodId: 10, + name: "TxSelect", + args: [] +}; + +module.exports.TxSelectOk = 5898251; + +var methodInfoTxSelectOk = module.exports.methodInfoTxSelectOk = { + id: 5898251, + classId: 90, + methodId: 11, + name: "TxSelectOk", + args: [] +}; + +module.exports.TxCommit = 5898260; + +var methodInfoTxCommit = module.exports.methodInfoTxCommit = { + id: 5898260, + classId: 90, + methodId: 20, + name: "TxCommit", + args: [] +}; + +module.exports.TxCommitOk = 5898261; + +var methodInfoTxCommitOk = module.exports.methodInfoTxCommitOk = { + id: 5898261, + classId: 90, + methodId: 21, + name: "TxCommitOk", + args: [] +}; + +module.exports.TxRollback = 5898270; + +var methodInfoTxRollback = module.exports.methodInfoTxRollback = { + id: 5898270, + classId: 90, + methodId: 30, + name: "TxRollback", + args: [] +}; + +module.exports.TxRollbackOk = 5898271; + +var methodInfoTxRollbackOk = module.exports.methodInfoTxRollbackOk = { + id: 5898271, + classId: 90, + methodId: 31, + name: "TxRollbackOk", + args: [] +}; + +module.exports.ConfirmSelect = 5570570; + +var methodInfoConfirmSelect = module.exports.methodInfoConfirmSelect = { + id: 5570570, + classId: 85, + methodId: 10, + name: "ConfirmSelect", + args: [ { + type: "bit", + name: "nowait", + default: !1 + } ] +}; + +module.exports.ConfirmSelectOk = 5570571; + +var methodInfoConfirmSelectOk = module.exports.methodInfoConfirmSelectOk = { + id: 5570571, + classId: 85, + methodId: 11, + name: "ConfirmSelectOk", + args: [] +}; + +module.exports.BasicProperties = 60; + +var propertiesInfoBasicProperties = module.exports.propertiesInfoBasicProperties = { + id: 60, + name: "BasicProperties", + args: [ { + type: "shortstr", + name: "contentType" + }, { + type: "shortstr", + name: "contentEncoding" + }, { + type: "table", + name: "headers" + }, { + type: "octet", + name: "deliveryMode" + }, { + type: "octet", + name: "priority" + }, { + type: "shortstr", + name: "correlationId" + }, { + type: "shortstr", + name: "replyTo" + }, { + type: "shortstr", + name: "expiration" + }, { + type: "shortstr", + name: "messageId" + }, { + type: "timestamp", + name: "timestamp" + }, { + type: "shortstr", + name: "type" + }, { + type: "shortstr", + name: "userId" + }, { + type: "shortstr", + name: "appId" + }, { + type: "shortstr", + name: "clusterId" + } ] +}; \ No newline at end of file From 368074a5382f6091216c9350b01871fb7a5c3a72 Mon Sep 17 00:00:00 2001 From: Stephen Cresswell <229672+cressie176@users.noreply.github.com> Date: Thu, 11 Apr 2024 21:14:04 +0100 Subject: [PATCH 2/2] Nolonger need prepare --- package.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/package.json b/package.json index 841a5b09..e610a680 100644 --- a/package.json +++ b/package.json @@ -24,8 +24,7 @@ "uglify-js": "2.8.x" }, "scripts": { - "test": "make test", - "prepare": "make" + "test": "make test" }, "keywords": [ "AMQP",