examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPInvalidFrameException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPInvalidFrameException extends AMQPRuntimeException
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPLogicException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPLogicException extends \LogicException implements AMQPExceptionInterface
+{
+
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPNoDataException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+/**
+ * Used mostly in non-blocking methods when no data is ready for processing.
+ */
+class AMQPNoDataException extends AMQPRuntimeException
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPNotImplementedException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPNotImplementedException extends AMQPRuntimeException
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPOutOfBoundsException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPOutOfBoundsException extends \OutOfBoundsException implements AMQPExceptionInterface
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPOutOfRangeException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPOutOfRangeException extends \OutOfRangeException implements AMQPExceptionInterface
+{
+
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPProtocolChannelException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPProtocolChannelException extends AMQPProtocolException
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPProtocolException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPProtocolException extends \Exception implements AMQPExceptionInterface
+{
+    /** @var int */
+    public $amqp_reply_code;
+
+    /** @var string */
+    public $amqp_reply_text;
+
+    /** @var int[] */
+    public $amqp_method_sig;
+
+    /** @var array */
+    public $args;
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param int[] $method_sig
+     */
+    public function __construct($reply_code, $reply_text, $method_sig)
+    {
+        parent::__construct($reply_text, $reply_code);
+
+        $this->amqp_reply_code = $reply_code; // redundant, but kept for BC
+        $this->amqp_reply_text = $reply_text; // redundant, but kept for BC
+        $this->amqp_method_sig = $method_sig;
+
+        $this->args = array($reply_code, $reply_text, $method_sig);
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPRuntimeException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPRuntimeException extends \RuntimeException implements AMQPExceptionInterface
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPSocketException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPSocketException extends AMQPRuntimeException
+{
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exception/AMQPTimeoutException.php

+<?php
+
+namespace PhpAmqpLib\Exception;
+
+class AMQPTimeoutException extends \RuntimeException implements AMQPExceptionInterface
+{
+    /**
+     * @var int|float|null
+     */
+    private $timeout;
+
+    public function __construct($message = '', $timeout = 0, $code = 0, \Exception $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+        $this->timeout = $timeout;
+    }
+
+    /**
+     * @param int|float|null $timeout
+     * @param int $code
+     * @return self
+     */
+    public static function writeTimeout($timeout, $code = 0)
+    {
+        return new self('Error sending data. Connection timed out.', $timeout, $code);
+    }
+
+    /**
+     * @return int|float|null
+     */
+    public function getTimeout()
+    {
+        return $this->timeout;
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Exchange/AMQPExchangeType.php

+<?php
+
+namespace PhpAmqpLib\Exchange;
+
+final class AMQPExchangeType
+{
+    const DIRECT = 'direct';
+    const FANOUT = 'fanout';
+    const TOPIC = 'topic';
+    const HEADERS = 'headers';
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/Assert.php

+<?php
+
+namespace PhpAmqpLib\Helper;
+
+use InvalidArgumentException;
+
+class Assert
+{
+    /**
+     * @param mixed $argument
+     * @throws \InvalidArgumentException
+     */
+    public static function isCallable($argument)
+    {
+        if (!is_callable($argument)) {
+            throw new InvalidArgumentException(sprintf(
+                'Given argument "%s" should be callable. %s type was given.',
+                $argument,
+                gettype($argument)
+            ));
+        }
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/BigInteger.php

+<?php
+
+namespace PhpAmqpLib\Helper;
+
+if (class_exists('phpseclib\Math\BigInteger')) {
+    class BigInteger extends \phpseclib\Math\BigInteger
+    {
+    }
+} elseif (class_exists('phpseclib3\Math\BigInteger')) {
+    class BigInteger extends \phpseclib3\Math\BigInteger
+    {
+    }
+} else {
+    throw new \RuntimeException('Cannot find supported phpseclib/phpseclib library');
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/DebugHelper.php

+<?php
+
+namespace PhpAmqpLib\Helper;
+
+use PhpAmqpLib\Wire\Constants;
+
+class DebugHelper
+{
+    /**
+     * @var bool
+     */
+    protected $debug;
+
+    /**
+     * @var resource
+     */
+    protected $debug_output;
+
+    /**
+     * @var Constants
+     */
+    protected $constants;
+
+    /**
+     * @param Constants $constants
+     */
+    public function __construct(Constants $constants)
+    {
+        $this->debug = defined('AMQP_DEBUG') ? AMQP_DEBUG : false;
+        if (defined('AMQP_DEBUG_OUTPUT')) {
+            $this->debug_output = AMQP_DEBUG_OUTPUT;
+        } else {
+            $this->debug_output = fopen('php://output', 'wb');
+        }
+        $this->constants = $constants;
+    }
+
+    /**
+     * @param string $msg
+     */
+    public function debug_msg($msg)
+    {
+        if ($this->debug) {
+            $this->print_msg($msg);
+        }
+    }
+
+    /**
+     * @param array|null $allowed_methods
+     */
+    public function debug_allowed_methods($allowed_methods)
+    {
+        if ($this->debug) {
+            if ($allowed_methods) {
+                $msg = 'waiting for ' . implode(', ', $allowed_methods);
+            } else {
+                $msg = 'waiting for any method';
+            }
+            $this->debug_msg($msg);
+        }
+    }
+
+    /**
+     * @param string|array $method_sig
+     */
+    public function debug_method_signature1($method_sig)
+    {
+        $this->debug_method_signature('< %s:', $method_sig);
+    }
+
+    /**
+     * @param string $msg
+     * @param string|array $method_sig
+     */
+    public function debug_method_signature($msg, $method_sig)
+    {
+        if ($this->debug) {
+            $constants = $this->constants;
+            $methods = $constants::$GLOBAL_METHOD_NAMES;
+            $key = MiscHelper::methodSig($method_sig);
+            $this->debug_msg(sprintf($msg . ': %s', $key, $methods[$key]));
+        }
+    }
+
+    /**
+     * @param string $data
+     */
+    public function debug_hexdump($data)
+    {
+        if ($this->debug) {
+            $this->debug_msg(
+                sprintf(
+                    '< [hex]: %s%s',
+                    PHP_EOL,
+                    MiscHelper::hexdump($data, $htmloutput = false, $uppercase = true, $return = true)
+                )
+            );
+        }
+    }
+
+    /**
+     * @param int $version_major
+     * @param int $version_minor
+     * @param array $server_properties
+     * @param array $mechanisms
+     * @param array $locales
+     */
+    public function debug_connection_start($version_major, $version_minor, $server_properties, $mechanisms, $locales)
+    {
+        if ($this->debug) {
+            $this->debug_msg(
+                sprintf(
+                    'Start from server, version: %d.%d, properties: %s, mechanisms: %s, locales: %s',
+                    $version_major,
+                    $version_minor,
+                    MiscHelper::dump_table($server_properties),
+                    implode(', ', $mechanisms),
+                    implode(', ', $locales)
+                )
+            );
+        }
+    }
+
+    /**
+     * @param string $s
+     */
+    protected function print_msg($s)
+    {
+        fwrite($this->debug_output, $s . PHP_EOL);
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/MiscHelper.php

+<?php
+
+namespace PhpAmqpLib\Helper;
+
+class MiscHelper
+{
+    /**
+     * @param string|array $a
+     * @return string
+     */
+    public static function methodSig($a)
+    {
+        if (is_string($a)) {
+            return $a;
+        }
+
+        return sprintf('%d,%d', $a[0], $a[1]);
+    }
+
+    /**
+     * Gets a number (either int or float) and returns an array containing its integer part as first element and its
+     * decimal part mutliplied by 10^6. Useful for some PHP stream functions that need seconds and microseconds as
+     * different arguments
+     *
+     * @param int|float $number
+     * @return int[]
+     */
+    public static function splitSecondsMicroseconds($number)
+    {
+        return array((int)floor($number), (int)(fmod($number, 1) * 1000000));
+    }
+
+    /**
+     * View any string as a hexdump.
+     *
+     * This is most commonly used to view binary data from streams
+     * or sockets while debugging, but can be used to view any string
+     * with non-viewable characters.
+     *
+     * @version     1.3.2
+     * @author      Aidan Lister <aidan@php.net>
+     * @author      Peter Waller <iridum@php.net>
+     * @link        http://aidanlister.com/repos/v/function.hexdump.php
+     *
+     * @param string $data The string to be dumped
+     * @param bool $htmloutput Set to false for non-HTML output
+     * @param bool $uppercase Set to true for uppercase hex
+     * @param bool $return Set to true to return the dump
+     * @return string|null
+     */
+    public static function hexdump($data, $htmloutput = true, $uppercase = false, $return = false)
+    {
+        // Init
+        $hexi = '';
+        $ascii = '';
+        $dump = $htmloutput ? '<pre>' : '';
+        $offset = 0;
+        $len = mb_strlen($data, 'ASCII');
+
+        // Upper or lower case hexidecimal
+        $hexFormat = $uppercase ? 'X' : 'x';
+
+        // Iterate string
+        for ($i = $j = 0; $i < $len; $i++) {
+            // Convert to hexidecimal
+            // We must use concatenation here because the $hexFormat value
+            // is needed for sprintf() to parse the format
+            $hexi .= sprintf('%02' .  $hexFormat . ' ', ord($data[$i]));
+
+            // Replace non-viewable bytes with '.'
+            if (ord($data[$i]) >= 32) {
+                $ascii .= $htmloutput ? htmlentities($data[$i]) : $data[$i];
+            } else {
+                $ascii .= '.';
+            }
+
+            // Add extra column spacing
+            if ($j === 7) {
+                $hexi .= ' ';
+                $ascii .= ' ';
+            }
+
+            // Add row
+            if (++$j === 16 || $i === $len - 1) {
+                // Join the hexi / ascii output
+                // We must use concatenation here because the $hexFormat value
+                // is needed for sprintf() to parse the format
+                $dump .= sprintf('%04' . $hexFormat . '  %-49s  %s', $offset, $hexi, $ascii);
+
+                // Reset vars
+                $hexi = $ascii = '';
+                $offset += 16;
+                $j = 0;
+
+                // Add newline
+                if ($i !== $len - 1) {
+                    $dump .= PHP_EOL;
+                }
+            }
+        }
+
+        // Finish dump
+        $dump .= $htmloutput ? '</pre>' : '';
+        $dump .= PHP_EOL;
+
+        if ($return) {
+            return $dump;
+        }
+
+        echo $dump;
+
+        return null;
+    }
+
+    /**
+     * @param array $table
+     * @return string
+     */
+    public static function dump_table($table)
+    {
+        $tokens = array();
+        foreach ($table as $name => $value) {
+            switch ($value[0]) {
+                case 'D':
+                    $val = $value[1]->n . 'E' . $value[1]->e;
+                    break;
+                case 'F':
+                    $val = '(' . self::dump_table($value[1]) . ')';
+                    break;
+                case 'T':
+                    $val = date('Y-m-d H:i:s', $value[1]);
+                    break;
+                default:
+                    $val = $value[1];
+            }
+            $tokens[] = $name . '=' . $val;
+        }
+
+        return implode(', ', $tokens);
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/Protocol/MethodMap080.php

+<?php
+
+/* This file was autogenerated by spec/parser.php - Do not modify */
+
+namespace PhpAmqpLib\Helper\Protocol;
+
+class MethodMap080
+{
+    /**
+     * @var array
+     */
+    protected $method_map = array(
+        '10,10' => 'connection_start',
+        '10,11' => 'connection_start_ok',
+        '10,20' => 'connection_secure',
+        '10,21' => 'connection_secure_ok',
+        '10,30' => 'connection_tune',
+        '10,31' => 'connection_tune_ok',
+        '10,40' => 'connection_open',
+        '10,41' => 'connection_open_ok',
+        '10,50' => 'connection_redirect',
+        '10,60' => 'connection_close',
+        '10,61' => 'connection_close_ok',
+        '20,10' => 'channel_open',
+        '20,11' => 'channel_open_ok',
+        '20,20' => 'channel_flow',
+        '20,21' => 'channel_flow_ok',
+        '20,30' => 'channel_alert',
+        '20,40' => 'channel_close',
+        '20,41' => 'channel_close_ok',
+        '30,10' => 'access_request',
+        '30,11' => 'access_request_ok',
+        '40,10' => 'exchange_declare',
+        '40,11' => 'exchange_declare_ok',
+        '40,20' => 'exchange_delete',
+        '40,21' => 'exchange_delete_ok',
+        '50,10' => 'queue_declare',
+        '50,11' => 'queue_declare_ok',
+        '50,20' => 'queue_bind',
+        '50,21' => 'queue_bind_ok',
+        '50,30' => 'queue_purge',
+        '50,31' => 'queue_purge_ok',
+        '50,40' => 'queue_delete',
+        '50,41' => 'queue_delete_ok',
+        '50,50' => 'queue_unbind',
+        '50,51' => 'queue_unbind_ok',
+        '60,10' => 'basic_qos',
+        '60,11' => 'basic_qos_ok',
+        '60,20' => 'basic_consume',
+        '60,21' => 'basic_consume_ok',
+        '60,30' => 'basic_cancel',
+        '60,31' => 'basic_cancel_ok',
+        '60,40' => 'basic_publish',
+        '60,50' => 'basic_return',
+        '60,60' => 'basic_deliver',
+        '60,70' => 'basic_get',
+        '60,71' => 'basic_get_ok',
+        '60,72' => 'basic_get_empty',
+        '60,80' => 'basic_ack',
+        '60,90' => 'basic_reject',
+        '60,100' => 'basic_recover_async',
+        '60,110' => 'basic_recover',
+        '60,111' => 'basic_recover_ok',
+        '70,10' => 'file_qos',
+        '70,11' => 'file_qos_ok',
+        '70,20' => 'file_consume',
+        '70,21' => 'file_consume_ok',
+        '70,30' => 'file_cancel',
+        '70,31' => 'file_cancel_ok',
+        '70,40' => 'file_open',
+        '70,41' => 'file_open_ok',
+        '70,50' => 'file_stage',
+        '70,60' => 'file_publish',
+        '70,70' => 'file_return',
+        '70,80' => 'file_deliver',
+        '70,90' => 'file_ack',
+        '70,100' => 'file_reject',
+        '80,10' => 'stream_qos',
+        '80,11' => 'stream_qos_ok',
+        '80,20' => 'stream_consume',
+        '80,21' => 'stream_consume_ok',
+        '80,30' => 'stream_cancel',
+        '80,31' => 'stream_cancel_ok',
+        '80,40' => 'stream_publish',
+        '80,50' => 'stream_return',
+        '80,60' => 'stream_deliver',
+        '90,10' => 'tx_select',
+        '90,11' => 'tx_select_ok',
+        '90,20' => 'tx_commit',
+        '90,21' => 'tx_commit_ok',
+        '90,30' => 'tx_rollback',
+        '90,31' => 'tx_rollback_ok',
+        '100,10' => 'dtx_select',
+        '100,11' => 'dtx_select_ok',
+        '100,20' => 'dtx_start',
+        '100,21' => 'dtx_start_ok',
+        '110,10' => 'tunnel_request',
+        '120,10' => 'test_integer',
+        '120,11' => 'test_integer_ok',
+        '120,20' => 'test_string',
+        '120,21' => 'test_string_ok',
+        '120,30' => 'test_table',
+        '120,31' => 'test_table_ok',
+        '120,40' => 'test_content',
+        '120,41' => 'test_content_ok',
+    );
+
+    /**
+     * @var string $method_sig
+     * @return string
+     */
+    public function get_method($method_sig)
+    {
+        return $this->method_map[$method_sig];
+    }
+
+    /**
+     * @var string $method_sig
+     * @return bool
+     */
+    public function valid_method($method_sig)
+    {
+        return array_key_exists($method_sig, $this->method_map);
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/Protocol/MethodMap091.php

+<?php
+
+/* This file was autogenerated by spec/parser.php - Do not modify */
+
+namespace PhpAmqpLib\Helper\Protocol;
+
+class MethodMap091
+{
+    /**
+     * @var array
+     */
+    protected $method_map = array(
+        '10,10' => 'connection_start',
+        '10,11' => 'connection_start_ok',
+        '10,20' => 'connection_secure',
+        '10,21' => 'connection_secure_ok',
+        '10,30' => 'connection_tune',
+        '10,31' => 'connection_tune_ok',
+        '10,40' => 'connection_open',
+        '10,41' => 'connection_open_ok',
+        '10,50' => 'connection_close',
+        '10,51' => 'connection_close_ok',
+        '10,60' => 'connection_blocked',
+        '10,61' => 'connection_unblocked',
+        '20,10' => 'channel_open',
+        '20,11' => 'channel_open_ok',
+        '20,20' => 'channel_flow',
+        '20,21' => 'channel_flow_ok',
+        '20,40' => 'channel_close',
+        '20,41' => 'channel_close_ok',
+        '30,10' => 'access_request',
+        '30,11' => 'access_request_ok',
+        '40,10' => 'exchange_declare',
+        '40,11' => 'exchange_declare_ok',
+        '40,20' => 'exchange_delete',
+        '40,21' => 'exchange_delete_ok',
+        '40,30' => 'exchange_bind',
+        '40,31' => 'exchange_bind_ok',
+        '40,40' => 'exchange_unbind',
+        '40,51' => 'exchange_unbind_ok',
+        '50,10' => 'queue_declare',
+        '50,11' => 'queue_declare_ok',
+        '50,20' => 'queue_bind',
+        '50,21' => 'queue_bind_ok',
+        '50,30' => 'queue_purge',
+        '50,31' => 'queue_purge_ok',
+        '50,40' => 'queue_delete',
+        '50,41' => 'queue_delete_ok',
+        '50,50' => 'queue_unbind',
+        '50,51' => 'queue_unbind_ok',
+        '60,10' => 'basic_qos',
+        '60,11' => 'basic_qos_ok',
+        '60,20' => 'basic_consume',
+        '60,21' => 'basic_consume_ok',
+        '60,30' => 'basic_cancel_from_server',
+        '60,31' => 'basic_cancel_ok',
+        '60,40' => 'basic_publish',
+        '60,50' => 'basic_return',
+        '60,60' => 'basic_deliver',
+        '60,70' => 'basic_get',
+        '60,71' => 'basic_get_ok',
+        '60,72' => 'basic_get_empty',
+        '60,80' => 'basic_ack_from_server',
+        '60,90' => 'basic_reject',
+        '60,100' => 'basic_recover_async',
+        '60,110' => 'basic_recover',
+        '60,111' => 'basic_recover_ok',
+        '60,120' => 'basic_nack_from_server',
+        '90,10' => 'tx_select',
+        '90,11' => 'tx_select_ok',
+        '90,20' => 'tx_commit',
+        '90,21' => 'tx_commit_ok',
+        '90,30' => 'tx_rollback',
+        '90,31' => 'tx_rollback_ok',
+        '85,10' => 'confirm_select',
+        '85,11' => 'confirm_select_ok',
+    );
+
+    /**
+     * @var string $method_sig
+     * @return string
+     */
+    public function get_method($method_sig)
+    {
+        return $this->method_map[$method_sig];
+    }
+
+    /**
+     * @var string $method_sig
+     * @return bool
+     */
+    public function valid_method($method_sig)
+    {
+        return array_key_exists($method_sig, $this->method_map);
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/Protocol/Protocol080.php

+<?php
+
+/* This file was autogenerated by spec/parser.php - Do not modify */
+
+namespace PhpAmqpLib\Helper\Protocol;
+
+use PhpAmqpLib\Wire\AMQPWriter;
+use PhpAmqpLib\Wire\AMQPReader;
+
+class Protocol080
+{
+    /**
+     * @param int $version_major
+     * @param int $version_minor
+     * @param mixed $server_properties
+     * @param string $mechanisms
+     * @param string $locales
+     * @return array
+     */
+    public function connectionStart(
+        $version_major = 0,
+        $version_minor = 8,
+        $server_properties = [],
+        $mechanisms = 'PLAIN',
+        $locales = 'en_US'
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_octet($version_major);
+        $writer->write_octet($version_minor);
+        $writer->write_table(empty($server_properties) ? array() : $server_properties);
+        $writer->write_longstr($mechanisms);
+        $writer->write_longstr($locales);
+        return array(10, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionStartOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_table();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_longstr();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $challenge
+     * @return array
+     */
+    public function connectionSecure($challenge)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longstr($challenge);
+        return array(10, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionSecureOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longstr();
+        return $response;
+    }
+
+    /**
+     * @param int $channel_max
+     * @param int $frame_max
+     * @param int $heartbeat
+     * @return array
+     */
+    public function connectionTune($channel_max = 0, $frame_max = 0, $heartbeat = 0)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($channel_max);
+        $writer->write_long($frame_max);
+        $writer->write_short($heartbeat);
+        return array(10, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionTuneOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_short();
+        $response[] = $reader->read_long();
+        $response[] = $reader->read_short();
+        return $response;
+    }
+
+    /**
+     * @param string $virtual_host
+     * @param string $capabilities
+     * @param bool $insist
+     * @return array
+     */
+    public function connectionOpen($virtual_host = '/', $capabilities = '', $insist = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($virtual_host);
+        $writer->write_shortstr($capabilities);
+        $writer->write_bits(array($insist));
+        return array(10, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionOpenOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $host
+     * @param string $known_hosts
+     * @return array
+     */
+    public function connectionRedirect($host, $known_hosts = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($host);
+        $writer->write_shortstr($known_hosts);
+        return array(10, 50, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param int $class_id
+     * @param int $method_id
+     * @return array
+     */
+    public function connectionClose($reply_code, $reply_text, $class_id, $method_id)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_short($class_id);
+        $writer->write_short($method_id);
+        return array(10, 60, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionCloseOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $out_of_band
+     * @return array
+     */
+    public function channelOpen($out_of_band = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($out_of_band);
+        return array(20, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelOpenOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param bool $active
+     * @return array
+     */
+    public function channelFlow($active)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($active));
+        return array(20, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelFlowOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_bit();
+        return $response;
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $details
+     * @return array
+     */
+    public function channelAlert($reply_code, $reply_text = '', $details = array())
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_table(empty($details) ? array() : $details);
+        return array(20, 30, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param int $class_id
+     * @param int $method_id
+     * @return array
+     */
+    public function channelClose($reply_code, $reply_text, $class_id, $method_id)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_short($class_id);
+        $writer->write_short($method_id);
+        return array(20, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelCloseOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $realm
+     * @param bool $exclusive
+     * @param bool $passive
+     * @param bool $active
+     * @param bool $write
+     * @param bool $read
+     * @return array
+     */
+    public function accessRequest(
+        $realm = '/data',
+        $exclusive = false,
+        $passive = true,
+        $active = true,
+        $write = true,
+        $read = true
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($realm);
+        $writer->write_bits(array($exclusive, $passive, $active, $write, $read));
+        return array(30, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function accessRequestOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_short();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $type
+     * @param bool $passive
+     * @param bool $durable
+     * @param bool $auto_delete
+     * @param bool $internal
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function exchangeDeclare(
+        $ticket = 1,
+        $exchange = '',
+        $type = 'direct',
+        $passive = false,
+        $durable = false,
+        $auto_delete = false,
+        $internal = false,
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($type);
+        $writer->write_bits(array($passive, $durable, $auto_delete, $internal, $nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(40, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeDeclareOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param bool $if_unused
+     * @param bool $nowait
+     * @return array
+     */
+    public function exchangeDelete($ticket = 1, $exchange = '', $if_unused = false, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_bits(array($if_unused, $nowait));
+        return array(40, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeDeleteOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $passive
+     * @param bool $durable
+     * @param bool $exclusive
+     * @param bool $auto_delete
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueDeclare(
+        $ticket = 1,
+        $queue = '',
+        $passive = false,
+        $durable = false,
+        $exclusive = false,
+        $auto_delete = false,
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($passive, $durable, $exclusive, $auto_delete, $nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueDeclareOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_long();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueBind(
+        $ticket = 1,
+        $queue = '',
+        $exchange = '',
+        $routing_key = '',
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueBindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $nowait
+     * @return array
+     */
+    public function queuePurge($ticket = 1, $queue = '', $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($nowait));
+        return array(50, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queuePurgeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $if_unused
+     * @param bool $if_empty
+     * @param bool $nowait
+     * @return array
+     */
+    public function queueDelete($ticket = 1, $queue = '', $if_unused = false, $if_empty = false, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($if_unused, $if_empty, $nowait));
+        return array(50, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueDeleteOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $exchange
+     * @param string $routing_key
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueUnbind($ticket = 1, $queue = '', $exchange = '', $routing_key = '', $arguments = array())
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 50, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueUnbindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $prefetch_size
+     * @param int $prefetch_count
+     * @param bool $global
+     * @return array
+     */
+    public function basicQos($prefetch_size = 0, $prefetch_count = 0, $global = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_long($prefetch_size);
+        $writer->write_short($prefetch_count);
+        $writer->write_bits(array($global));
+        return array(60, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicQosOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $consumer_tag
+     * @param bool $no_local
+     * @param bool $no_ack
+     * @param bool $exclusive
+     * @param bool $nowait
+     * @return array
+     */
+    public function basicConsume(
+        $ticket = 1,
+        $queue = '',
+        $consumer_tag = '',
+        $no_local = false,
+        $no_ack = false,
+        $exclusive = false,
+        $nowait = false
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($no_local, $no_ack, $exclusive, $nowait));
+        return array(60, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicConsumeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param bool $nowait
+     * @return array
+     */
+    public function basicCancel($consumer_tag, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($nowait));
+        return array(60, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicCancelOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $mandatory
+     * @param bool $immediate
+     * @return array
+     */
+    public function basicPublish($ticket = 1, $exchange = '', $routing_key = '', $mandatory = false, $immediate = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($mandatory, $immediate));
+        return array(60, 40, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function basicReturn($reply_code, $reply_text, $exchange, $routing_key)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(60, 50, $writer);
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param int $delivery_tag
+     * @param bool $redelivered
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function basicDeliver($consumer_tag, $delivery_tag, $redelivered, $exchange, $routing_key)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($redelivered));
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(60, 60, $writer);
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $no_ack
+     * @return array
+     */
+    public function basicGet($ticket = 1, $queue = '', $no_ack = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($no_ack));
+        return array(60, 70, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicGetOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longlong();
+        $response[] = $reader->read_bit();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicGetEmpty(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $multiple
+     * @return array
+     */
+    public function basicAck($delivery_tag = 0, $multiple = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($multiple));
+        return array(60, 80, $writer);
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicReject($delivery_tag, $requeue = true)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($requeue));
+        return array(60, 90, $writer);
+    }
+
+    /**
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicRecoverAsync($requeue = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($requeue));
+        return array(60, 100, $writer);
+    }
+
+    /**
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicRecover($requeue = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($requeue));
+        return array(60, 110, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicRecoverOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $prefetch_size
+     * @param int $prefetch_count
+     * @param bool $global
+     * @return array
+     */
+    public function fileQos($prefetch_size = 0, $prefetch_count = 0, $global = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_long($prefetch_size);
+        $writer->write_short($prefetch_count);
+        $writer->write_bits(array($global));
+        return array(70, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function fileQosOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $consumer_tag
+     * @param bool $no_local
+     * @param bool $no_ack
+     * @param bool $exclusive
+     * @param bool $nowait
+     * @return array
+     */
+    public function fileConsume(
+        $ticket = 1,
+        $queue = '',
+        $consumer_tag = '',
+        $no_local = false,
+        $no_ack = false,
+        $exclusive = false,
+        $nowait = false
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($no_local, $no_ack, $exclusive, $nowait));
+        return array(70, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function fileConsumeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param bool $nowait
+     * @return array
+     */
+    public function fileCancel($consumer_tag, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($nowait));
+        return array(70, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function fileCancelOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $identifier
+     * @param int $content_size
+     * @return array
+     */
+    public function fileOpen($identifier, $content_size)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($identifier);
+        $writer->write_longlong($content_size);
+        return array(70, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function fileOpenOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longlong();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function fileStage()
+    {
+        $writer = new AMQPWriter();
+        return array(70, 50, $writer);
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $mandatory
+     * @param bool $immediate
+     * @param string $identifier
+     * @return array
+     */
+    public function filePublish(
+        $ticket = 1,
+        $exchange = '',
+        $routing_key = '',
+        $mandatory = false,
+        $immediate = false,
+        $identifier = ''
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($mandatory, $immediate));
+        $writer->write_shortstr($identifier);
+        return array(70, 60, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function fileReturn($reply_code = 200, $reply_text = '', $exchange = '', $routing_key = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(70, 70, $writer);
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param int $delivery_tag
+     * @param bool $redelivered
+     * @param string $exchange
+     * @param string $routing_key
+     * @param string $identifier
+     * @return array
+     */
+    public function fileDeliver(
+        $consumer_tag,
+        $delivery_tag,
+        $redelivered,
+        $exchange,
+        $routing_key,
+        $identifier
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($redelivered));
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_shortstr($identifier);
+        return array(70, 80, $writer);
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $multiple
+     * @return array
+     */
+    public function fileAck($delivery_tag = 0, $multiple = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($multiple));
+        return array(70, 90, $writer);
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $requeue
+     * @return array
+     */
+    public function fileReject($delivery_tag, $requeue = true)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($requeue));
+        return array(70, 100, $writer);
+    }
+
+    /**
+     * @param int $prefetch_size
+     * @param int $prefetch_count
+     * @param int $consume_rate
+     * @param bool $global
+     * @return array
+     */
+    public function streamQos($prefetch_size = 0, $prefetch_count = 0, $consume_rate = 0, $global = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_long($prefetch_size);
+        $writer->write_short($prefetch_count);
+        $writer->write_long($consume_rate);
+        $writer->write_bits(array($global));
+        return array(80, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function streamQosOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $consumer_tag
+     * @param bool $no_local
+     * @param bool $exclusive
+     * @param bool $nowait
+     * @return array
+     */
+    public function streamConsume(
+        $ticket = 1,
+        $queue = '',
+        $consumer_tag = '',
+        $no_local = false,
+        $exclusive = false,
+        $nowait = false
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($no_local, $exclusive, $nowait));
+        return array(80, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function streamConsumeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param bool $nowait
+     * @return array
+     */
+    public function streamCancel($consumer_tag, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($nowait));
+        return array(80, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function streamCancelOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $mandatory
+     * @param bool $immediate
+     * @return array
+     */
+    public function streamPublish(
+        $ticket = 1,
+        $exchange = '',
+        $routing_key = '',
+        $mandatory = false,
+        $immediate = false
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($mandatory, $immediate));
+        return array(80, 40, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function streamReturn($reply_code = 200, $reply_text = '', $exchange = '', $routing_key = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(80, 50, $writer);
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param int $delivery_tag
+     * @param string $exchange
+     * @param string $queue
+     * @return array
+     */
+    public function streamDeliver($consumer_tag, $delivery_tag, $exchange, $queue)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_longlong($delivery_tag);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($queue);
+        return array(80, 60, $writer);
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txSelect()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txSelectOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txCommit()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txCommitOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txRollback()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txRollbackOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function dtxSelect()
+    {
+        $writer = new AMQPWriter();
+        return array(100, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function dtxSelectOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $dtx_identifier
+     * @return array
+     */
+    public function dtxStart($dtx_identifier)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($dtx_identifier);
+        return array(100, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function dtxStartOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $meta_data
+     * @return array
+     */
+    public function tunnelRequest($meta_data)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_table(empty($meta_data) ? array() : $meta_data);
+        return array(110, 10, $writer);
+    }
+
+    /**
+     * @param int $integer_1
+     * @param int $integer_2
+     * @param int $integer_3
+     * @param int $integer_4
+     * @param int $operation
+     * @return array
+     */
+    public function testInteger($integer_1, $integer_2, $integer_3, $integer_4, $operation)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_octet($integer_1);
+        $writer->write_short($integer_2);
+        $writer->write_long($integer_3);
+        $writer->write_longlong($integer_4);
+        $writer->write_octet($operation);
+        return array(120, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function testIntegerOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longlong();
+        return $response;
+    }
+
+    /**
+     * @param string $string_1
+     * @param string $string_2
+     * @param int $operation
+     * @return array
+     */
+    public function testString($string_1, $string_2, $operation)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($string_1);
+        $writer->write_longstr($string_2);
+        $writer->write_octet($operation);
+        return array(120, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function testStringOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longstr();
+        return $response;
+    }
+
+    /**
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $table
+     * @param int $integer_op
+     * @param int $string_op
+     * @return array
+     */
+    public function testTable($table, $integer_op, $string_op)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_table(empty($table) ? array() : $table);
+        $writer->write_octet($integer_op);
+        $writer->write_octet($string_op);
+        return array(120, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function testTableOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longlong();
+        $response[] = $reader->read_longstr();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function testContent()
+    {
+        $writer = new AMQPWriter();
+        return array(120, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function testContentOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+}

examples/rabbitmq/vendor/php-amqplib/php-amqplib/PhpAmqpLib/Helper/Protocol/Protocol091.php

+<?php
+
+/* This file was autogenerated by spec/parser.php - Do not modify */
+
+namespace PhpAmqpLib\Helper\Protocol;
+
+use PhpAmqpLib\Wire\AMQPWriter;
+use PhpAmqpLib\Wire\AMQPReader;
+
+class Protocol091
+{
+    /**
+     * @param int $version_major
+     * @param int $version_minor
+     * @param mixed $server_properties
+     * @param string $mechanisms
+     * @param string $locales
+     * @return array
+     */
+    public function connectionStart(
+        $version_major = 0,
+        $version_minor = 9,
+        $server_properties = [],
+        $mechanisms = 'PLAIN',
+        $locales = 'en_US'
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_octet($version_major);
+        $writer->write_octet($version_minor);
+        $writer->write_table(empty($server_properties) ? array() : $server_properties);
+        $writer->write_longstr($mechanisms);
+        $writer->write_longstr($locales);
+        return array(10, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionStartOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_table();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_longstr();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $challenge
+     * @return array
+     */
+    public function connectionSecure($challenge)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longstr($challenge);
+        return array(10, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionSecureOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longstr();
+        return $response;
+    }
+
+    /**
+     * @param int $channel_max
+     * @param int $frame_max
+     * @param int $heartbeat
+     * @return array
+     */
+    public function connectionTune($channel_max = 0, $frame_max = 0, $heartbeat = 0)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($channel_max);
+        $writer->write_long($frame_max);
+        $writer->write_short($heartbeat);
+        return array(10, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionTuneOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_short();
+        $response[] = $reader->read_long();
+        $response[] = $reader->read_short();
+        return $response;
+    }
+
+    /**
+     * @param string $virtual_host
+     * @param string $capabilities
+     * @param bool $insist
+     * @return array
+     */
+    public function connectionOpen($virtual_host = '/', $capabilities = '', $insist = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($virtual_host);
+        $writer->write_shortstr($capabilities);
+        $writer->write_bits(array($insist));
+        return array(10, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionOpenOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param int $class_id
+     * @param int $method_id
+     * @return array
+     */
+    public function connectionClose($reply_code, $reply_text, $class_id, $method_id)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_short($class_id);
+        $writer->write_short($method_id);
+        return array(10, 50, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionCloseOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $reason
+     * @return array
+     */
+    public function connectionBlocked($reason = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($reason);
+        return array(10, 60, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function connectionUnblocked(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $out_of_band
+     * @return array
+     */
+    public function channelOpen($out_of_band = '')
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($out_of_band);
+        return array(20, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelOpenOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longstr();
+        return $response;
+    }
+
+    /**
+     * @param bool $active
+     * @return array
+     */
+    public function channelFlow($active)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($active));
+        return array(20, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelFlowOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_bit();
+        return $response;
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param int $class_id
+     * @param int $method_id
+     * @return array
+     */
+    public function channelClose($reply_code, $reply_text, $class_id, $method_id)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_short($class_id);
+        $writer->write_short($method_id);
+        return array(20, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function channelCloseOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param string $realm
+     * @param bool $exclusive
+     * @param bool $passive
+     * @param bool $active
+     * @param bool $write
+     * @param bool $read
+     * @return array
+     */
+    public function accessRequest(
+        $realm = '/data',
+        $exclusive = false,
+        $passive = true,
+        $active = true,
+        $write = true,
+        $read = true
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($realm);
+        $writer->write_bits(array($exclusive, $passive, $active, $write, $read));
+        return array(30, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function accessRequestOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_short();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $type
+     * @param bool $passive
+     * @param bool $durable
+     * @param bool $auto_delete
+     * @param bool $internal
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function exchangeDeclare(
+        $ticket = 0,
+        $exchange = '',
+        $type = 'direct',
+        $passive = false,
+        $durable = false,
+        $auto_delete = false,
+        $internal = false,
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($type);
+        $writer->write_bits(array($passive, $durable, $auto_delete, $internal, $nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(40, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeDeclareOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param bool $if_unused
+     * @param bool $nowait
+     * @return array
+     */
+    public function exchangeDelete($ticket = 0, $exchange = '', $if_unused = false, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_bits(array($if_unused, $nowait));
+        return array(40, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeDeleteOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $destination
+     * @param string $source
+     * @param string $routing_key
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function exchangeBind(
+        $ticket = 0,
+        $destination = '',
+        $source = '',
+        $routing_key = '',
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($destination);
+        $writer->write_shortstr($source);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(40, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeBindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $destination
+     * @param string $source
+     * @param string $routing_key
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function exchangeUnbind(
+        $ticket = 0,
+        $destination = '',
+        $source = '',
+        $routing_key = '',
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($destination);
+        $writer->write_shortstr($source);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(40, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function exchangeUnbindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $passive
+     * @param bool $durable
+     * @param bool $exclusive
+     * @param bool $auto_delete
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueDeclare(
+        $ticket = 0,
+        $queue = '',
+        $passive = false,
+        $durable = false,
+        $exclusive = false,
+        $auto_delete = false,
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($passive, $durable, $exclusive, $auto_delete, $nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueDeclareOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_long();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueBind(
+        $ticket = 0,
+        $queue = '',
+        $exchange = '',
+        $routing_key = '',
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueBindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $nowait
+     * @return array
+     */
+    public function queuePurge($ticket = 0, $queue = '', $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($nowait));
+        return array(50, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queuePurgeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $if_unused
+     * @param bool $if_empty
+     * @param bool $nowait
+     * @return array
+     */
+    public function queueDelete($ticket = 0, $queue = '', $if_unused = false, $if_empty = false, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($if_unused, $if_empty, $nowait));
+        return array(50, 40, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueDeleteOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $exchange
+     * @param string $routing_key
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function queueUnbind($ticket = 0, $queue = '', $exchange = '', $routing_key = '', $arguments = array())
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(50, 50, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function queueUnbindOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $prefetch_size
+     * @param int $prefetch_count
+     * @param bool $global
+     * @return array
+     */
+    public function basicQos($prefetch_size = 0, $prefetch_count = 0, $global = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_long($prefetch_size);
+        $writer->write_short($prefetch_count);
+        $writer->write_bits(array($global));
+        return array(60, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicQosOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param string $consumer_tag
+     * @param bool $no_local
+     * @param bool $no_ack
+     * @param bool $exclusive
+     * @param bool $nowait
+     * @param \PhpAmqpLib\Wire\AMQPTable|array $arguments
+     * @return array
+     */
+    public function basicConsume(
+        $ticket = 0,
+        $queue = '',
+        $consumer_tag = '',
+        $no_local = false,
+        $no_ack = false,
+        $exclusive = false,
+        $nowait = false,
+        $arguments = array()
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($no_local, $no_ack, $exclusive, $nowait));
+        $writer->write_table(empty($arguments) ? array() : $arguments);
+        return array(60, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicConsumeOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param bool $nowait
+     * @return array
+     */
+    public function basicCancel($consumer_tag, $nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_bits(array($nowait));
+        return array(60, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicCancelOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $exchange
+     * @param string $routing_key
+     * @param bool $mandatory
+     * @param bool $immediate
+     * @return array
+     */
+    public function basicPublish(
+        $ticket = 0,
+        $exchange = '',
+        $routing_key = '',
+        $mandatory = false,
+        $immediate = false
+    ) {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        $writer->write_bits(array($mandatory, $immediate));
+        return array(60, 40, $writer);
+    }
+
+    /**
+     * @param int $reply_code
+     * @param string $reply_text
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function basicReturn($reply_code, $reply_text, $exchange, $routing_key)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($reply_code);
+        $writer->write_shortstr($reply_text);
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(60, 50, $writer);
+    }
+
+    /**
+     * @param string $consumer_tag
+     * @param int $delivery_tag
+     * @param bool $redelivered
+     * @param string $exchange
+     * @param string $routing_key
+     * @return array
+     */
+    public function basicDeliver($consumer_tag, $delivery_tag, $redelivered, $exchange, $routing_key)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_shortstr($consumer_tag);
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($redelivered));
+        $writer->write_shortstr($exchange);
+        $writer->write_shortstr($routing_key);
+        return array(60, 60, $writer);
+    }
+
+    /**
+     * @param int $ticket
+     * @param string $queue
+     * @param bool $no_ack
+     * @return array
+     */
+    public function basicGet($ticket = 0, $queue = '', $no_ack = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_short($ticket);
+        $writer->write_shortstr($queue);
+        $writer->write_bits(array($no_ack));
+        return array(60, 70, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicGetOk(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_longlong();
+        $response[] = $reader->read_bit();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_shortstr();
+        $response[] = $reader->read_long();
+        return $response;
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicGetEmpty(AMQPReader $reader)
+    {
+        $response = array();
+        $response[] = $reader->read_shortstr();
+        return $response;
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $multiple
+     * @return array
+     */
+    public function basicAck($delivery_tag = 0, $multiple = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($multiple));
+        return array(60, 80, $writer);
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicReject($delivery_tag, $requeue = true)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($requeue));
+        return array(60, 90, $writer);
+    }
+
+    /**
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicRecoverAsync($requeue = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($requeue));
+        return array(60, 100, $writer);
+    }
+
+    /**
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicRecover($requeue = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($requeue));
+        return array(60, 110, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function basicRecoverOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param int $delivery_tag
+     * @param bool $multiple
+     * @param bool $requeue
+     * @return array
+     */
+    public function basicNack($delivery_tag = 0, $multiple = false, $requeue = true)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_longlong($delivery_tag);
+        $writer->write_bits(array($multiple, $requeue));
+        return array(60, 120, $writer);
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txSelect()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txSelectOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txCommit()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 20, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txCommitOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+
+     * @return array
+     */
+    public function txRollback()
+    {
+        $writer = new AMQPWriter();
+        return array(90, 30, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function txRollbackOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+
+    /**
+     * @param bool $nowait
+     * @return array
+     */
+    public function confirmSelect($nowait = false)
+    {
+        $writer = new AMQPWriter();
+        $writer->write_bits(array($nowait));
+        return array(85, 10, $writer);
+    }
+
+    /**
+     * @param AMQPReader $reader
+     * @return array
+     */
+    public static function confirmSelectOk(AMQPReader $reader)
+    {
+        $response = array();
+        return $response;
+    }
+}