Apply RabbitMQ support patch by Michael Barker, on bug #457089.

svn path=/branches/messaging-2008/mcs/; revision=120957

37 files changed, 27672 insertions, 210 deletions

diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ.dll.sources b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ.dll.sources
index 21a917c3dec..193d4813a17 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ.dll.sources
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ.dll.sources
@@ -4,5 +4,6 @@
 ./Mono.Messaging.RabbitMQ/MessageFactory.cs
 ./Mono.Messaging.RabbitMQ/RabbitMQMessageEnumerator.cs
 ./Mono.Messaging.RabbitMQ/RabbitMQMessageQueue.cs
+./Mono.Messaging.RabbitMQ/RabbitMQMessageQueueTransaction.cs
 ./Mono.Messaging.RabbitMQ/RabbitMQMessagingProvider.cs
 
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/ChangeLog b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/ChangeLog
index f3f3d3d1c25..3604f63ebf9 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/ChangeLog
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/ChangeLog
@@ -1,3 +1,25 @@
+2008-12-07  Michael Barker  <mike@middlesoft.co.uk>
+
+	* RabbitMQMessageQueue.cs:  Throw MessageUnavailableException when there are
+	no messages.
+
+2008-11-23  Michael Barker  <mike@middlesoft.co.uk>
+
+	* RabbitMQMessageQueue.cs:  Added selector support for ReceiveBy{Id,CorrelationId}
+	and support for MessageQueueTransactionType, currently only None and Single
+	are supported.  Added PeekBy{Id,CorrelationId} methods.
+	* MessageFactory.cs:  Made read/write message methods non-static and requires
+	the MessagingProvider as a constructor parameter.
+
+2008-11-02  Michael Barker  <mike@middlesoft.co.uk>
+
+	* RabbitMQMessageQueueTransaction.cs: New, Handles transactional delivery
+	by maintaining the transaction context.
+	* RabbitMQMessageQueue.cs: Added support for transactions, purging, deleting
+	and refactored some of the methods to improve the code reuse.
+	* RabbitMQMessagingProvider.cs:  Added methods for queue deletion and
+	creating transactions.
+
 2008-10-26  Michael Barker  <mike@middlesoft.co.uk>
 
 	* MessageFactory.cs:  Support all properties defined in the 1.1 version of
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/MessageFactory.cs b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/MessageFactory.cs
index aa0f852bf0d..e48da2ca2ba 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/MessageFactory.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/MessageFactory.cs
@@ -67,10 +67,18 @@ namespace Mono.Messaging.RabbitMQ {
 		private static readonly string USE_AUTHENTICATION_KEY = "UseAuthentication";
 		private static readonly string USE_DEAD_LETTER_QUEUE_KEY = "UseDeadLetterQueue";
 		private static readonly string USE_ENCRYPTION_KEY = "UseEncryption";
+		private static readonly string TRANSACTION_ID_KEY = "TrandactionId";
 		
 		private static readonly int PERSISTENT_DELIVERY_MODE = 2;
 		
-		public static IMessageBuilder WriteMessage (IModel ch, IMessage msg)
+		private readonly RabbitMQMessagingProvider provider;
+		
+		public MessageFactory (RabbitMQMessagingProvider provider)
+		{
+			this.provider = provider;
+		}
+		
+		public IMessageBuilder WriteMessage (IModel ch, IMessage msg)
 		{
 			BasicMessageBuilder mb = new BasicMessageBuilder (ch);
 			mb.Properties.MessageId = msg.Id;
@@ -103,6 +111,7 @@ namespace Mono.Messaging.RabbitMQ {
 			headers[SENDER_CERTIFICATE_KEY] = msg.SenderCertificate;
 			headers[TIME_TO_BE_RECEIVED_KEY] = msg.TimeToBeReceived.Ticks;
 			headers[TIME_TO_REACH_QUEUE_KEY] = msg.TimeToReachQueue.Ticks;
+			SetValue (headers, TRANSACTION_ID_KEY, msg.TransactionId);
 			headers[USE_AUTHENTICATION_KEY] = msg.UseAuthentication;
 			headers[USE_DEAD_LETTER_QUEUE_KEY] = msg.UseDeadLetterQueue;
 			headers[USE_ENCRYPTION_KEY] = msg.UseEncryption;
@@ -122,7 +131,7 @@ namespace Mono.Messaging.RabbitMQ {
 				headers[name] = val;
 		}
 		
-		public static IMessage ReadMessage (QueueReference destination, BasicDeliverEventArgs result)
+		public IMessage ReadMessage (QueueReference destination, BasicDeliverEventArgs result)
 		{
 			/*
 			if (destination == null)
@@ -133,22 +142,24 @@ namespace Mono.Messaging.RabbitMQ {
 			MessageBase msg = new MessageBase ();
 			Stream s = new MemoryStream ();
 			s.Write (result.Body, 0, result.Body.Length);
-			Console.WriteLine ("Body.Length Out {0}", result.Body.Length);
 			DateTime arrivedTime = DateTime.Now;
 			IDictionary headers = result.BasicProperties.Headers;
 			long senderVersion = (long) headers[SENDER_VERSION_KEY];
 			string sourceMachine = GetString (headers, SOURCE_MACHINE_KEY);
 			DateTime sentTime = AmqpTimestampToDateTime (result.BasicProperties.Timestamp);
+			string transactionId = GetString (headers, TRANSACTION_ID_KEY);
 			msg.SetDeliveryInfo (Acknowledgment.None,
 			                     arrivedTime,
-			                     new RabbitMQMessageQueue (destination),
+			                     new RabbitMQMessageQueue (provider,
+			                                               destination,
+			                                               true),
 			                     result.BasicProperties.MessageId,
 			                     MessageType.Normal,
 			                     new byte[0],
 			                     senderVersion,
 			                     sentTime,
 			                     sourceMachine,
-			                     null);
+			                     transactionId);
 			msg.CorrelationId = result.BasicProperties.CorrelationId;
 			msg.BodyStream = s;
 			msg.BodyType = (int) result.BasicProperties.Headers[BODY_TYPE_KEY];
@@ -156,8 +167,12 @@ namespace Mono.Messaging.RabbitMQ {
 				Enum.ToObject (typeof (AcknowledgeTypes), 
 				               headers[ACKNOWLEDGE_TYPE_KEY]);
 			string adminQueuePath = GetString (headers, ADMINISTRATION_QUEUE_KEY);
-			if (adminQueuePath != null)
-				msg.AdministrationQueue = new RabbitMQMessageQueue (QueueReference.Parse (adminQueuePath));
+			if (adminQueuePath != null) {
+				QueueReference qRef = QueueReference.Parse (adminQueuePath);
+				msg.AdministrationQueue = new RabbitMQMessageQueue (provider,
+				                                                    qRef,
+				                                                    true);
+			}
 			msg.AppSpecific = (int) headers[APP_SPECIFIC_KEY];
 			msg.AuthenticationProviderName = GetString (headers, AUTHENTICATION_PROVIDER_NAME_KEY);
 			msg.AuthenticationProviderType = (CryptographicProviderType) Enum.ToObject (typeof (CryptographicProviderType), headers[AUTHENTICATION_PROVIDER_TYPE_KEY]);
@@ -172,7 +187,7 @@ namespace Mono.Messaging.RabbitMQ {
 			msg.Priority = (MessagePriority) Enum.ToObject (typeof (MessagePriority), result.BasicProperties.Priority);
 			msg.Recoverable = result.BasicProperties.DeliveryMode == PERSISTENT_DELIVERY_MODE;
 			if (result.BasicProperties.ReplyTo != null)
-				msg.ResponseQueue = new RabbitMQMessageQueue (QueueReference.Parse (result.BasicProperties.ReplyTo));
+				msg.ResponseQueue = new RabbitMQMessageQueue (provider, QueueReference.Parse (result.BasicProperties.ReplyTo), true);
 			msg.SenderCertificate = (byte[]) headers[SENDER_CERTIFICATE_KEY];
 			msg.TimeToBeReceived = new TimeSpan((long) headers[TIME_TO_BE_RECEIVED_KEY]);
 			msg.TimeToReachQueue = new TimeSpan((long) headers[TIME_TO_REACH_QUEUE_KEY]);
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageEnumerator.cs b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageEnumerator.cs
index 33d6236426d..30d0ea3542b 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageEnumerator.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageEnumerator.cs
@@ -43,13 +43,16 @@ namespace Mono.Messaging.RabbitMQ {
 
 	public class RabbitMQMessageEnumerator : IMessageEnumerator {
 		
+		private readonly MessageFactory helper;
 		private readonly QueueReference qRef;
 		private IConnection cn = null;
 		private BasicDeliverEventArgs current = null;
 		private IModel model = null;
 		private Subscription subscription = null;
 		
-		public RabbitMQMessageEnumerator (QueueReference qRef) {
+		public RabbitMQMessageEnumerator (MessageFactory helper,
+		                                  QueueReference qRef) {
+			this.helper = helper;
 			this.qRef = qRef;
 		}
 		
@@ -140,9 +143,19 @@ namespace Mono.Messaging.RabbitMQ {
 			return msg;
 		}
 		
+		public IMessage RemoveCurrent (IMessageQueueTransaction transaction)
+		{
+			throw new NotSupportedException ("Unable to remove messages within a transaction");
+		}
+		
+		public IMessage RemoveCurrent (MessageQueueTransactionType transactionType)
+		{
+			throw new NotSupportedException ("Unable to remove messages within a transaction");
+		}
+		
 		private IMessage CreateMessage (BasicDeliverEventArgs result)
 		{
-			return MessageFactory.ReadMessage (qRef, result);
+			return helper.ReadMessage (qRef, result);
 		}
 
 	}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueue.cs b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueue.cs
index eacc97675d2..b83eaca15a9 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueue.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueue.cs
@@ -55,14 +55,33 @@ namespace Mono.Messaging.RabbitMQ {
 		private ISynchronizeInvoke synchronizingObject = null;
 		private bool useJournalQueue = false;
 		private QueueReference qRef = QueueReference.DEFAULT;
+		private readonly RabbitMQMessagingProvider provider;
+		private readonly MessageFactory helper;
+		private readonly string realm;
+		private readonly bool transactional;
 		
-		public RabbitMQMessageQueue ()
+		public RabbitMQMessageQueue (RabbitMQMessagingProvider provider,
+		                             bool transactional)
+			: this (provider, QueueReference.DEFAULT, transactional)
 		{
 		}
 		
-		public RabbitMQMessageQueue (QueueReference qRef)
+		public RabbitMQMessageQueue (RabbitMQMessagingProvider provider,
+		                             QueueReference qRef, 
+		                             bool transactional)
+			: this (provider, "/data", qRef, transactional)
 		{
+		}
+		
+		public RabbitMQMessageQueue (RabbitMQMessagingProvider provider,
+		                             string realm, QueueReference qRef,
+		                             bool transactional)
+		{
+			this.provider = provider;
+			this.helper = new MessageFactory (provider);
+			this.realm = realm;
 			this.qRef = qRef;
+			this.transactional = transactional;
 		}
 
 		public bool Authenticate {
@@ -130,7 +149,7 @@ namespace Mono.Messaging.RabbitMQ {
 		}
 		
 		public bool Transactional {
-			get { throw new NotImplementedException (); }
+			get { return transactional; }
 		}
 		
 		public bool UseJournalQueue {
@@ -155,23 +174,43 @@ namespace Mono.Messaging.RabbitMQ {
 			return version;
 		}
 		
-		private void SetDeliveryInfo (IMessage msg, IConnection cn)
+		private void SetDeliveryInfo (IMessage msg, long senderVersion,
+		                              string transactionId)
 		{
-			long senderVersion = GetVersion (cn);
 			msg.SetDeliveryInfo (Acknowledgment.None,
 			                     DateTime.MinValue,
 			                     this,
-			                     Guid.NewGuid ().ToString (),
+			                     Guid.NewGuid ().ToString () + "\\0",
 			                     MessageType.Normal,
 			                     new byte[0],
 			                     senderVersion,
 			                     DateTime.UtcNow,
 			                     null,
-			                     null);
+			                     transactionId);
 		}
 		
+		public void Close ()
+		{
+			// No-op (Queue are currently stateless)
+		}
+		
+		public static void Delete (string realm, QueueReference qRef)
+		{
+			ConnectionFactory cf = new ConnectionFactory ();
+			
+			using (IConnection cn = cf.CreateConnection (qRef.Host)) {
+				using (IModel model = cn.CreateModel ()) {
+					ushort ticket = model.AccessRequest (realm);
+					model.QueueDelete (ticket, qRef.Queue, false, false, false);
+				}
+			}
+		}			
+		
 		public void Send (IMessage msg)
 		{
+			if (QRef == QueueReference.DEFAULT)
+				throw new MonoMessagingException ("Path has not been specified");
+			
 			if (msg.BodyStream == null)
 				throw new ArgumentException ("Message is not serialized properly");
 		
@@ -179,17 +218,9 @@ namespace Mono.Messaging.RabbitMQ {
 			
 			try {
 				using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+					SetDeliveryInfo (msg, GetVersion (cn), null);
 					using (IModel ch = cn.CreateModel ()) {
-						ushort ticket = ch.AccessRequest ("/data");
-						string finalName = ch.QueueDeclare (ticket, QRef.Queue, false);
-						SetDeliveryInfo (msg, cn);
-						IMessageBuilder mb = MessageFactory.WriteMessage (ch, msg);
-						Console.WriteLine("Body.Length In {0}", mb.GetContentBody ().Length);
-												
-						ch.BasicPublish (ticket, "",
-						                 finalName,
-						                 (IBasicProperties) mb.GetContentHeader(),
-						                 mb.GetContentBody ());
+						Send (ch, msg);
 					}
 				}
 			} catch (BrokerUnreachableException e) {
@@ -197,32 +228,525 @@ namespace Mono.Messaging.RabbitMQ {
 			}
 		}
 		
-		public IMessage Receive ()
+		public void Send (IMessage msg, IMessageQueueTransaction transaction)
+		{
+			if (QRef == QueueReference.DEFAULT)
+				throw new MonoMessagingException ("Path has not been specified");
+			
+			if (msg.BodyStream == null)
+				throw new ArgumentException ("Message is not serialized properly");
+			
+			RabbitMQMessageQueueTransaction tx = (RabbitMQMessageQueueTransaction) transaction;
+			
+			tx.RunSend (SendInContext, msg);
+		}
+		
+		public void Send (IMessage msg, MessageQueueTransactionType transactionType)
+		{
+			switch (transactionType) {
+			case MessageQueueTransactionType.Single:
+				using (IMessageQueueTransaction tx = provider.CreateMessageQueueTransaction ()) {
+					try {
+						Send (msg, tx);
+						tx.Commit ();
+					} catch (Exception e) {
+						tx.Abort ();
+						throw new MonoMessagingException(e.Message, e);
+					}
+				}
+				break;
+
+			case MessageQueueTransactionType.None:
+				Send (msg);
+				break;
+
+			case MessageQueueTransactionType.Automatic:
+				throw new NotSupportedException("Automatic transaction types not supported");
+			}
+		}
+		
+		private void SendInContext (ref string host, ref IConnection cn, 
+		                            ref IModel model, IMessage msg, string txId)
+		{
+			if (host == null)
+				host = QRef.Host;
+			else if (host != QRef.Host)
+				throw new MonoMessagingException ("Transactions can not span multiple hosts");
+			
+			if (cn == null) {
+				ConnectionFactory cf = new ConnectionFactory ();
+				cn = cf.CreateConnection (host);
+			}
+			
+			if (model == null) {
+				model = cn.CreateModel ();
+				model.TxSelect ();
+			}
+			
+			SetDeliveryInfo (msg, GetVersion (cn), txId);
+			Send (model, msg);
+		}
+		
+		private void Send (IModel model, IMessage msg)
+		{
+			ushort ticket = model.AccessRequest ("/data");
+			string finalName = model.QueueDeclare (ticket, QRef.Queue, true);
+			IMessageBuilder mb = helper.WriteMessage (model, msg);
+
+			model.BasicPublish (ticket, "", finalName,
+			                    (IBasicProperties) mb.GetContentHeader(),
+			                    mb.GetContentBody ());
+		}
+		
+		public void Purge ()
+		{
+			ConnectionFactory cf = new ConnectionFactory ();
+
+			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+				using (IModel model = cn.CreateModel ()) {
+					ushort ticket = model.AccessRequest (realm);
+					model.QueuePurge (ticket, QRef.Queue, false);
+				}
+			}
+		}
+		
+		public IMessage Peek ()
 		{
 			ConnectionFactory cf = new ConnectionFactory ();
 
 			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
 				using (IModel ch = cn.CreateModel ()) {
-					ushort ticket = ch.AccessRequest ("/data");
-					string finalName = ch.QueueDeclare (ticket, QRef.Queue, false);
+					return Receive (ch, -1, false);
+				}
+			}
+		}
+		
+		public IMessage Peek (TimeSpan timeout)
+		{
+			return Run (Peeker (timeout));
+//			ConnectionFactory cf = new ConnectionFactory ();
+//
+//			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+//				using (IModel ch = cn.CreateModel ()) {
+//					if (timeout == TimeSpan.MaxValue) {
+//						return Receive (ch, -1, false);
+//					} else {
+//						return Receive (ch, (int) timeout.TotalMilliseconds, false);
+//					}
+//				}
+//			}
+		}
+		
+		public IMessage PeekById (string id)
+		{
+			return Run (Peeker (ById (id)));
+//			ConnectionFactory cf = new ConnectionFactory ();
+//
+//			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+//				using (IModel ch = cn.CreateModel ()) {
+//					return Receive (ch, 500, true, new IdMatcher (id).MatchById);
+//				}
+//			}
+		}
+
+		public IMessage PeekById (string id, TimeSpan timeout)
+		{
+			return Run (Peeker (timeout, ById (id)));
+		}
+		
+		public IMessage PeekByCorrelationId (string id)
+		{
+			return Run (Peeker (ByCorrelationId (id)));
+//			ConnectionFactory cf = new ConnectionFactory ();
+//
+//			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+//				using (IModel ch = cn.CreateModel ()) {
+//					return Receive (ch, 500, false, 
+//					                new CorrelationIdMatcher (id).MatchById);
+//				}
+//			}
+		}
+
+		public IMessage PeekByCorrelationId (string id, TimeSpan timeout)
+		{
+			return Run (Peeker (timeout, ByCorrelationId (id)));
+		}
+		
+		public IMessage Receive ()
+		{
+			return Run (Receiver ());
+		}
+		
+		public IMessage Receive (TimeSpan timeout)
+		{
+			return Run (Receiver (timeout));
+		}
+		
+		public IMessage Receive (TimeSpan timeout,
+		                         IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver (timeout));
+		}
+		
+		public IMessage Receive (TimeSpan timeout,
+		                         MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver (timeout));
+		}
+		
+		public IMessage Receive (IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver());
+		}
+		
+		public IMessage Receive (MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver ());
+		}		
+
+		public IMessage ReceiveById (string id)
+		{
+			return Run (Receiver (ById (id)));
+		}
+
+		public IMessage ReceiveById (string id, TimeSpan timeout)
+		{
+			return Run (Receiver (timeout, ById (id)));
+		}
+		
+		public IMessage ReceiveById (string id,
+		                             IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver (ById (id)));
+		}
+		
+		public IMessage ReceiveById (string id,
+		                             MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver (ById (id)));
+		}
+		
+		public IMessage ReceiveById (string id, TimeSpan timeout,
+		                             IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver (timeout, ById (id)));
+		}
+		
+		public IMessage ReceiveById (string id, TimeSpan timeout,
+		                             MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver (timeout, ById (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id)
+		{
+			return Run (Receiver (ByCorrelationId (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout)
+		{
+			return Run (Receiver (timeout, ByCorrelationId (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id,
+		                                        IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver (ByCorrelationId (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id,
+		                                        MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver (ByCorrelationId (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
+		                                        IMessageQueueTransaction transaction)
+		{
+			return Run (transaction, Receiver (timeout, ByCorrelationId (id)));
+		}
+		
+		public IMessage ReceiveByCorrelationId (string id, TimeSpan timeout,
+		                                        MessageQueueTransactionType transactionType)
+		{
+			return Run (transactionType, Receiver (timeout, ByCorrelationId (id)));
+		}
+		
+		public IMessageEnumerator GetMessageEnumerator ()
+		{
+			return new RabbitMQMessageEnumerator (helper, QRef);
+		}
+		
+		private IMessage Run (MessageQueueTransactionType transactionType,
+		                      TxReceiver.DoReceive r)
+		{
+			switch (transactionType) {
+			case MessageQueueTransactionType.Single:
+				using (RabbitMQMessageQueueTransaction tx = GetTx ()) {
+					bool success = false;
+					try {
+						IMessage msg = Run (tx, r);
+						tx.Commit ();
+						success = true;
+						return msg;
+					} finally {
+						if (!success)
+							tx.Abort ();
+					}
+				}
+
+			case MessageQueueTransactionType.None:
+				return Run (r);
+
+			default:
+				throw new NotSupportedException(transactionType + " not supported");
+			}
+		}		
+
+		private IMessage Run (IMessageQueueTransaction transaction,
+		                      TxReceiver.DoReceive r)
+		{
+			TxReceiver txr = new TxReceiver (this, r);
+			RabbitMQMessageQueueTransaction tx = 
+				(RabbitMQMessageQueueTransaction) transaction;
+			return tx.RunReceive (txr.ReceiveInContext);			
+		}
+		
+		private IMessage Run (TxReceiver.DoReceive r)
+		{
+			ConnectionFactory cf = new ConnectionFactory ();
+			using (IConnection cn = cf.CreateConnection (QRef.Host)) {
+				using (IModel model = cn.CreateModel ()) {
+					return r (this, model);
+				}
+			}
+		}
+		
+		private IMessage ReceiveInContext (ref string host, ref IConnection cn, 
+		                                   ref IModel model, string txId)
+		{
+			if (host == null)
+				host = QRef.Host;
+			else if (host != QRef.Host)
+				throw new MonoMessagingException ("Transactions can not span multiple hosts");
+			
+			if (cn == null) {
+				ConnectionFactory cf = new ConnectionFactory ();
+				cn = cf.CreateConnection (host);
+			}
+			
+			if (model == null) {
+				model = cn.CreateModel ();
+				model.TxSelect ();
+			}
+			
+			return Receive (model, -1, true);
+		}		
+
+		private class TxReceiver
+		{
+			private readonly DoReceive doReceive;
+			private readonly RabbitMQMessageQueue q;
+			
+			public TxReceiver(RabbitMQMessageQueue q, DoReceive doReceive) {
+				this.q = q;
+				this.doReceive = doReceive;
+			}
+			
+			public delegate IMessage DoReceive (RabbitMQMessageQueue q, IModel model);
+			
+			public IMessage ReceiveInContext (ref string host, ref IConnection cn, 
+			                                  ref IModel model, string txId)
+			{
+				if (host == null)
+					host = q.QRef.Host;
+				else if (host != q.QRef.Host)
+					throw new MonoMessagingException ("Transactions can not span multiple hosts");
+				
+				if (cn == null) {
+					ConnectionFactory cf = new ConnectionFactory ();
+					cn = cf.CreateConnection (host);
+				}
+				
+				if (model == null) {
+					model = cn.CreateModel ();
+					model.TxSelect ();
+				}
+				
+				return doReceive (q, model);
+			}
+		}
+		
+		private class DoReceiveWithTimeout
+		{
+			private readonly int timeout;
+			private readonly IsMatch matcher;
+			private readonly bool ack;
+			
+			public DoReceiveWithTimeout (int timeout, IsMatch matcher)
+				: this (timeout, matcher, true)
+			{
+			}
+			
+			public DoReceiveWithTimeout (int timeout, IsMatch matcher, bool ack)
+			{
+				if (matcher != null && timeout == -1)
+					this.timeout = 500;
+				else 
+					this.timeout = timeout;
+				this.matcher = matcher;
+				this.ack = ack;
+			}
+			
+			public IMessage DoReceive (RabbitMQMessageQueue q, IModel model)
+			{
+				if (matcher == null)
+					return q.Receive (model, timeout, ack);
+				else
+					return q.Receive (model, timeout, ack, matcher);
+			}
+		}
+		
+		private static TxReceiver.DoReceive Receiver (TimeSpan timeout,
+		                                              IsMatch matcher)
+		{
+			int to = TimeSpanToInt32 (timeout);
+			return new DoReceiveWithTimeout (to, matcher).DoReceive;
+		}
+		
+		private static TxReceiver.DoReceive Receiver (IsMatch matcher)
+		{
+			return new DoReceiveWithTimeout (-1, matcher).DoReceive;
+		}
+		
+		private static TxReceiver.DoReceive Receiver (TimeSpan timeout)
+		{
+			int to = TimeSpanToInt32 (timeout);
+			return new DoReceiveWithTimeout (to, null).DoReceive;
+		}
+
+		private TxReceiver.DoReceive Receiver ()
+		{
+			return new DoReceiveWithTimeout (-1, null).DoReceive;
+		}		
+		
+		private TxReceiver.DoReceive Peeker ()
+		{
+			return new DoReceiveWithTimeout (-1, null).DoReceive;
+		}		
+		
+		private TxReceiver.DoReceive Peeker (TimeSpan timeout)
+		{
+			int to = TimeSpanToInt32 (timeout);
+			return new DoReceiveWithTimeout (to, null, false).DoReceive;
+		}		
+		
+		private TxReceiver.DoReceive Peeker (IsMatch matcher)
+		{
+			return new DoReceiveWithTimeout (-1, matcher, false).DoReceive;
+		}		
+		
+		private TxReceiver.DoReceive Peeker (TimeSpan timeout, IsMatch matcher)
+		{
+			int to = TimeSpanToInt32 (timeout);
+			return new DoReceiveWithTimeout (to, matcher, false).DoReceive;
+		}
+		
+		delegate bool IsMatch (BasicDeliverEventArgs result);		
+		
+		private class IdMatcher
+		{
+			private readonly string id;
+			public IdMatcher (string id)
+			{
+				this.id = id;
+			}
+			
+			public bool MatchById (BasicDeliverEventArgs result)
+			{
+				return result.BasicProperties.MessageId == id;
+			}
+		}
+		
+		private static IsMatch ById (string id)
+		{
+			return new IdMatcher (id).MatchById;
+		}
+		
+		private class CorrelationIdMatcher
+		{
+			private readonly string correlationId;
+			public CorrelationIdMatcher (string correlationId)
+			{
+				this.correlationId = correlationId;
+			}
+			
+			public bool MatchById (BasicDeliverEventArgs result)
+			{
+				return result.BasicProperties.CorrelationId == correlationId;
+			}
+		}
+		
+		private static IsMatch ByCorrelationId (string correlationId)
+		{
+			return new CorrelationIdMatcher (correlationId).MatchById;
+		}
+		
+		private IMessage Receive (IModel model, int timeout, bool doAck)
+		{
+			Console.WriteLine ("{0}, {1}", timeout, doAck);
+			
+			ushort ticket = model.AccessRequest (realm);
+			string finalName = model.QueueDeclare (ticket, QRef.Queue, false);
+			
+			using (Subscription sub = new Subscription (model, ticket, finalName)) {
+				BasicDeliverEventArgs result;
+				if (sub.Next (timeout, out result)) {
+					IMessage m = helper.ReadMessage (QRef, result);
+					if (doAck)
+						sub.Ack (result);
+					return m;
+				} else {
+					throw new MonoMessagingException ("No Message Available");
+				}
+			}
+		}
+				
+		private IMessage Receive (IModel model, int timeout, 
+		                          bool doAck, IsMatch matcher)
+		{
+			Console.WriteLine ("{0}, {1}", timeout, doAck);
+			
+			ushort ticket = model.AccessRequest (realm);
+			string finalName = model.QueueDeclare (ticket, QRef.Queue, false);
+			
+			using (Subscription sub = new Subscription (model, ticket, finalName)) {
+				BasicDeliverEventArgs result;
+				while (sub.Next (timeout, out result)) {
 					
-					Subscription sub = new Subscription (ch, ticket, finalName);
-					BasicDeliverEventArgs result = sub.Next ();
-					sub.Ack (result);
-					sub.Close ();
-					if (result == null) {
-						throw new MonoMessagingException ("No Message Available");
-					} else {
-						IMessage m = MessageFactory.ReadMessage (QRef, result);
+					if (matcher (result)) {
+						IMessage m = helper.ReadMessage (QRef, result);
+						if (doAck)
+							sub.Ack (result);
 						return m;
 					}
 				}
+				
+				throw new MessageUnavailableException ("Message not available");
 			}
 		}
 		
-		public IMessageEnumerator GetMessageEnumerator ()
+		private RabbitMQMessageQueueTransaction GetTx ()
+		{
+			return (RabbitMQMessageQueueTransaction) provider.CreateMessageQueueTransaction ();
+		}		
+		
+		private static int TimeSpanToInt32 (TimeSpan timespan)
 		{
-			return new RabbitMQMessageEnumerator (QRef);
+			if (timespan == TimeSpan.MaxValue)
+				return -1;
+			else
+				return (int) timespan.TotalMilliseconds;
 		}
 	}
 }
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueueTransaction.cs b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueueTransaction.cs
new file mode 100644
index 00000000000..52e3a93cf6c
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessageQueueTransaction.cs
@@ -0,0 +1,140 @@
+//
+// Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.IO;
+using System.Text;
+
+using Mono.Messaging;
+
+using RabbitMQ.Client;
+using RabbitMQ.Client.Content;
+using RabbitMQ.Client.Events;
+using RabbitMQ.Client.Exceptions;
+using RabbitMQ.Client.MessagePatterns;
+using RabbitMQ.Util;
+
+namespace Mono.Messaging.RabbitMQ {
+
+	public class RabbitMQMessageQueueTransaction : IMessageQueueTransaction {
+		
+		private readonly string txId;
+		private MessageQueueTransactionStatus status = MessageQueueTransactionStatus.Initialized;
+		private IConnection cn = null;
+		private IModel model = null;
+		private String host = null;
+		private bool isDisposed = false;
+		private Object syncObj = new Object ();
+		
+		public RabbitMQMessageQueueTransaction (string txId)
+		{
+			this.txId = txId;
+		}
+		
+		public MessageQueueTransactionStatus Status {
+			get { 
+				lock (syncObj) 
+					return status;
+			}
+		}
+		
+		public void Abort ()
+		{
+			lock (syncObj) {
+				if (model != null)
+					model.TxRollback ();
+				status = MessageQueueTransactionStatus.Aborted;
+			}
+		}
+		
+		public void Begin ()
+		{
+			lock (syncObj) {
+				if (status == MessageQueueTransactionStatus.Pending)
+					throw new InvalidOperationException ("Transaction already started");
+				status = MessageQueueTransactionStatus.Pending;
+			}
+		}
+		
+		public void Commit ()
+		{
+			lock (syncObj) {
+				model.TxCommit ();
+				status = MessageQueueTransactionStatus.Committed;
+			}
+		}
+		
+		public string Id {
+			get { return txId; }
+		}
+		
+		public delegate void Send (ref string host, ref IConnection cn, 
+		                           ref IModel model, IMessage msg, string txId);
+		
+		public delegate IMessage Receive (ref string host, ref IConnection cn, 
+		                                  ref IModel model, string txId);
+		
+		public void RunSend (Send sendDelegate, IMessage msg)
+		{
+			lock (syncObj) {
+				sendDelegate (ref host, ref cn, ref model, msg, Id);
+			}
+		}
+		
+		public IMessage RunReceive (Receive receiveDelegate)
+		{
+			lock (syncObj) {
+				return receiveDelegate (ref host, ref cn, ref model, Id);
+			}
+		}
+		
+		public void Dispose ()
+		{
+			Dispose (true);
+			GC.SuppressFinalize (this);
+		}
+		
+		protected virtual void Dispose (bool disposing)
+		{
+			lock (syncObj) {
+				if (!isDisposed && disposing) {
+					if (model != null)
+						model.Dispose ();
+					if (cn != null)
+						cn.Dispose ();
+					isDisposed = true;
+				}
+			}
+		}
+
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessagingProvider.cs b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessagingProvider.cs
index 88236f635c7..45445659d0e 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessagingProvider.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ/RabbitMQMessagingProvider.cs
@@ -29,6 +29,10 @@
 //
 
 using System;
+using System.Collections;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
 
 using Mono.Messaging;
 
@@ -36,26 +40,113 @@ namespace Mono.Messaging.RabbitMQ {
 
 	public class RabbitMQMessagingProvider : IMessagingProvider {
 		
-		public bool Exists (QueueReference qRef)
-		{
-			// In AMQP all queues exist, because they are declared rather
-			// than created.
-			return true;
-		}
+		private volatile uint txCounter = 0;
+		private readonly uint localIp;
+		private static readonly string DEFAULT_REALM = "/data";
 		
-		public IMessageQueue GetMessageQueue ()
+		public RabbitMQMessagingProvider()
 		{
-			return new RabbitMQMessageQueue ();
+			localIp = GetLocalIP ();
 		}
 		
-		public IMessageQueue CreateMessageQueue (QueueReference qRef)
+		private static uint GetLocalIP ()
 		{
-			return new RabbitMQMessageQueue (qRef);
+			//IPHostEntry host = Dns.GetHostEntry (Dns.GetHostName ());
+			String strHostName = Dns.GetHostName ();
+			IPHostEntry ipEntry = Dns.GetHostByName (strHostName);
+			foreach (IPAddress ip in ipEntry.AddressList) {
+				if (AddressFamily.InterNetwork == ip.AddressFamily) {
+					byte[] addr = ip.GetAddressBytes ();
+					uint localIP = 0;
+					for (int i = 0; i < 4 && i < addr.Length; i++) {
+						localIP += (uint) (addr[i] << 8 * (3 - i));
+					}
+					return localIP;
+				}
+			}
+			return 0;
 		}
 		
 		public IMessage CreateMessage ()
 		{
 			return new MessageBase ();
 		}
+		
+		public IMessageQueueTransaction CreateMessageQueueTransaction ()
+		{
+			string txId = localIp.ToString () + (++txCounter).ToString (); 
+			return new RabbitMQMessageQueueTransaction (txId);
+		}
+		
+		public void DeleteQueue (QueueReference qRef)
+		{
+			RabbitMQMessageQueue.Delete (DEFAULT_REALM, qRef);
+		}
+		
+		private readonly IDictionary queues = new Hashtable ();
+		private readonly ReaderWriterLock qLock = new ReaderWriterLock ();
+		private const int TIMEOUT = 15000;
+		
+		public IMessageQueue[] GetPublicQueues ()
+		{
+			IMessageQueue[] qs;
+			qLock.AcquireReaderLock (TIMEOUT);
+			try {
+				ICollection qCollection = queues.Values;
+				qs = new IMessageQueue[qCollection.Count];
+				qCollection.CopyTo (qs, 0);
+				return qs;
+			} finally {
+				qLock.ReleaseReaderLock ();
+			}
+		}
+		
+		public bool Exists (QueueReference qRef)
+		{
+			qLock.AcquireReaderLock (TIMEOUT);
+			try {
+				return queues.Contains (qRef);
+			} finally {
+				qLock.ReleaseReaderLock ();
+			}
+		}
+		
+		public IMessageQueue CreateMessageQueue (QueueReference qRef,
+		                                         bool transactional)
+		{
+			qLock.AcquireWriterLock (TIMEOUT);
+			try {
+				IMessageQueue mq = new RabbitMQMessageQueue (this, qRef,
+				                                             transactional);
+				queues[qRef] = mq;
+				return mq;
+			} finally {
+				qLock.ReleaseWriterLock ();
+			}
+		}
+
+		public IMessageQueue GetMessageQueue (QueueReference qRef)
+		{
+			qLock.AcquireReaderLock (TIMEOUT);
+			try {
+				if (queues.Contains (qRef))
+					return (IMessageQueue) queues[qRef];
+				else {
+					LockCookie lc = qLock.UpgradeToWriterLock (TIMEOUT);
+					try {
+						IMessageQueue mq = new RabbitMQMessageQueue (this, qRef,
+						                                             false);
+						queues[qRef] = mq;
+						return mq;
+					} finally {
+						qLock.DowngradeFromWriterLock (ref lc);
+					}
+				}
+			} finally {
+				qLock.ReleaseReaderLock ();
+			}
+		}
+		
+
 	}
 }
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ_test.dll.sources b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ_test.dll.sources
index c2368a61c89..1845e0082bc 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ_test.dll.sources
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Mono.Messaging.RabbitMQ_test.dll.sources
@@ -1,3 +1,9 @@
+Mono.Messaging.RabbitMQ/MQUtil.cs
 Mono.Messaging.RabbitMQ/BasicMessagingTest.cs
+Mono.Messaging.RabbitMQ/AdminTest.cs
+Mono.Messaging.RabbitMQ/FailuresTest.cs
 Mono.Messaging.RabbitMQ/RabbitMQMessagingProviderTest.cs
 Mono.Messaging.RabbitMQ/MessageEnumeratorTest.cs
+Mono.Messaging.RabbitMQ/PeekTest.cs
+Mono.Messaging.RabbitMQ/TransactionMessagingTest.cs
+Mono.Messaging.RabbitMQ/SelectorTest.cs
\ No newline at end of file
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/AdminTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/AdminTest.cs
new file mode 100644
index 00000000000..612f401988d
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/AdminTest.cs
@@ -0,0 +1,130 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+using System.Reflection;
+using System.Threading;
+using System.Text.RegularExpressions;
+
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	[TestFixture]
+	public class AdminTest {
+		
+		[Test]
+		public void CreateNonTransactionalQueue ()
+		{
+			string qName = @".\private$\admin-queue-1";
+			Assert.IsFalse (MessageQueue.Exists (qName), "Queue should not exist");
+			MessageQueue q = MessageQueue.Create (qName);
+			Assert.IsFalse (q.Transactional);
+			Assert.IsTrue (MessageQueue.Exists (qName), "Queue should exist");
+		}
+		
+		[Test]
+		public void CreateTransactionalQueue ()
+		{
+			string qName = @".\private$\admin-queue-2";
+			Assert.IsFalse (MessageQueue.Exists (qName), "Queue should not exist");
+			MessageQueue q = MessageQueue.Create (qName, true);
+			Assert.IsTrue (q.Transactional, "Queue should be transactional");
+			Assert.IsTrue (MessageQueue.Exists (qName), "Queue should exist");
+		}
+		
+		private bool Contains(MessageQueue[] qs, String qName)
+		{
+			foreach (MessageQueue q in qs)
+			{
+				if (q.QueueName == qName)
+					return true;
+			}
+			return false;
+		}
+
+		[Test]
+		public void GetPublicQueues ()
+		{
+			string qName1 = @".\admin-queue-3";
+			string qName2 = @".\admin-queue-4";
+			
+			MessageQueue.Create (qName1);
+			MessageQueue.Create (qName2);
+			
+			MessageQueue[] mq = MessageQueue.GetPublicQueues ();
+			Assert.IsTrue (Contains (mq, "admin-queue-3"), qName1 + " not found");
+			Assert.IsTrue (Contains (mq, "admin-queue-4"), qName2 + " not found");
+		}
+		
+		[Test]
+		public void GetQueue ()
+		{
+			MessageQueue q1 = MQUtil.GetQueue(@".\private$\admin-queue-5", true);
+			Assert.IsTrue (q1.Transactional, "Queue should be transactional");
+			MessageQueue q2 = MQUtil.GetQueue(@".\private$\admin-queue-5", true);
+			Assert.IsTrue (q2.Transactional, "Queue should be transactional");
+		}
+		
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void PurgeQueue ()
+		{
+			MessageQueue q = MQUtil.GetQueue(@".\private$\purge-queue");
+			Message m1 = new Message ("foobar1", new BinaryMessageFormatter ());
+			Message m2 = new Message ("foobar2", new BinaryMessageFormatter ());
+			Message m3 = new Message ("foobar3", new BinaryMessageFormatter ());
+			Message m4 = new Message ("foobar4", new BinaryMessageFormatter ());
+			
+			q.Send (m1);
+			q.Send (m2);
+			q.Send (m3);
+			q.Send (m4);
+			
+			Message received = q.Receive ();			
+			q.Purge ();
+			q.Receive (new TimeSpan (0, 0, 2));
+		}
+				
+		[Test]
+		public void DeleteQueue ()
+		{
+			MessageQueue q = MQUtil.GetQueue(@".\private$\delete-queue");
+			Message m1 = new Message ("foobar1", new BinaryMessageFormatter ());
+			
+			q.Send (m1);
+			
+			Message received = q.Receive ();
+
+			MessageQueue.Delete(@".\private$\delete-queue");
+		}
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/BasicMessagingTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/BasicMessagingTest.cs
index 31368cea674..57e02307c41 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/BasicMessagingTest.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/BasicMessagingTest.cs
@@ -36,7 +36,7 @@ using System.Text.RegularExpressions;
 
 using NUnit.Framework;
 
-namespace MonoTests.Mono.Messsaging.RabbitMQ
+namespace MonoTests.Mono.Messaging.RabbitMQ
 {
 	[TestFixture]
 	public class BasicMessageTest {
@@ -44,12 +44,14 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 		[Test]
 		public void SendReceiveBinaryMessage ()
 		{
-			String qName = "testq";
-			MessageQueue mq = new MessageQueue (qName);
-			Assert.AreEqual (mq.QueueName, qName, "Queue name not set properly");
+			String qName = @"private$\testq";
+			String qPath = @".\" + qName;
+			MessageQueue mq = MQUtil.GetQueue (qPath);
+			Assert.AreEqual(qName, mq.QueueName, "Queue name not set properly");
 			String s = "Test: " + DateTime.Now;
 			Message m = new Message (s, new BinaryMessageFormatter ());
-			m.CorrelationId = "foo";
+			m.CorrelationId = Guid.NewGuid () + "\\0";
+			mq.MessageReadPropertyFilter.SetAll ();
 
 			mq.Send (m);
 
@@ -57,28 +59,55 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			m2.Formatter = new BinaryMessageFormatter ();
 			Assert.AreEqual (s, m2.Body);
 
-			Assert.IsTrue (DateTime.MinValue == m.ArrivedTime);
-			Assert.IsNotNull (m2.Id, "Id is null");
+			//Assert.IsTrue (DateTime.MinValue == m.ArrivedTime);
+			Assert.IsNotNull(m2.Id, "Id is null");
 			Assert.IsTrue (Guid.Empty.ToString () !=  m2.Id, "Id is Empty");
-		   	Assert.IsTrue (DateTime.MinValue != m2.ArrivedTime, "Arrived Time is not set");
+			Assert.IsTrue (DateTime.MinValue != m2.ArrivedTime, "Arrived Time is not set");
 			Assert.AreEqual (Acknowledgment.None, m2.Acknowledgment, "Acknowledgment");
 			Assert.AreEqual (m.CorrelationId, m2.CorrelationId, "CorrelationId not set properly");
 			Assert.IsTrue (0 != m2.SenderVersion);
-			Assert.IsNotNull (m2.SourceMachine, "SourceMachine is null");
+			// TODO: This is not support on a workgroup installation.
+			//Assert.IsNotNull (m2.SourceMachine, "SourceMachine is null");
 			Assert.AreEqual (qName, m2.DestinationQueue.QueueName, "Destination Queue not set");
+			
+			mq.Close ();
+		}
+		
+		[Test]
+		public void SendMessageWithLabel ()
+		{
+			String qName = @".\private$\testq";
+			String label = "mylabel";
+			MessageQueue mq = MQUtil.GetQueue (qName);
+			Assert.AreEqual (@"private$\testq", mq.QueueName, "Queue name not set properly");
+			String s = "Test: " + DateTime.Now;
+			Message m = new Message (s, new BinaryMessageFormatter ());
+			m.CorrelationId = Guid.NewGuid () + "\\0" ;
+
+			mq.Send (m, label);
+
+			Message m2 = mq.Receive ();
+			m2.Formatter = new BinaryMessageFormatter ();
+			Assert.AreEqual (s, m2.Body, "Message not passed correctly");
+			Assert.AreEqual (label, m2.Label, "Label not passed correctly");
 		}
 		
+		
 		[Test]
 		public void CheckDefaults ()
 		{
 			Message m = new Message ("Test", new BinaryMessageFormatter ());
 			Assert.AreEqual (true, m.AttachSenderId, "AttachSenderId has incorrect default");
-			Assert.AreEqual ("Microsoft Base Cryptographic Provider version 1.0", 
+			Assert.AreEqual (Guid.Empty.ToString () + "\\0", m.Id, "Id has incorrect default");
+			Assert.AreEqual ("Microsoft Base Cryptographic Provider, Ver. 1.0", 
 			                 m.AuthenticationProviderName, 
 			                 "AuthenticationProviderName has incorrect default"); 
 			Assert.AreEqual (0, m.Extension.Length, "Extension has incorrect default");
 			Assert.AreEqual ("", m.Label, "Label has incorrect default");
 			Assert.IsFalse (m.Recoverable, "Recoverable has incorrect default");
+			Assert.IsFalse (m.IsFirstInTransaction, "IsFirstInTransaction has incorrect default");
+			Assert.IsFalse (m.IsLastInTransaction, "IsLastInTransaction has incorrect default");
+			Assert.AreEqual ("", m.TransactionId, "TransactionId has incorrect default");
 			Assert.AreEqual (MessagePriority.Normal, m.Priority, "MessagePriority has incorrect default");
 		}
 		
@@ -87,8 +116,8 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			PropertyInfo pi = m.GetType ().GetProperty (property);
 			try {
 				Assert.IsNotNull (pi, "Property not defined: " + property);
-				pi.GetValue (m, null);
-				Assert.Fail (property);
+				object o = pi.GetValue (m, null);
+				Assert.Fail (property + ": " + o);
 			} catch (InvalidOperationException e) {
 			} catch (TargetInvocationException e) {
 				Assert.AreEqual (typeof (InvalidOperationException), 
@@ -104,9 +133,9 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			CheckInvalidOperation (m, "ArrivedTime");
 			CheckInvalidOperation (m, "Authenticated");
 			CheckInvalidOperation (m, "DestinationQueue");
-			CheckInvalidOperation (m, "Id");
-			CheckInvalidOperation (m, "IsFirstInTransaction");
-			CheckInvalidOperation (m, "IsLastInTransaction");
+			//CheckInvalidOperation (m, "Id");
+			//CheckInvalidOperation (m, "IsFirstInTransaction");
+			//CheckInvalidOperation (m, "IsLastInTransaction");
 			// TODO: Support 2.0 features.
 			//CheckInvalidOperation (m, "LookupId");
 			CheckInvalidOperation (m, "MessageType");
@@ -114,71 +143,75 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			CheckInvalidOperation (m, "SenderVersion");
 			CheckInvalidOperation (m, "SentTime");
 			CheckInvalidOperation (m, "SourceMachine");
-			CheckInvalidOperation (m, "TransactionId");
+			//CheckInvalidOperation (m, "TransactionId");
 		}
 		
-		private static void CheckArgumentInvalid (Message m, String property)
+		private static void CheckArgumentInvalid(Message m, String property, Type exceptionType)
 		{
-			PropertyInfo pi = m.GetType ().GetProperty (property);
+			PropertyInfo pi = m.GetType().GetProperty(property);
 			try {
-				Assert.IsNotNull (pi, "Property not defined: " + property);
-				pi.SetValue (m, null, null);
-				Assert.Fail (property);
+				Assert.IsNotNull(pi, "Property not defined: " + property);
+				pi.SetValue(m, null, null);
+				Assert.Fail(property);
 			} catch (InvalidOperationException e) {
 			} catch (TargetInvocationException e) {
-				Assert.AreEqual (typeof (ArgumentException), 
-				                 e.InnerException.GetType ());
+				Assert.AreEqual(exceptionType,
+				                e.InnerException.GetType(),
+				                property);
 			}
 		}
-		
+
 		[Test]
 		public void CheckArgumentInvalidForProperties ()
 		{
 			Message m = new Message ("Stuff");
-			CheckArgumentInvalid (m, "DestinationSymmetricKey");
-			CheckArgumentInvalid (m, "DigitalSignature");
-			CheckArgumentInvalid (m, "Extension");
+			CheckArgumentInvalid (m, "DestinationSymmetricKey", typeof (ArgumentNullException));
+			CheckArgumentInvalid (m, "DigitalSignature", typeof(ArgumentNullException));
+			CheckArgumentInvalid (m, "Extension", typeof(ArgumentNullException));
 		}
-		
+
 		[Test]
 		public void SendReceiveBinaryMessageWithAllPropertiesSet ()
-		{			
-			String qName = "testq";
-			MessageQueue mq = new MessageQueue (qName);
-			Assert.AreEqual (mq.QueueName, qName, "Queue name not set properly");
+		{
+			String qName = @"private$\testq";
+			String qPath = @".\" + qName;
+			MessageQueue mq = MQUtil.GetQueue (qPath);
+			mq.MessageReadPropertyFilter.SetAll ();
+			Assert.AreEqual(qName, mq.QueueName, "Queue name not set properly");
 			
-			MessageQueue adminQ = new MessageQueue ("myAdmin");
-			MessageQueue responseQ = new MessageQueue ("myResponse");
+			MessageQueue adminQ = MQUtil.GetQueue (@".\private$\myadmin");
+			MessageQueue responseQ = MQUtil.GetQueue (@".\private$\myresponse");
 			Guid connectorType = Guid.NewGuid ();
 			String s = "Test: " + DateTime.Now;
 			
 			Message m = new Message (s, new BinaryMessageFormatter ());
-			m.CorrelationId = "foo";
+			m.CorrelationId = Guid.NewGuid () + "\\0";
 			m.AcknowledgeType = AcknowledgeTypes.PositiveArrival;
 			m.AdministrationQueue = adminQ;
 			m.AppSpecific = 5;
-			m.AuthenticationProviderName = "Test Provider Name";
-			m.AuthenticationProviderType = CryptographicProviderType.None;
-			m.ConnectorType = connectorType;
-			m.DestinationSymmetricKey = new byte[] { 0x0A, 0x0B, 0x0C };
-			m.DigitalSignature = new byte[] { 0x0C, 0x0D, 0x0E };
-			m.EncryptionAlgorithm = EncryptionAlgorithm.Rc4;
+			//m.AuthenticationProviderName = "Test Provider Name";
+			//m.AuthenticationProviderType = CryptographicProviderType.None;
+			//m.ConnectorType = connectorType;
+			//m.DestinationSymmetricKey = new byte[] { 0x0A, 0x0B, 0x0C };
+			//m.DigitalSignature = new byte[] { 0x0C, 0x0D, 0x0E };
+			//m.EncryptionAlgorithm = EncryptionAlgorithm.Rc4;
 			m.Extension = new byte[] { 0x01, 0x02, 0x03 };
-			m.HashAlgorithm = HashAlgorithm.Sha;
+			//m.HashAlgorithm = HashAlgorithm.Sha;
 			m.Label = "MyLabel";
 			m.Priority = MessagePriority.AboveNormal;
 			m.Recoverable = true;
 			m.ResponseQueue = responseQ;
 			m.SenderCertificate = new byte[] { 0x04, 0x05, 0x06 };
-			m.TimeToBeReceived = new TimeSpan(0, 0, 5);
-			m.TimeToReachQueue = new TimeSpan(0, 0, 10);
-			m.UseAuthentication = true;
+			m.TimeToBeReceived = new TimeSpan(0, 0, 10);
+			m.TimeToReachQueue = new TimeSpan(0, 0, 5);
+			//m.UseAuthentication = true;
 			m.UseDeadLetterQueue = true;
-			m.UseEncryption = true;
+			//m.UseEncryption = true;
 			
 			mq.Send (m);
-
+			
 			Message m2 = mq.Receive ();
+			
 			m2.Formatter = new BinaryMessageFormatter ();
 			Assert.AreEqual (s, m2.Body);
 			
@@ -187,23 +220,23 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			Assert.AreEqual (adminQ.QueueName, m2.AdministrationQueue.QueueName, 
 			                 "AdministrationQueue not passed correctly");
 			Assert.AreEqual (5, m2.AppSpecific, "AppSpecific not passed correctly");
-			Assert.AreEqual (m.AuthenticationProviderName, m2.AuthenticationProviderName,
-			                 "AuthenticationProviderName not passed correctly");
-			Assert.AreEqual (m.AuthenticationProviderType, m2.AuthenticationProviderType,
-			                 "AuthenticationProviderType not passed correctly");
-			Assert.AreEqual (connectorType, m2.ConnectorType, 
-			                 "ConnectorType not passed correctly");
+			//Assert.AreEqual (m.AuthenticationProviderName, m2.AuthenticationProviderName,
+			//                 "AuthenticationProviderName not passed correctly");
+			//Assert.AreEqual (m.AuthenticationProviderType, m2.AuthenticationProviderType,
+			//                 "AuthenticationProviderType not passed correctly");
+			//Assert.AreEqual (connectorType, m2.ConnectorType, 
+			//                 "ConnectorType not passed correctly");
 			Assert.AreEqual (m.CorrelationId, m2.CorrelationId, 
 			                 "CorrelationId not passed correctly");
-			AreEqual (m.DestinationSymmetricKey, m2.DestinationSymmetricKey, 
-			          "DestinationSymmetricKey not passed correctly");
-			AreEqual (m.DigitalSignature, m2.DigitalSignature,
-			          "DigitalSignature not passed properly");
-			Assert.AreEqual (EncryptionAlgorithm.Rc4, m2.EncryptionAlgorithm,
-			                 "EncryptionAlgorithm not passed properly");
+			//AreEqual (m.DestinationSymmetricKey, m2.DestinationSymmetricKey, 
+			//          "DestinationSymmetricKey not passed correctly");
+			//AreEqual (m.DigitalSignature, m2.DigitalSignature,
+			//          "DigitalSignature not passed properly");
+			//Assert.AreEqual (EncryptionAlgorithm.Rc4, m2.EncryptionAlgorithm,
+			//                 "EncryptionAlgorithm not passed properly");
 			AreEqual (m.Extension, m2.Extension, "Extension not passed properly");
-			Assert.AreEqual (m.HashAlgorithm, m2.HashAlgorithm,
-			                 "HashAlgorithm not passed properly");
+			//Assert.AreEqual (m.HashAlgorithm, m2.HashAlgorithm,
+			//                 "HashAlgorithm not passed properly");
 			Assert.AreEqual (m.Label, m2.Label, "Label not passed correctly");
 			Assert.AreEqual (MessagePriority.AboveNormal, m2.Priority,
 			                 "Priority not passed properly");
@@ -211,25 +244,26 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			Assert.AreEqual (responseQ.QueueName, m2.ResponseQueue.QueueName,
 			                 "ResponseQueue not passed properly");
 			AreEqual (m.SenderCertificate, m2.SenderCertificate,
-			               "SenderCertificate not passed properly");
+			          "SenderCertificate not passed properly");
 			Assert.AreEqual (m.TimeToBeReceived, m2.TimeToBeReceived,
 			                 "TimeToBeReceived not passed properly");
 			Assert.AreEqual (m.TimeToReachQueue, m2.TimeToReachQueue,
 			                 "TimeToReachQueue not passed properly");
-			Assert.IsTrue (m2.UseAuthentication,
-			               "UseAuthentication not passed properly");
+			//Assert.IsTrue (m2.UseAuthentication,
+			//               "UseAuthentication not passed properly");
 			Assert.IsTrue (m2.UseDeadLetterQueue,
 			               "UseDeadLetterQueue not passed properly");
-			Assert.IsTrue (m2.UseEncryption, "UseEncryption not pass properly");
+			//Assert.IsTrue (m2.UseEncryption, "UseEncryption not pass properly");
 			//Assert.AreEqual ();
 			
-			Assert.IsTrue (DateTime.MinValue == m.ArrivedTime);
 			Assert.IsNotNull (m2.Id, "Id is null");
 			Assert.IsTrue (Guid.Empty.ToString () !=  m2.Id, "Id is Empty");
-		   	Assert.IsTrue (DateTime.MinValue != m2.ArrivedTime, "Arrived Time is not set");
+			Assert.IsTrue (DateTime.MinValue != m2.ArrivedTime, "Arrived Time is not set");
 			Assert.AreEqual (Acknowledgment.None, m2.Acknowledgment, "Acknowledgment");
 			Assert.IsTrue (0 != m2.SenderVersion);
-			Assert.IsNotNull (m2.SourceMachine, "SourceMachine is null");
+			
+			//Assert.IsNotNull (m2.SourceMachine, "SourceMachine is null");
+			
 		}
 		
 		private static void AreEqual(byte[] expected, byte[] actual, string message)
@@ -239,12 +273,35 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 				Assert.AreEqual (expected[i], actual[i], message);
 		}
 		
+		//[Test]
+		// No supported by Rabbit
+		public void SendPriorityMessages ()
+		{
+			MessageQueue mq = MQUtil.GetQueue ("testpriority");
+			Message sent1 = new Message ("Highest", new BinaryMessageFormatter ());
+			sent1.Priority = MessagePriority.Highest;
+			Message sent2 = new Message ("Lowest", new BinaryMessageFormatter ());
+			sent2.Priority = MessagePriority.Lowest;
+			
+			mq.Send (sent1);
+			mq.Send (sent2);
+			
+			Message received1 = mq.Receive ();
+			Message received2 = mq.Receive ();
+			
+			Assert.AreEqual (MessagePriority.Highest, received2.Priority,
+			                 "Priority delivery incorrect");
+			Assert.AreEqual (MessagePriority.Lowest, received1.Priority,
+			                 "Priority delivery incorrect");
+		}
+		
 		[Test]
 		public void SendReceiveXmlMessage ()
 		{
-			MessageQueue mq = new MessageQueue ("testq");
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\testq");
 			String s = "Test: " + DateTime.Now;
 			Message m = new Message (s, new XmlMessageFormatter (new Type[] { typeof (string) }));
+			mq.MessageReadPropertyFilter.SetAll();
 		   
 			mq.Send (m);
 			Message m2 = mq.Receive ();
@@ -257,26 +314,12 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 		}
 	   
 		[Test]
-		public void CreateQueue ()
-		{
-			string path = @".\private$\MyQ";
-			string body = "This is a test";
-		   
-			MessageQueue q = MessageQueue.Create (path);
-			Assert.IsNotNull (q);
-		}
-	   
-		[Test]
 		public void SendBinaryText ()
 		{
 			string path = @".\private$\MyQ";
 			string body = "This is a test";
 		   
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-					q = new MessageQueue (path);
-			else
-					q = MessageQueue.Create (path);
+			MessageQueue q = MQUtil.GetQueue (path);
 
 			q.Formatter = new BinaryMessageFormatter ();
 
@@ -295,17 +338,13 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			string path = @".\private$\MyQ";
 			string body = "This is a test";
 
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-				q = new MessageQueue (path);
-			else
-				q = MessageQueue.Create (path);
+			MessageQueue q = MQUtil.GetQueue (path, new XmlMessageFormatter ());
 
 			q.Send (body);
 
 			Message m2 = q.Receive ();
 			XmlMessageFormatter xmlf = (XmlMessageFormatter) q.Formatter;
-			Assert.AreEqual (typeof (string), xmlf.TargetTypes[0]);
+			//Assert.AreEqual (typeof (string), xmlf.TargetTypes[0]);
 			Assert.AreEqual (typeof (XmlMessageFormatter), m2.Formatter.GetType ());
 			Assert.AreEqual (body, m2.Body);
 			Assert.AreEqual (0, m2.BodyType);
@@ -320,11 +359,7 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			body.MyProperty2 = "Something";
 			body.MyProperty3 = "Something else";
 
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-					q = new MessageQueue (path);
-			else
-					q = MessageQueue.Create (path);
+			MessageQueue q = MQUtil.GetQueue (path);
 
 			q.Formatter = new BinaryMessageFormatter ();
 
@@ -349,15 +384,11 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			body.MyProperty2 = "Something";
 			body.MyProperty3 = "Something else";
 
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-					q = new MessageQueue (path);
-			else
-					q = MessageQueue.Create (path);
+			MessageQueue q = MQUtil.GetQueue (path, new XmlMessageFormatter ());
 
 			q.Send (body);
 
-			MessageQueue q2 = new MessageQueue (path);
+			MessageQueue q2 = MQUtil.GetQueue (path);
 			q2.Formatter = new XmlMessageFormatter (new Type[] { typeof(Thingy) });
 
 			Message m2 = q2.Receive ();
@@ -380,15 +411,9 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			Message m1 = new Message (body);
 			m1.Formatter = new BinaryMessageFormatter ();
 
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-					q = new MessageQueue (path);
-			else
-					q = MessageQueue.Create (path);
-
+			MessageQueue q = MQUtil.GetQueue (path);
 
 			q.Send (m1);
-			//Assert.IsNotNull (m1.Id);
 
 			Message m2 = q.Receive ();
 			m2.Formatter = new BinaryMessageFormatter ();
@@ -412,11 +437,7 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			Message m1 = new Message (body);
 			Assert.IsNull (m1.Formatter);
 
-			MessageQueue q;
-			if (MessageQueue.Exists (path))
-					q = new MessageQueue (path);
-			else
-					q = MessageQueue.Create (path);
+			MessageQueue q = MQUtil.GetQueue (path, new XmlMessageFormatter ());
 
 			q.Send (m1);
 
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/ChangeLog b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/ChangeLog
index fd6cb0f7b13..fea66238c2b 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/ChangeLog
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/ChangeLog
@@ -1,3 +1,39 @@
+2008-12-06  Michael Barker  <mike@middlesoft.co.uk>
+
+	* AdminTest.cs:  Updated to run against MS.NET
+	* BasicMessagingTest.cs:  Updated to run against MS.NET
+	* FailuresTest.cs:  Updated to run against MS.NET
+	* MessageEnumeratorTest.cs:  Updated to run against MS.NET
+	* MQUtil.cs:  Updated to run against MS.NET
+	* PeekTest.cs:  Updated to run against MS.NET
+	* SelectorTest.cs:  Updated to run against MS.NET
+	* TransactionMessagingTest.cs:  Updated to run against MS.NET
+
+2008-12-01  Michael Barker  <mike@middlesoft.co.uk>
+
+	* AdminTest.cs:  Added tests for queue discovery methods.
+
+2008-11-23  Michael Barker  <mike@middlesoft.co.uk>
+
+	* TransactionMessagingTest.cs:  Added tests for all methods that the
+	transaction type argument, currently only Single is supported.  Added methods
+	with transactions and timeout.
+	* PeekTest.cs:  Added PeekBy{Id,CorrelationId} tests.
+
+2008-11-09  Michael Barker  <mike@middlesoft.co.uk>
+
+	* SelectorTest.cs:  New, tests for ReceiveByXYZ() methods
+
+2008-11-04  Michael Barker  <mike@middlesoft.co.uk>
+
+	* PeekTest.cs:  New, tests for peeking at messages.
+
+2008-11-02  Michael Barker  <mike@middlesoft.co.uk>
+
+	* TransactionMessagingTest.cs: New, tests for transactional messaging.
+	* FailuresTest.cs: New, tests for exceptions.
+	* AdminTest.cs: New, tests for administration functions.
+
 2008-09-29  Michael Barker  <mike@middlesoft.co.uk>
 
 	* BasicMessagingTest.cs: New
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/FailuresTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/FailuresTest.cs
new file mode 100644
index 00000000000..c4ca13e1cef
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/FailuresTest.cs
@@ -0,0 +1,66 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+using System.Reflection;
+using System.Threading;
+using System.Text.RegularExpressions;
+
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	[TestFixture]
+	public class FailuresTest {
+
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void SendWithPathNotSet ()
+		{
+			MessageQueue q = new MessageQueue ();
+			Message m = new Message ("foobar", new BinaryMessageFormatter ());
+			
+			q.Send (m);
+		}
+		
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void SendInTransactionWithPathNotSet ()
+		{
+			MessageQueue q = new MessageQueue ();
+			Message m = new Message ("foobar", new BinaryMessageFormatter ());
+			MessageQueueTransaction tx = new MessageQueueTransaction ();
+			
+			q.Send (m, tx);
+		}
+		
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MQUtil.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MQUtil.cs
new file mode 100644
index 00000000000..6c32aca5393
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MQUtil.cs
@@ -0,0 +1,67 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	public class MQUtil
+	{
+		public static MessageQueue GetQueue (string path)
+		{
+			return GetQueue (path, false);
+		}
+		
+		public static MessageQueue GetQueue (string path, bool isTransactional)
+		{
+			return GetQueue (path, isTransactional,
+			                 new BinaryMessageFormatter ());
+		}
+		
+		public static MessageQueue GetQueue (string path, IMessageFormatter formatter)
+		{
+			return GetQueue (path, false, formatter);
+		}
+		
+		public static MessageQueue GetQueue (string path, bool isTransactional, 
+		                                     IMessageFormatter formatter)
+		{
+			MessageQueue q;
+			if (MessageQueue.Exists (path)) {
+				q = new MessageQueue (path);
+			} else {
+				q = MessageQueue.Create (path, isTransactional);
+			}
+			q.Formatter = formatter;
+			return q;
+		}		
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MessageEnumeratorTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MessageEnumeratorTest.cs
index e918e72df69..5c4c2bf3584 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MessageEnumeratorTest.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/MessageEnumeratorTest.cs
@@ -31,22 +31,22 @@
 using System;
 using System.Messaging;
 
-using Mono.Messaging;
-using Mono.Messaging.RabbitMQ;
+//using Mono.Messaging;
+//using Mono.Messaging.RabbitMQ;
 
 using NUnit.Framework;
 
-namespace MonoTests.Mono.Messsaging.RabbitMQ
+namespace MonoTests.Mono.Messaging.RabbitMQ
 {
 	[TestFixture]
 	public class MessageEnumeratorTest {
 		
-		private readonly String qName = "testq2";
+		private readonly String qName = @".\private$\testq2";
 		
 		private void SendMessage (string s) {
-			MessageQueue mq = new MessageQueue (qName);
+			MessageQueue mq = MQUtil.GetQueue (qName);
 			Message m = new Message (s, new BinaryMessageFormatter ());
-			m.CorrelationId = "foo";
+			m.CorrelationId = Guid.NewGuid () + "\\0";
 			mq.Send (m);
 		}
 		
@@ -58,7 +58,7 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			SendMessage ("message 3");
 			SendMessage ("message 4");
 			
-			MessageQueue mq0 = new MessageQueue (qName);
+			MessageQueue mq0 = MQUtil.GetQueue (qName);
 			MessageEnumerator me0 = mq0.GetMessageEnumerator ();
 			
 			me0.MoveNext ();
@@ -72,7 +72,7 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			me0.Dispose ();
 			mq0.Dispose ();
 			
-			MessageQueue mq1 = new MessageQueue (qName);
+			MessageQueue mq1 = MQUtil.GetQueue (qName);
 			MessageEnumerator me1 = mq1.GetMessageEnumerator ();
 			
 			me1.MoveNext();
@@ -83,6 +83,33 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 			m1.Formatter = new BinaryMessageFormatter ();
 			Console.WriteLine ("{0}", m1.Body);
 			Assert.AreEqual ("message 4", (String) m1.Body, "body incorrect");
+			
+			mq1.Purge ();
+			MessageQueue.Delete (qName);
+		}
+		
+		//[Test]
+		// Not supported with AMQP
+		public void RemoveMessageWithTx ()
+		{
+			MessageQueue q = MQUtil.GetQueue ("testq3");
+			
+			q.Formatter = new BinaryMessageFormatter ();
+			q.Send ("foo1");
+			q.Send ("foo2");
+			
+			MessageEnumerator me1 = q.GetMessageEnumerator ();
+			MessageQueueTransaction tx = new MessageQueueTransaction ();
+			me1.MoveNext ();
+			Message m1 = me1.Current;
+			me1.RemoveCurrent (tx);
+			tx.Commit ();
+			me1.Close ();
+			
+			MessageEnumerator me2 = q.GetMessageEnumerator ();
+			Assert.IsTrue (me1.MoveNext ());
+			me2.RemoveCurrent ();
+			Assert.IsFalse (me2.MoveNext ());
 		}
 	}
 }
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/PeekTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/PeekTest.cs
new file mode 100644
index 00000000000..2c6c60b49b3
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/PeekTest.cs
@@ -0,0 +1,187 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	[TestFixture]
+	public class PeekTest {
+		
+		[Test]
+		public void PeekMessage ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\peek-queue-1");
+			mq.Send (s1);
+			
+			Message r1 = mq.Peek ();
+			Assert.AreEqual (body, r1.Body);
+			
+			Message r2 = mq.Receive ();
+			Assert.AreEqual (body, r2.Body);
+		}
+		
+		[Test]
+		public void PeekMessageWithTimeout ()
+		{
+			String body = "foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			MessageQueue mq = MQUtil.GetQueue(@".\private$\peek-queue-2");
+			mq.Send (s1);
+			
+			Message r1 = mq.Peek (new TimeSpan (0, 0, 2));
+			Assert.AreEqual (body, r1.Body);
+			
+			Message r2 = mq.Receive ();
+			Assert.AreEqual (body, r2.Body);
+		}
+		
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void PeekNoMessageWithTimeout ()
+		{
+			MessageQueue mq = MQUtil.GetQueue(@".\private$\peek-queue-3");
+			Message r1 = mq.Peek (new TimeSpan (0, 0, 2));
+		}
+		
+		[Test]
+		public void PeekById ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue (@".\private$\peek-queue-4");
+			q.Send (s1);
+			
+			String id = s1.Id;
+			try {
+				Message r1 = q.PeekById (id);
+				Assert.AreEqual (body, r1.Body, "Unable to PeekById correctly");
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		public void PeekByIdWithTimeout ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue (@".\private$\peek-queue-5");
+			q.Send (s1);
+			
+			String id = s1.Id;
+			try {
+				Message r1 = q.PeekById (id, new TimeSpan (0, 0, 2));
+				Assert.AreEqual (body, r1.Body, "Unable to PeekById correctly");
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void PeekByIdNotFound ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue (@".\private$\peek-queue-6");
+			q.Send (s1);
+			
+			String id = "fail!";
+			
+			try {
+				Message r1 = q.PeekById (id);
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		public void PeekByCorrelationId ()
+		{
+			String correlationId = Guid.NewGuid () + "\\0";
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			s1.CorrelationId = correlationId;
+			MessageQueue q = MQUtil.GetQueue (@".\private$\peek-queue-7");
+			q.Formatter = new BinaryMessageFormatter ();
+			q.Send (s1);
+			
+			try {
+				Message r1 = q.PeekByCorrelationId (correlationId);
+				Assert.AreEqual (body, r1.Body, "Unable to PeekByCorrelationId correctly");
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void PeekByCorrelationIdNotFound ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body);
+			String correlationId = Guid.NewGuid() + "\\0";
+			MessageQueue q = MQUtil.GetQueue(@".\private$\peek-queue-8");
+			q.Formatter = new BinaryMessageFormatter ();
+			q.Send (s1);
+			
+			try {
+				Message r1 = q.PeekByCorrelationId ("fail!");
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		public void PeekByCorrelationIdWithTimeout ()
+		{
+			String correlationId = Guid.NewGuid () + "\\0";
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			s1.CorrelationId = correlationId;
+			MessageQueue q = MQUtil.GetQueue (@".\private$\peek-queue-9");
+			q.Formatter = new BinaryMessageFormatter ();
+			q.Send (s1);
+			
+			try {
+				Message r1 = q.PeekByCorrelationId (correlationId, new TimeSpan (0, 0, 2));
+				Assert.AreEqual (body, r1.Body, "Unable to PeekByCorrelationId correctly");
+			} finally {
+				q.Purge ();
+			}
+		}		
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/RabbitMQMessagingProviderTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/RabbitMQMessagingProviderTest.cs
index 65305f7c9ef..31fd8f19478 100644
--- a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/RabbitMQMessagingProviderTest.cs
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/RabbitMQMessagingProviderTest.cs
@@ -35,7 +35,7 @@ using Mono.Messaging.RabbitMQ;
 
 using NUnit.Framework;
 
-namespace MonoTests.Mono.Messsaging.RabbitMQ
+namespace MonoTests.Mono.Messaging.RabbitMQ
 {
 	[TestFixture]
 	public class RabbitMQMessagingProviderTest {
@@ -52,7 +52,7 @@ namespace MonoTests.Mono.Messsaging.RabbitMQ
 		public void GetMessageQueue ()
 		{
 			IMessagingProvider p = new RabbitMQMessagingProvider ();
-			IMessageQueue q = p.GetMessageQueue ();
+			IMessageQueue q = p.CreateMessageQueue (QueueReference.DEFAULT, true);
 			Assert.IsNotNull (q);   
 		}
 		
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/SelectorTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/SelectorTest.cs
new file mode 100644
index 00000000000..73caaedfc6e
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/SelectorTest.cs
@@ -0,0 +1,138 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	[TestFixture]
+	public class SelectorTest
+	{
+		
+		[Test]
+		public void SelectById ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString ();
+			Message s1 = new Message (body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue (@".\private$\selector-queue-1");
+			q.Send (s1);
+			
+			String id = s1.Id;
+			
+			Message r1 = q.ReceiveById (id);
+			
+			Assert.AreEqual (body, r1.Body, "Unable to ReceiveById correctly");
+		}
+		
+		[Test]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void SelectByIdNotFound ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue(@".\private$\selector-queue-2");
+			q.Send (s1);
+			
+			String id = "fail!";
+			
+			try {
+				Message r1 = q.ReceiveById (id);
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		public void SelectByCorrelationId ()
+		{
+			string correlationId = Guid.NewGuid () + "\\0";
+			String body = "Foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			s1.CorrelationId = correlationId;
+			MessageQueue q = MQUtil.GetQueue(@".\private$\selector-queue-3");
+			q.Send (s1);
+			
+			Message r1 = q.ReceiveByCorrelationId (correlationId);
+			
+			Assert.AreEqual (body, r1.Body, "Unable to ReceiveByCorrelationId correctly");
+		}
+		
+		[Test]
+		[ExpectedException (typeof (InvalidOperationException))]
+		public void SelectByCorrelationIdNotFound ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "Foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			s1.CorrelationId = correlationId;
+			MessageQueue q = MQUtil.GetQueue(@".\private$\selector-queue-4");
+			q.Send (s1);
+			
+			try {
+				Message r1 = q.ReceiveByCorrelationId ("fail!");
+			} finally {
+				q.Purge ();
+			}
+		}
+		
+		[Test]
+		public void SelectByIdWithTimeout ()
+		{
+			String body = "Foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			MessageQueue q = MQUtil.GetQueue(@".\private$\selector-queue-5");
+			q.Send (s1);
+			
+			String id = s1.Id;
+			
+			Message r1 = q.ReceiveById (id, new TimeSpan (0, 0, 2));
+			
+			Assert.AreEqual (body, r1.Body, "Unable to ReceiveById correctly");
+		}
+				
+		[Test]
+		public void SelectByCorrelationIdWithTimeout ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "Foo-" + DateTime.Now.ToString();
+			Message s1 = new Message(body, new BinaryMessageFormatter());
+			s1.CorrelationId = correlationId;
+			MessageQueue q = MQUtil.GetQueue(@".\private$\selector-queue-3");
+			q.Send (s1);
+			
+			Message r1 = q.ReceiveByCorrelationId (correlationId, new TimeSpan (0, 0, 2));
+			
+			Assert.AreEqual (body, r1.Body, "Unable to ReceiveByCorrelationId correctly");
+		}
+	}
+}
diff --git a/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/TransactionMessagingTest.cs b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/TransactionMessagingTest.cs
new file mode 100644
index 00000000000..e0230952e26
--- /dev/null
+++ b/mcs/class/Mono.Messaging.RabbitMQ/Test/Mono.Messaging.RabbitMQ/TransactionMessagingTest.cs
@@ -0,0 +1,467 @@
+//
+// Test.Mono.Messaging.RabbitMQ
+//
+// Authors:
+//	  Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Messaging;
+using System.Reflection;
+using System.Threading;
+using System.Text.RegularExpressions;
+
+using NUnit.Framework;
+
+namespace MonoTests.Mono.Messaging.RabbitMQ
+{
+	[TestFixture]
+	public class TransactionMessageTest {
+		
+		[Test]
+		public void Send2WithTransaction ()
+		{
+			Message sent1 = new Message ("Message 1", new BinaryMessageFormatter ());
+			Message sent2 = new Message ("Message 2", new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-1", true);
+			mq.MessageReadPropertyFilter.SetAll ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				mq.Send (sent1, tx);
+				mq.Send (sent2, tx);
+				
+				tx.Commit ();
+				
+				Message received1 = mq.Receive ();
+				Assert.IsNotNull (received1.TransactionId, "TransactionId not set");
+				Message received2 = mq.Receive ();
+				Assert.IsNotNull (received2.TransactionId, "TransactionId not set");
+				
+				Assert.AreEqual (received1.TransactionId, received2.TransactionId, "Messages have differing TransactionIds");
+				Assert.IsTrue (received1.TransactionId.Length > 1);
+				Assert.AreEqual (sent1.Body, received1.Body, "Message 1 not delivered correctly");
+				Assert.AreEqual (sent2.Body, received2.Body, "Message 2 not delivered correctly");
+			}
+		}
+		
+		[Test]
+		public void Send2WithLabelWithTransaction ()
+		{
+			String label1 = "label1";
+			String label2 = "label2";
+			Message sent1 = new Message ("Message 1", new BinaryMessageFormatter ());
+			Message sent2 = new Message ("Message 2", new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-2", true);
+			mq.MessageReadPropertyFilter.SetAll ();
+			Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				mq.Send (sent1, label1, tx);
+				mq.Send (sent2, label2, tx);
+				
+				tx.Commit ();
+				
+				Message received1 = mq.Receive ();
+				Assert.IsNotNull (received1.TransactionId, "TransactionId not set");
+				Message received2 = mq.Receive ();
+				Assert.IsNotNull (received2.TransactionId, "TransactionId not set");
+				
+				Assert.AreEqual (received1.TransactionId, received2.TransactionId, "Messages have differing TransactionIds");
+				Assert.IsTrue (received1.TransactionId.Length > 1);
+				Assert.AreEqual (sent1.Body, received1.Body, "Message 1 not delivered correctly");
+				Assert.AreEqual (sent2.Body, received2.Body, "Message 2 not delivered correctly");
+				Assert.AreEqual (label1, received1.Label, "Label 1 not passed correctly");
+				Assert.AreEqual (label2, received2.Label, "Label 2 not passed correctly");
+			}
+		}
+				
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void Send2WithTransactionAbort ()
+		{
+			Message sent1 = new Message ("Message 1", new BinaryMessageFormatter ());
+			Message sent2 = new Message ("Message 2", new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-1", true);
+			mq.MessageReadPropertyFilter.SetAll ();
+			Assert.IsTrue(mq.Transactional, "Message Queue should be transactional");
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				mq.Send (sent1, tx);
+				mq.Send (sent2, tx);
+				
+				tx.Abort ();
+				mq.Receive (new TimeSpan (0, 0, 2));
+			}
+		}
+		
+		[Test]
+		public void ReceiveWithTransaction ()
+		{
+			String body = "Message 4";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-4", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.Receive (tx);
+				
+				tx.Commit ();
+				
+				Assert.AreEqual (body, received1.Body);
+			}
+		}
+		
+		[Test]
+		public void ReceiveWithTransactionAbort ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-5", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.Receive (tx);
+				
+				tx.Abort ();
+			}
+			
+			Message received2 = mq.Receive ();
+			Assert.AreEqual (body, received2.Body);
+		}
+		
+		[Test]
+		public void ReceiveWithTransactionType ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-6", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			Message received1 = mq.Receive (MessageQueueTransactionType.Single);
+			
+			Assert.AreEqual (body, received1.Body);
+		}
+		
+		[Test]
+		public void SendWithTransactionType ()
+		{
+			Message sent1 = new Message ("Message 1");
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-7", true);
+			mq.MessageReadPropertyFilter.SetAll();
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			Message received1 = mq.Receive ();
+			Assert.IsNotNull (received1.TransactionId, "TransactionId not set");
+		}
+		
+		[Test]
+		public void SendWithTransactionTypeAndLabel ()
+		{
+			Message sent1 = new Message ("Message 1");
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-8", true);
+			mq.MessageReadPropertyFilter.SetAll();
+			String label = "mylabel";
+			
+			mq.Send (sent1, label, MessageQueueTransactionType.Single);
+			
+			Message received1 = mq.Receive ();
+			Assert.IsNotNull (received1.TransactionId, "TransactionId not set");
+			Assert.AreEqual (label, received1.Label, "Label not set");
+		}
+
+		[Test]
+		public void ReceiveByIdWithTransaction ()
+		{
+			String body = "Message 4";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-9", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.ReceiveById (id, tx);
+				
+				tx.Commit ();
+				
+				Assert.AreEqual (body, received1.Body);
+			}
+		}
+		
+		[Test]
+		public void ReceiveByIdWithTransactionAbort ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-10", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.ReceiveById (id, tx);
+				
+				tx.Abort ();
+			}
+			
+			Message received2 = mq.Receive ();
+			Assert.AreEqual (body, received2.Body);
+		}
+		
+		[Test]
+		public void ReceiveByIdWithTransactionType ()
+		{
+			String body = "Message 4";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-11", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+
+			Message received1 = mq.ReceiveById (id, MessageQueueTransactionType.Single);
+			Assert.AreEqual (body, received1.Body);
+		}
+
+		[Test]
+		public void ReceiveByCorrelationIdWithTransaction ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "Message 4";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			sent1.CorrelationId = correlationId;
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-12", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+
+				Message received1 = mq.ReceiveByCorrelationId(correlationId, tx);
+				
+				tx.Commit ();
+				
+				Assert.AreEqual (body, received1.Body);
+			}
+		}
+		
+		[Test]
+		public void ReceiveByCorrelationIdWithTransactionAbort ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "foo-" + DateTime.Now.ToString();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			sent1.CorrelationId = correlationId;
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-13", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.ReceiveByCorrelationId (correlationId, tx);
+				
+				tx.Abort ();
+			}
+			
+			Message received2 = mq.Receive ();
+			Assert.AreEqual (body, received2.Body);
+		}
+
+		[Test]
+		public void ReceiveByCorrelationIdWithTransactionType ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "Message 10";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			sent1.CorrelationId = correlationId;
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-14", true);
+			mq.Formatter = new BinaryMessageFormatter ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			Message received1 = mq.ReceiveByCorrelationId (correlationId, MessageQueueTransactionType.Single);
+			Assert.AreEqual (body, received1.Body);
+		}
+
+		[Test]
+		public void ReceiveWithTransactionAndTimeout ()
+		{
+			String body = "Message 11";
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-15", true);
+			mq.Formatter = new BinaryMessageFormatter ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.Receive (new TimeSpan (0, 0, 2), tx);
+				
+				tx.Commit ();
+				
+				Assert.AreEqual (body, received1.Body);
+			}
+		}
+
+		[Test]
+		public void ReceiveWithTransactionAndTimeoutAndAbort ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-16", true);
+			mq.Formatter = new BinaryMessageFormatter ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.Receive (new TimeSpan (0, 0, 2), tx);
+				
+				tx.Abort ();
+			}
+			
+			Message received2 = mq.Receive ();
+			Assert.AreEqual (body, received2.Body);
+		}
+		
+		[Test]
+		public void ReceiveWithTransactionTypeAndTimeout ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-17", true);
+			mq.Formatter = new BinaryMessageFormatter ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			
+			Message received1 = mq.Receive (new TimeSpan (0, 0, 5), MessageQueueTransactionType.Single);
+			
+			Assert.AreEqual (body, received1.Body);
+		}
+
+		[Test]
+		[ExpectedException (typeof (MessageQueueException))]
+		public void ReceiveWithTransactionTypeAndTimeoutFailure ()
+		{
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-18", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			Message received1 = mq.Receive (new TimeSpan (0, 0, 2), MessageQueueTransactionType.Single);
+		}
+		
+		[Test]
+		public void ReceiveByIdWithTransactionAndTimeout ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-19", true);
+			mq.Formatter = new BinaryMessageFormatter ();
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+				
+				Message received1 = mq.ReceiveById (id, new TimeSpan (0, 0, 2), tx);
+				
+				tx.Commit ();
+				
+				Assert.AreEqual (body, received1.Body);
+			}
+		}
+		
+		[Test]
+		public void ReceiveByIdWithTransactionTypeAndTimeout ()
+		{
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-20", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			Message received1 = mq.ReceiveById (id, new TimeSpan (0, 0, 2), MessageQueueTransactionType.Single);
+			Assert.AreEqual (body, received1.Body);
+		}
+
+		[Test]
+		public void ReceiveByCorrelationIdWithTransactionAndTimeout ()
+		{
+			string correlationId = Guid.NewGuid () + "\\0";
+			String body = "foo-" + DateTime.Now.ToString ();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			sent1.CorrelationId = correlationId;
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-21", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+			
+			using (MessageQueueTransaction tx = new MessageQueueTransaction ()) {
+				tx.Begin ();
+
+				Message received1 = mq.ReceiveByCorrelationId (correlationId, new TimeSpan (0, 0, 2), tx);
+				tx.Commit ();
+				Assert.AreEqual (body, received1.Body);
+			}
+		}		
+
+		[Test]
+		public void ReceiveByCorrelationIdWithTransactionTypeAndTimeout ()
+		{
+			string correlationId = Guid.NewGuid() + "\\0";
+			String body = "foo-" + DateTime.Now.ToString();
+			Message sent1 = new Message (body, new BinaryMessageFormatter ());
+			sent1.CorrelationId = correlationId;
+			MessageQueue mq = MQUtil.GetQueue (@".\private$\tx-queue-22", true);
+			Assert.IsTrue (mq.Transactional, "Message Queue should be transactional");
+			mq.Send (sent1, MessageQueueTransactionType.Single);
+			string id = sent1.Id;
+
+			Message received1 = mq.ReceiveByCorrelationId (correlationId,  new TimeSpan (0, 0, 2), MessageQueueTransactionType.Single);
+			Assert.AreEqual (body, received1.Body);
+		}		
+	}
+}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging.dll.sources b/mcs/class/Mono.Messaging/Mono.Messaging.dll.sources
index 30cb4d4f736..298f8e2a6f0 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging.dll.sources
+++ b/mcs/class/Mono.Messaging/Mono.Messaging.dll.sources
@@ -10,11 +10,15 @@
 ./Mono.Messaging/HashAlgorithm.cs
 ./Mono.Messaging/IMessagingProvider.cs
 ./Mono.Messaging/IMessageEnumerator.cs
+./Mono.Messaging/IMessageQueueTransaction.cs
 ./Mono.Messaging/IMessageQueue.cs
 ./Mono.Messaging/IMessage.cs
 ./Mono.Messaging/MessageBase.cs
 ./Mono.Messaging/MessagePriority.cs
+./Mono.Messaging/MessageQueueTransactionStatus.cs
+./Mono.Messaging/MessageQueueTransactionType.cs
 ./Mono.Messaging/MessageType.cs
+./Mono.Messaging/MessageUnavailableException.cs
 ./Mono.Messaging/MessagingProviderLocator.cs
 ./Mono.Messaging/MonoMessagingException.cs
 ./Mono.Messaging/QueueReference.cs
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/ChangeLog b/mcs/class/Mono.Messaging/Mono.Messaging/ChangeLog
index e3468735c44..70948f474f9 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/ChangeLog
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/ChangeLog
@@ -1,3 +1,29 @@
+2008-12-07  Michael Barker  <mike@middlesoft.co.uk>
+
+	* MessageUnavailableException.cs:  Specific exception for messages not being
+	available on the queue.
+	* QueueReference.cs:  Change queue name to return "private$" as required.
+
+2008-11-23  Michael Barker  <mike@middlesoft.co.uk>
+
+	* IMessageQueue.cs:  Added support for MessageQueueTransactionType, 
+	ReceiveBy{Id,CorrelationId} and PeekBy{Id,CorrelationId} methods.
+
+2008-11-09  Michael Barker  <mike@middlesoft.co.uk>
+
+	* MessageQueueTransactionType.cs:  New, copy of 
+	System.Messaging.MessageQueueTransactionStatus.cs
+
+2008-11-02  Michael Barker  <mike@middlesoft.co.uk>
+
+	* IMessageQueueTransaction.cs: New, interface for supporting transactions
+	* MessageQueueTransactionStatus.cs: New, straight copy of the class from
+	System.Messaging
+	* IMessageQueue.cs: Added methods for transactional delivery and purging
+	queues.
+	* IMessageQueueProvider.cs: Added method for creating transactions and
+	deleting queues.
+
 2008-10-26  Michael Barker  <mike@middlesoft.co.uk>
 
 	* ConnectionException.cs:  Added support for InnerExceptions
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/IMessageEnumerator.cs b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageEnumerator.cs
index b67dfa432b1..07dccbfbdd0 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/IMessageEnumerator.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageEnumerator.cs
@@ -48,9 +48,9 @@ namespace Mono.Messaging {
 
 		IMessage RemoveCurrent();
 
-		//IMessage RemoveCurrent(MessageQueueTransaction transaction);
+		IMessage RemoveCurrent(IMessageQueueTransaction transaction);
 
-		//IMessage RemoveCurrent(MessageQueueTransactionType transactionType);
+		IMessage RemoveCurrent(MessageQueueTransactionType transactionType);
 
 		//IMessage RemoveCurrent(TimeSpan timeout);
 
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueue.cs b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueue.cs
index 4d0bc15504d..8146c503618 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueue.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueue.cs
@@ -107,10 +107,64 @@ namespace Mono.Messaging {
 			get; set;
 		}
 		
+		void Close ();
+		
+		void Purge ();
+		
 		void Send (IMessage message);
 		
+		void Send (IMessage message, IMessageQueueTransaction transaction);
+		
+		void Send (IMessage message, MessageQueueTransactionType transactionType);
+		
+		IMessage Peek ();
+		
+		IMessage Peek (TimeSpan timeout);
+		
+		IMessage PeekById (string id);
+		
+		IMessage PeekById (string id, TimeSpan timeout);
+		
+		IMessage PeekByCorrelationId (string correlationId);
+		
+		IMessage PeekByCorrelationId (string correlationId, TimeSpan timeout);
+		
 		IMessage Receive ();
 		
+		IMessage Receive (TimeSpan timeout);
+		
+		IMessage Receive (IMessageQueueTransaction transaction);
+		
+		IMessage Receive (TimeSpan timeout, IMessageQueueTransaction transaction);
+		
+		IMessage Receive (MessageQueueTransactionType transactionType);
+		
+		IMessage Receive (TimeSpan timeout, MessageQueueTransactionType transactionType);
+		
+		IMessage ReceiveById (string id);
+		
+		IMessage ReceiveById (string id, TimeSpan timeout);
+		
+		IMessage ReceiveById (string id, IMessageQueueTransaction transaction);
+		
+		IMessage ReceiveById (string id, MessageQueueTransactionType transactionType);
+		
+		IMessage ReceiveById (string id, TimeSpan timeout, IMessageQueueTransaction transaction);
+		
+		IMessage ReceiveById (string id, TimeSpan timeout, MessageQueueTransactionType transactionType);
+			
+		IMessage ReceiveByCorrelationId (string correlationId);
+		
+		IMessage ReceiveByCorrelationId (string correlationId, TimeSpan timeout);
+		
+		IMessage ReceiveByCorrelationId (string correlationId, IMessageQueueTransaction transaction);
+		
+		IMessage ReceiveByCorrelationId (string correlationId, MessageQueueTransactionType transactionType);
+		
+		IMessage ReceiveByCorrelationId (string correlationId, TimeSpan timeout, IMessageQueueTransaction transaction);
+			
+		IMessage ReceiveByCorrelationId (string correlationId, TimeSpan timeout, MessageQueueTransactionType transactionType);
+		
 		IMessageEnumerator GetMessageEnumerator ();
 	}
 
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueueTransaction.cs b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueueTransaction.cs
new file mode 100644
index 00000000000..d8a39e000bc
--- /dev/null
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/IMessageQueueTransaction.cs
@@ -0,0 +1,47 @@
+//
+// Mono.Messaging
+//
+// Authors:
+//		Michael Barker (mike@middlesoft.co.uk)
+//
+// (C) 2008 Michael Barker
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.ComponentModel;
+
+namespace Mono.Messaging {
+
+	public interface IMessageQueueTransaction : IDisposable {
+	
+		MessageQueueTransactionStatus Status { get; }
+		
+		void Abort ();
+		
+		void Begin ();
+		
+		void Commit ();
+	}
+
+}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/IMessagingProvider.cs b/mcs/class/Mono.Messaging/Mono.Messaging/IMessagingProvider.cs
index b32c61f7117..7293f45de83 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/IMessagingProvider.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/IMessagingProvider.cs
@@ -34,11 +34,18 @@ namespace Mono.Messaging {
 		
 		bool Exists (QueueReference qRef);
 		
-		IMessageQueue CreateMessageQueue (QueueReference qRef);
+		IMessageQueue CreateMessageQueue (QueueReference qRef,
+		                                  bool transactional);
 		
-		IMessageQueue GetMessageQueue ();
+		IMessageQueue GetMessageQueue (QueueReference qRef);
 
 		IMessage CreateMessage ();
+		
+		IMessageQueueTransaction CreateMessageQueueTransaction ();
+
+		void DeleteQueue (QueueReference qRef);
+		
+		IMessageQueue[] GetPublicQueues ();
 	}
 
 }
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/MessageBase.cs b/mcs/class/Mono.Messaging/Mono.Messaging/MessageBase.cs
index 8736b7291b8..7fcfad91ac1 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/MessageBase.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/MessageBase.cs
@@ -42,7 +42,7 @@ namespace Mono.Messaging {
 		DateTime arrivedTime;
 		bool attachSenderId = true;
 		bool authenticated;
-		string authenticationProviderName = "Microsoft Base Cryptographic Provider version 1.0";
+		string authenticationProviderName = "Microsoft Base Cryptographic Provider, Ver. 1.0";
 		CryptographicProviderType authenticationProviderType 
 			= CryptographicProviderType.RsaFull;
 		Stream bodyStream;
@@ -56,7 +56,7 @@ namespace Mono.Messaging {
 			= EncryptionAlgorithm.Rc2;
 		byte[] extension = new byte[0];
 		HashAlgorithm hashAlgorithm = HashAlgorithm.Sha;
-		string id = Guid.Empty.ToString ();
+		string id = Guid.Empty.ToString () + "\\0";
 		bool isFirstInTransaction = false;
 		bool isLastInTransaction = false;
 		string label = "";
@@ -71,7 +71,7 @@ namespace Mono.Messaging {
 		string sourceMachine;
 		TimeSpan timeToBeReceived;
 		TimeSpan timeToReachQueue;
-		string transactionId;
+		string transactionId = "";
 		IMessageQueue transactionStatusQueue;
 		bool useAuthentication;
 		bool useDeadLetterQueue;
@@ -162,7 +162,7 @@ namespace Mono.Messaging {
 			get { return destinationSymmetricKey; }
 			set { 
 				if (value == null)
-					throw new ArgumentException ("DestinationSymmetricKey can not be null");
+					throw new ArgumentNullException ("DestinationSymmetricKey can not be null");
 				destinationSymmetricKey = value;
 			}
 		}
@@ -171,7 +171,7 @@ namespace Mono.Messaging {
 			get { return digitalSignature; }
 			set {
 				if (value == null)
-					throw new ArgumentException ("DigitalSignature can not be null");
+					throw new ArgumentNullException ("DigitalSignature can not be null");
 				digitalSignature = value;
 			}
 		}
@@ -185,7 +185,7 @@ namespace Mono.Messaging {
 			get { return extension; }
 			set {
 				if (value == null)
-					throw new ArgumentException ("Extension can not be null");
+					throw new ArgumentNullException ("Extension can not be null");
 				extension = value;
 			}
 		}
@@ -197,21 +197,21 @@ namespace Mono.Messaging {
 
 		public string Id {
 			get { 
-				CheckDelivered ();
+				//CheckDelivered ();
 				return id;
 			}
 		}
 
 		public bool IsFirstInTransaction {
 			get { 
-				CheckDelivered ();
+				//CheckDelivered ();
 				return isFirstInTransaction;
 			}
 		}
 
 		public bool IsLastInTransaction {
 			get { 
-				CheckDelivered ();
+				//CheckDelivered ();
 				return isLastInTransaction;
 			}
 		}
@@ -288,7 +288,7 @@ namespace Mono.Messaging {
 
 		public string TransactionId {
 			get {  
-				CheckDelivered ();
+				//CheckDelivered ();
 				return transactionId;
 			}
 		}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionStatus.cs b/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionStatus.cs
new file mode 100644
index 00000000000..0c2d9467e7f
--- /dev/null
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionStatus.cs
@@ -0,0 +1,42 @@
+//
+// Mono.Messaging
+//
+// Authors:
+//      Michael Barker (mike@middlesoft.co.uk)
+//
+//	(C) Ximian, Inc.  http://www.ximian.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+
+namespace Mono.Messaging
+{
+	[Serializable]
+	public enum MessageQueueTransactionStatus
+	{
+		Aborted = 0,
+		Committed = 1,
+		Initialized = 2,
+		Pending = 3
+	}
+}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionType.cs b/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionType.cs
new file mode 100644
index 00000000000..dbb0e55ab1b
--- /dev/null
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/MessageQueueTransactionType.cs
@@ -0,0 +1,41 @@
+//
+// System.Messaging
+//
+// Authors:
+//      Michael Barker (mike@middlesoft.co.uk)
+//
+//	(C) Ximian, Inc.  http://www.ximian.com
+//
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+
+namespace Mono.Messaging 
+{
+	[Serializable]
+	public enum MessageQueueTransactionType 
+	{
+		Automatic = 1,
+		None = 0,
+		Single = 3
+	}
+}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/MessageUnavailableException.cs b/mcs/class/Mono.Messaging/Mono.Messaging/MessageUnavailableException.cs
new file mode 100644
index 00000000000..9ce979d2c43
--- /dev/null
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/MessageUnavailableException.cs
@@ -0,0 +1,28 @@
+// MessageUnavailableException.cs created with MonoDevelop
+// User: mike at 11:46 a 7/12/2008
+//
+// To change standard headers go to Edit->Preferences->Coding->Standard Headers
+//
+
+using System;
+
+namespace Mono.Messaging
+{
+	
+	
+	public class MessageUnavailableException : MonoMessagingException
+	{
+		public MessageUnavailableException () : base ()
+		{
+		}
+		
+		public MessageUnavailableException (string msg) : base (msg)
+		{
+		}
+		
+		public MessageUnavailableException (string msg, Exception e) 
+			: base (msg, e)
+		{
+		}
+	}
+}
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/MessagingProviderLocator.cs b/mcs/class/Mono.Messaging/Mono.Messaging/MessagingProviderLocator.cs
index 06324c079fb..2a647aa2a99 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/MessagingProviderLocator.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/MessagingProviderLocator.cs
@@ -34,6 +34,9 @@ namespace Mono.Messaging
 {
 	public class MessagingProviderLocator 
 	{
+		private static IMessagingProvider provider = null;
+		private static readonly object syncObj = new object();
+		
 		public static IMessagingProvider GetProvider ()
 		{
 			//Assembly a = Assembly.Load("Mono.Messaging.RabbitMQ.dll");
@@ -41,17 +44,21 @@ namespace Mono.Messaging
 			
 			//foreach (type in ts)
 			//	Console.WriteLine (type.GetName ());
-			
-			Type t = Type.GetType ("Mono.Messaging.RabbitMQ.RabbitMQMessagingProvider, Mono.Messaging.RabbitMQ");
-			if (t == null)
-				throw new Exception ("Can't find class");
-			ConstructorInfo ci = t.GetConstructor (
-				BindingFlags.Public | BindingFlags.Instance, 
-						Type.DefaultBinder, new Type[0],
-						new ParameterModifier[0]);
-			if (ci == null)
-				throw new Exception ("Can't find constructor");
-			return (IMessagingProvider) ci.Invoke (new object[0]);
+			lock (syncObj) {
+				if (provider == null) {
+					Type t = Type.GetType ("Mono.Messaging.RabbitMQ.RabbitMQMessagingProvider, Mono.Messaging.RabbitMQ");
+					if (t == null)
+						throw new Exception ("Can't find class");
+					ConstructorInfo ci = t.GetConstructor (
+						BindingFlags.Public | BindingFlags.Instance, 
+								Type.DefaultBinder, new Type[0],
+								new ParameterModifier[0]);
+					if (ci == null)
+						throw new Exception ("Can't find constructor");
+					provider = (IMessagingProvider) ci.Invoke (new object[0]);
+				}
+			}
+			return provider;
 		}
 	}
 }
diff --git a/mcs/class/Mono.Messaging/Mono.Messaging/QueueReference.cs b/mcs/class/Mono.Messaging/Mono.Messaging/QueueReference.cs
index dd19286316a..e9770b65c37 100644
--- a/mcs/class/Mono.Messaging/Mono.Messaging/QueueReference.cs
+++ b/mcs/class/Mono.Messaging/Mono.Messaging/QueueReference.cs
@@ -59,7 +59,12 @@ namespace Mono.Messaging
 		}
 		
 		public string Queue {
-			get { return queue; }
+			get { 
+				if (isPrivate)
+					return @"private$\" + queue;
+				else
+					return queue;
+			}
 		}
 		
 		public bool IsPrivate {
@@ -97,6 +102,11 @@ namespace Mono.Messaging
 				&& queue == other.queue;
 		}
 		
+		public override int GetHashCode ()
+		{
+			return queue == null ? 0 : queue.GetHashCode () + host.GetHashCode ();
+		}
+		
 		public static QueueReference Parse (string path)
 		{
 			string trimedPath = RemoveLeadingSlashes (path);
@@ -115,7 +125,7 @@ namespace Mono.Messaging
 		
 		public static bool IsPrivateStr (string s)
 		{
-			return "$private" == s.ToLower ();
+			return "private$" == s.ToLower ();
 		}
 		
 		public static string RemoveLeadingSlashes (string s)
diff --git a/mcs/class/RabbitMQ.Client/ChangeLog b/mcs/class/RabbitMQ.Client/ChangeLog
index c0493cc454f..a95e12df982 100644
--- a/mcs/class/RabbitMQ.Client/ChangeLog
+++ b/mcs/class/RabbitMQ.Client/ChangeLog
@@ -1,3 +1,8 @@
+2008-12-07  Michael BArker  <mike@middlesoft.co.uk>
+
+	* Makefile:  Removed apigen, bootstrap and spec.  The code for
+	the generated interfaces is added to source control.
+
 2008-10-20  Atsushi Enomoto  <atsushi@ximian.com>
 
 	(This ChangeLog is for Mono integration.)
diff --git a/mcs/class/RabbitMQ.Client/Makefile b/mcs/class/RabbitMQ.Client/Makefile
index a636155a8cc..cb4c9979a0c 100644
--- a/mcs/class/RabbitMQ.Client/Makefile
+++ b/mcs/class/RabbitMQ.Client/Makefile
@@ -2,7 +2,8 @@ thisdir := class/RabbitMQ.Client
 
 include ../../build/rules.make
 
-SUBDIRS := src/bootstrap src/apigen docs/specs src/client
+#SUBDIRS := src/bootstrap src/apigen docs/specs src/client
+SUBDIRS := src/client
 
 .PHONY: all-local $(STD_TARGETS:=-local)
 all-local $(STD_TARGETS:=-local):
diff --git a/mcs/class/RabbitMQ.Client/docs/specs/Makefile b/mcs/class/RabbitMQ.Client/docs/specs/Makefile
index 1008f1ac477..4b01a833b0d 100644
--- a/mcs/class/RabbitMQ.Client/docs/specs/Makefile
+++ b/mcs/class/RabbitMQ.Client/docs/specs/Makefile
@@ -2,29 +2,24 @@ thisdir = class/RabbitMQ.Client/docs/specs
 SUBDIRS =
 include ../../../../build/rules.make
 
-all-local: copy autogenerated-api-0-9.cs autogenerated-api-0-8.cs autogenerated-api-qpid-0-8.cs
+all-local: autogenerated-api-0-9.cs autogenerated-api-0-8.cs autogenerated-api-qpid-0-8.cs
 
 copy:
 	cp ../../../lib/net_2_0/apigen-bootstrap.dll ../../src/apigen/.
 	
 autogenerated-api-0-9.cs: amqp0-9.xml
-	$(RUNTIME) ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_9 "/apiName:AMQP_0_9" $^ $@
+	mono ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_9 "/apiName:AMQP_0_9" $^ $@
 
 autogenerated-api-0-8.cs: amqp0-8.xml
-	$(RUNTIME) ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_8 "/apiName:AMQP_0_8" $^ $@
+	mono ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_8 "/apiName:AMQP_0_8" $^ $@
 	
 autogenerated-api-qpid-0-8.cs: qpid-amqp.0-8.xml
-	$(RUNTIME) ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_8qpid "/apiName:AMQP_0_8_QPID" $^ $@
-	
-#mono RabbitMQ.Client.Apigen.exe "/apiName:AMQP_0_8_QPID" /n:v0_8qpid ../docs/specs/qpid-amqp.0-8.xml autogenerated-api-qpid-0-8.cs
-#mono RabbitMQ.Client.Apigen.exe "/apiName:AMQP_0_8" /n:v0_8 ../docs/specs/amqp0-8.xml autogenerated-api-0-8.cs
-
+	mono ../../src/apigen/RabbitMQ.Client.Apigen.exe /n:v0_8qpid "/apiName:AMQP_0_8_QPID" $^ $@
 
 install-local:
 
 clean-local:
 	rm -f ../../src/apigen/apigen-bootstrap.dll
-	rm -f *.cs
 	
 test-local:
 
diff --git a/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-8.cs b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-8.cs
new file mode 100644
index 00000000000..7ab99176d18
--- /dev/null
+++ b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-8.cs
@@ -0,0 +1,8072 @@
+// Autogenerated code. Do not edit.
+
+using RabbitMQ.Client;
+using RabbitMQ.Client.Exceptions;
+
+namespace RabbitMQ.Client.Framing.v0_8 {
+  public class Protocol: RabbitMQ.Client.Framing.Impl.v0_8.ProtocolBase {
+    ///<summary>Protocol major version (= 8)</summary>
+    public override int MajorVersion { get { return 8; } }
+    ///<summary>Protocol minor version (= 0)</summary>
+    public override int MinorVersion { get { return 0; } }
+    ///<summary>Protocol API name (= AMQP_0_8)</summary>
+    public override string ApiName { get { return "AMQP_0_8"; } }
+    ///<summary>Default TCP port (= 5672)</summary>
+    public override int DefaultPort { get { return 5672; } }
+
+    public override RabbitMQ.Client.Impl.MethodBase DecodeMethodFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+      ushort methodId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 10: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionStart result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionSecure result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionSecure();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionSecureOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionSecureOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionTune result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionTune();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionTuneOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionTuneOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionOpen result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionRedirect result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionRedirect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionClose result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 61: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ConnectionCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ConnectionCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 20: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelOpen result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelFlow result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelFlow();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelFlowOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelFlowOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelAlert result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelAlert();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelClose result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ChannelCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ChannelCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 30: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.AccessRequest result = new RabbitMQ.Client.Framing.Impl.v0_8.AccessRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.AccessRequestOk result = new RabbitMQ.Client.Framing.Impl.v0_8.AccessRequestOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 40: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDelete result = new RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8.ExchangeDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 50: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueBind result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueBind();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueBindOk result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueBindOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueuePurge result = new RabbitMQ.Client.Framing.Impl.v0_8.QueuePurge();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueuePurgeOk result = new RabbitMQ.Client.Framing.Impl.v0_8.QueuePurgeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueDelete result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8.QueueDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8.QueueDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 60: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicQos result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicConsume result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicCancel result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicPublish result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicReturn result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicGet result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicGet();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 71: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicGetOk result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicGetOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 72: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicGetEmpty result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicGetEmpty();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicAck result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicReject result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_8.BasicRecover result = new RabbitMQ.Client.Framing.Impl.v0_8.BasicRecover();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 70: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileQos result = new RabbitMQ.Client.Framing.Impl.v0_8.FileQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8.FileQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileConsume result = new RabbitMQ.Client.Framing.Impl.v0_8.FileConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8.FileConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileCancel result = new RabbitMQ.Client.Framing.Impl.v0_8.FileCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8.FileCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileOpen result = new RabbitMQ.Client.Framing.Impl.v0_8.FileOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8.FileOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileStage result = new RabbitMQ.Client.Framing.Impl.v0_8.FileStage();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FilePublish result = new RabbitMQ.Client.Framing.Impl.v0_8.FilePublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileReturn result = new RabbitMQ.Client.Framing.Impl.v0_8.FileReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8.FileDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileAck result = new RabbitMQ.Client.Framing.Impl.v0_8.FileAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_8.FileReject result = new RabbitMQ.Client.Framing.Impl.v0_8.FileReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 80: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamQos result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamConsume result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamCancel result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamPublish result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamReturn result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8.StreamDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8.StreamDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 90: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8.TxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxCommit result = new RabbitMQ.Client.Framing.Impl.v0_8.TxCommit();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxCommitOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TxCommitOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxRollback result = new RabbitMQ.Client.Framing.Impl.v0_8.TxRollback();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TxRollbackOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TxRollbackOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 100: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.DtxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8.DtxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.DtxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8.DtxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.DtxStart result = new RabbitMQ.Client.Framing.Impl.v0_8.DtxStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.DtxStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8.DtxStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 110: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TunnelRequest result = new RabbitMQ.Client.Framing.Impl.v0_8.TunnelRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 120: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestInteger result = new RabbitMQ.Client.Framing.Impl.v0_8.TestInteger();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestIntegerOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TestIntegerOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestString result = new RabbitMQ.Client.Framing.Impl.v0_8.TestString();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestStringOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TestStringOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestTable result = new RabbitMQ.Client.Framing.Impl.v0_8.TestTable();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestTableOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TestTableOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestContent result = new RabbitMQ.Client.Framing.Impl.v0_8.TestContent();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8.TestContentOk result = new RabbitMQ.Client.Framing.Impl.v0_8.TestContentOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, methodId);
+    }
+
+    public override RabbitMQ.Client.Impl.ContentHeaderBase DecodeContentHeaderFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 60: return new BasicProperties();
+        case 70: return new FileProperties();
+        case 80: return new StreamProperties();
+        case 110: return new TunnelProperties();
+        case 120: return new TestProperties();
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, 0);
+    }
+  }
+  public class Constants {
+    ///<summary>(= 1)</summary>
+    public const int FrameMethod = 1;
+    ///<summary>(= 2)</summary>
+    public const int FrameHeader = 2;
+    ///<summary>(= 3)</summary>
+    public const int FrameBody = 3;
+    ///<summary>(= 4)</summary>
+    public const int FrameOobMethod = 4;
+    ///<summary>(= 5)</summary>
+    public const int FrameOobHeader = 5;
+    ///<summary>(= 6)</summary>
+    public const int FrameOobBody = 6;
+    ///<summary>(= 7)</summary>
+    public const int FrameTrace = 7;
+    ///<summary>(= 8)</summary>
+    public const int FrameHeartbeat = 8;
+    ///<summary>(= 4096)</summary>
+    public const int FrameMinSize = 4096;
+    ///<summary>(= 206)</summary>
+    public const int FrameEnd = 206;
+    ///<summary>(= 200)</summary>
+    public const int ReplySuccess = 200;
+    ///<summary>(= 310)</summary>
+    public const int NotDelivered = 310;
+    ///<summary>(= 311)</summary>
+    public const int ContentTooLarge = 311;
+    ///<summary>(= 320)</summary>
+    public const int ConnectionForced = 320;
+    ///<summary>(= 402)</summary>
+    public const int InvalidPath = 402;
+    ///<summary>(= 403)</summary>
+    public const int AccessRefused = 403;
+    ///<summary>(= 404)</summary>
+    public const int NotFound = 404;
+    ///<summary>(= 405)</summary>
+    public const int ResourceLocked = 405;
+    ///<summary>(= 501)</summary>
+    public const int FrameError = 501;
+    ///<summary>(= 502)</summary>
+    public const int SyntaxError = 502;
+    ///<summary>(= 503)</summary>
+    public const int CommandInvalid = 503;
+    ///<summary>(= 504)</summary>
+    public const int ChannelError = 504;
+    ///<summary>(= 506)</summary>
+    public const int ResourceError = 506;
+    ///<summary>(= 530)</summary>
+    public const int NotAllowed = 530;
+    ///<summary>(= 540)</summary>
+    public const int NotImplemented = 540;
+    ///<summary>(= 541)</summary>
+    public const int InternalError = 541;
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start".</summary>
+  /// <remarks>
+  /// 
+  ///     This method starts the connection negotiation process by telling
+  ///     the client the protocol version that the server proposes, along
+  ///     with a list of security mechanisms which the client can use for
+  ///     authentication.
+  ///   
+  /// </remarks>
+  public interface IConnectionStart: IMethod {
+    /// <summary>
+    /// 
+    ///       The protocol major version that the server agrees to use, which
+    ///       cannot be higher than the client's major version.
+    ///     
+    /// </summary>
+    byte VersionMajor { get; }
+    /// <summary>
+    /// 
+    ///       The protocol minor version that the server agrees to use, which
+    ///       cannot be higher than the client's minor version.
+    ///     
+    /// </summary>
+    byte VersionMinor { get; }
+    // (no documentation)
+    System.Collections.IDictionary ServerProperties { get; }
+    /// <summary>
+    /// 
+    ///       A list of the security mechanisms that the server supports, delimited
+    ///       by spaces.  Currently ASL supports these mechanisms: PLAIN.
+    ///     
+    /// </summary>
+    byte[] Mechanisms { get; }
+    /// <summary>
+    /// 
+    ///       A list of the message locales that the server supports, delimited
+    ///       by spaces.  The locale defines the language in which the server
+    ///       will send reply texts.
+    ///     
+    /// </summary>
+    byte[] Locales { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method selects a SASL security mechanism. ASL uses SASL
+  ///     (RFC2222) to negotiate authentication and encryption.
+  ///   
+  /// </remarks>
+  public interface IConnectionStartOk: IMethod {
+    // (no documentation)
+    System.Collections.IDictionary ClientProperties { get; }
+    /// <summary>
+    /// 
+    ///       A single security mechanisms selected by the client, which must be
+    ///       one of those specified by the server.
+    ///     
+    /// </summary>
+    string Mechanism { get; }
+    /// <summary>
+    /// 
+    ///       A block of opaque data passed to the security mechanism. The contents
+    ///       of this data are defined by the SASL security mechanism.  For the
+    ///       PLAIN security mechanism this is defined as a field table holding
+    ///       two fields, LOGIN and PASSWORD.
+    ///     
+    /// </summary>
+    byte[] Response { get; }
+    /// <summary>
+    /// 
+    ///       A single message local selected by the client, which must be one
+    ///       of those specified by the server.
+    ///     
+    /// </summary>
+    string Locale { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure".</summary>
+  /// <remarks>
+  /// 
+  ///     The SASL protocol works by exchanging challenges and responses until
+  ///     both peers have received sufficient information to authenticate each
+  ///     other.  This method challenges the client to provide more information.
+  ///   
+  /// </remarks>
+  public interface IConnectionSecure: IMethod {
+    /// <summary>
+    /// 
+    ///       Challenge information, a block of opaque binary data passed to
+    ///       the security mechanism.
+    ///     
+    /// </summary>
+    byte[] Challenge { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method attempts to authenticate, passing a block of SASL data
+  ///     for the security mechanism at the server side.
+  ///   
+  /// </remarks>
+  public interface IConnectionSecureOk: IMethod {
+    /// <summary>
+    /// 
+    ///       A block of opaque data passed to the security mechanism.  The contents
+    ///       of this data are defined by the SASL security mechanism.
+    ///     
+    /// </summary>
+    byte[] Response { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune".</summary>
+  /// <remarks>
+  /// 
+  ///     This method proposes a set of connection configuration values
+  ///     to the client.  The client can accept and/or adjust these.
+  ///   
+  /// </remarks>
+  public interface IConnectionTune: IMethod {
+    /// <summary>
+    /// 
+    ///       The maximum total number of channels that the server allows
+    ///       per connection. Zero means that the server does not impose a
+    ///       fixed limit, but the number of allowed channels may be limited
+    ///       by available server resources.
+    ///     
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///       The largest frame size that the server proposes for the
+    ///       connection. The client can negotiate a lower value.  Zero means
+    ///       that the server does not impose any specific limit but may reject
+    ///       very large frames if it cannot allocate resources for them.
+    ///     
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///       The delay, in seconds, of the connection heartbeat that the server
+    ///       wants.  Zero means the server does not want a heartbeat.
+    ///     
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sends the client's connection tuning parameters to the
+  ///     server. Certain fields are negotiated, others provide capability
+  ///     information.
+  ///   
+  /// </remarks>
+  public interface IConnectionTuneOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The maximum total number of channels that the client will use
+    ///       per connection.  May not be higher than the value specified by
+    ///       the server.
+    ///     
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///       The largest frame size that the client and server will use for
+    ///       the connection.  Zero means that the client does not impose any
+    ///       specific limit but may reject very large frames if it cannot
+    ///       allocate resources for them.  Note that the frame-max limit
+    ///       applies principally to content frames, where large contents
+    ///       can be broken into frames of arbitrary size.
+    ///     
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///       The delay, in seconds, of the connection heartbeat that the client
+    ///       wants. Zero means the client does not want a heartbeat.
+    ///     
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method opens a connection to a virtual host, which is a
+  ///     collection of resources, and acts to separate multiple application
+  ///     domains within a server.
+  ///   
+  /// </remarks>
+  public interface IConnectionOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       The name of the virtual host to work with.
+    ///     
+    /// </summary>
+    string VirtualHost { get; }
+    /// <summary>
+    /// 
+    ///       The client may specify a number of capability names, delimited by
+    ///       spaces.  The server can use this string to how to process the
+    ///       client's connection request.
+    ///     
+    /// </summary>
+    string Capabilities { get; }
+    /// <summary>
+    /// 
+    ///       In a configuration with multiple load-sharing servers, the server
+    ///       may respond to a Connection.Open method with a Connection.Redirect.
+    ///       The insist option tells the server that the client is insisting on
+    ///       a connection to the specified server.
+    ///     
+    /// </summary>
+    bool Insist { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method signals to the client that the connection is ready for
+  ///     use.
+  ///   
+  /// </remarks>
+  public interface IConnectionOpenOk: IMethod {
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.redirect".</summary>
+  /// <remarks>
+  /// 
+  ///     This method redirects the client to another server, based on the
+  ///     requested virtual host and/or capabilities.
+  ///   
+  /// </remarks>
+  public interface IConnectionRedirect: IMethod {
+    /// <summary>
+    /// 
+    ///       Specifies the server to connect to.  This is an IP address or a
+    ///       DNS name, optionally followed by a colon and a port number. If
+    ///       no port number is specified, the client should use the default
+    ///       port number for the protocol.
+    ///     
+    /// </summary>
+    string Host { get; }
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close".</summary>
+  /// <remarks>
+  /// 
+  ///     This method indicates that the sender wants to close the connection.
+  ///     This may be due to internal conditions (e.g. a forced shut-down) or
+  ///     due to an error handling a specific method, i.e. an exception.  When
+  ///     a close is due to an exception, the sender provides the class and
+  ///     method id of the method which caused the exception.
+  ///   
+  /// </remarks>
+  public interface IConnectionClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       class of the method.
+    ///     
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       ID of the method.
+    ///     
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Connection.Close method and tells the
+  ///     recipient that it is safe to release resources for the connection
+  ///     and close the socket.
+  ///   
+  /// </remarks>
+  public interface IConnectionCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method opens a virtual connection (a channel).
+  ///   
+  /// </remarks>
+  public interface IChannelOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       Configures out-of-band transfers on this channel.  The syntax and
+    ///       meaning of this field will be formally defined at a later date.
+    ///     
+    /// </summary>
+    string OutOfBand { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method signals to the client that the channel is ready for use.
+  ///   
+  /// </remarks>
+  public interface IChannelOpenOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the peer to pause or restart the flow of content
+  ///     data. This is a simple flow-control mechanism that a peer can use
+  ///     to avoid oveflowing its queues or otherwise finding itself receiving
+  ///     more messages than it can process.  Note that this method is not
+  ///     intended for window control.  The peer that receives a request to
+  ///     stop sending content should finish sending the current content, if
+  ///     any, and then wait until it receives a Flow restart method.
+  ///   
+  /// </remarks>
+  public interface IChannelFlow: IMethod {
+    /// <summary>
+    /// 
+    ///       If 1, the peer starts sending content frames.  If 0, the peer
+    ///       stops sending content frames.
+    ///     
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     Confirms to the peer that a flow command was received and processed.
+  ///   
+  /// </remarks>
+  public interface IChannelFlowOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Confirms the setting of the processed flow method: 1 means the
+    ///       peer will start sending or continue to send content frames; 0
+    ///       means it will not.
+    ///     
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.alert".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows the server to send a non-fatal warning to the
+  ///     client.  This is used for methods that are normally asynchronous
+  ///     and thus do not have confirmations, and for which the server may
+  ///     detect errors that need to be reported.  Fatal errors are handled
+  ///     as channel or connection exceptions; non-fatal errors are sent
+  ///     through this method.
+  ///   
+  /// </remarks>
+  public interface IChannelAlert: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       A set of fields that provide more information about the
+    ///       problem.  The meaning of these fields are defined on a
+    ///       per-reply-code basis (TO BE DEFINED).
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Details { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close".</summary>
+  /// <remarks>
+  /// 
+  ///     This method indicates that the sender wants to close the channel.
+  ///     This may be due to internal conditions (e.g. a forced shut-down) or
+  ///     due to an error handling a specific method, i.e. an exception.  When
+  ///     a close is due to an exception, the sender provides the class and
+  ///     method id of the method which caused the exception.
+  ///   
+  /// </remarks>
+  public interface IChannelClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       class of the method.
+    ///     
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       ID of the method.
+    ///     
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Channel.Close method and tells the recipient
+  ///     that it is safe to release resources for the channel and close the
+  ///     socket.
+  ///   
+  /// </remarks>
+  public interface IChannelCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests an access ticket for an access realm.
+  ///     The server responds by granting the access ticket.  If the
+  ///     client does not have access rights to the requested realm
+  ///     this causes a connection exception.  Access tickets are a
+  ///     per-channel resource.
+  ///   
+  /// </remarks>
+  public interface IAccessRequest: IMethod {
+    // (no documentation)
+    string Realm { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive access to the realm. If the server cannot grant
+    ///       this - because there are other active tickets for the realm - it
+    ///       raises a channel exception.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///       Request message passive access to the specified access realm.
+    ///       Passive access lets a client get information about resources in
+    ///       the realm but not to make any changes to them.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       Request message active access to the specified access realm.
+    ///       Acvtive access lets a client get create and delete resources in
+    ///       the realm.
+    ///     
+    /// </summary>
+    bool Active { get; }
+    /// <summary>
+    /// 
+    ///       Request write access to the specified access realm.  Write access
+    ///       lets a client publish messages to all exchanges in the realm.
+    ///     
+    /// </summary>
+    bool Write { get; }
+    /// <summary>
+    /// 
+    ///       Request read access to the specified access realm.  Read access
+    ///       lets a client consume messages from queues in the realm.
+    ///     
+    /// </summary>
+    bool Read { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with an access ticket. The access
+  ///     ticket is valid within the current channel and for the lifespan of
+  ///     the channel.
+  ///   
+  /// </remarks>
+  public interface IAccessRequestOk: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare".</summary>
+  /// <remarks>
+  /// 
+  ///     This method creates an exchange if it does not already exist, and if the
+  ///     exchange exists, verifies that it is of the correct and expected class.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///       When a client defines a new exchange, this belongs to the access realm
+    ///       of the ticket used.  All further work done with that exchange must be
+    ///       done with an access ticket for the same realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Each exchange belongs to one of a set of exchange types implemented
+    ///       by the server.  The exchange types define the functionality of the
+    ///       exchange - i.e. how messages are routed through it.  It is not valid
+    ///       or meaningful to attempt to change the type of an existing exchange.
+    ///     
+    /// </summary>
+    string Type { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not create the exchange.  The client can use
+    ///     this to check whether an exchange exists without modifying the server
+    ///     state.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       If set when creating a new exchange, the exchange will be marked as
+    ///       durable.  Durable exchanges remain active when a server restarts.
+    ///       Non-durable exchanges (transient exchanges) are purged if/when a
+    ///       server restarts.
+    ///     
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///       If set, the exchange is deleted when all queues have finished
+    ///       using it.
+    ///     
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///       If set, the exchange may not be used directly by publishers, but
+    ///       only when bound to other exchanges. Internal exchanges are used to
+    ///       construct wiring that is not visible to applications.
+    ///     
+    /// </summary>
+    bool Internal { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the declaration. The syntax and semantics
+    ///       of these arguments depends on the server implementation.  This
+    ///       field is ignored if passive is 1.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Declare method and confirms the name of the
+  ///     exchange, essential for automatically-named exchanges.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeclareOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete".</summary>
+  /// <remarks>
+  /// 
+  ///     This method deletes an exchange.  When an exchange is deleted all queue
+  ///     bindings on the exchange are cancelled.
+  ///   
+  /// </remarks>
+  public interface IExchangeDelete: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the exchange if it has no queue
+    ///       bindings. If the exchange has queue bindings the server does not
+    ///       delete it but raises a channel exception instead.
+    ///     
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the deletion of an exchange.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeleteOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare".</summary>
+  /// <remarks>
+  /// 
+  ///     This method creates or checks a queue.  When creating a new queue
+  ///     the client can specify various properties that control the durability
+  ///     of the queue and its contents, and the level of sharing for the queue.
+  ///   
+  /// </remarks>
+  public interface IQueueDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///       When a client defines a new queue, this belongs to the access realm
+    ///       of the ticket used.  All further work done with that queue must be
+    ///       done with an access ticket for the same realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not create the queue.  The client can use
+    ///     this to check whether a queue exists without modifying the server
+    ///     state.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       If set when creating a new queue, the queue will be marked as
+    ///       durable.  Durable queues remain active when a server restarts.
+    ///       Non-durable queues (transient queues) are purged if/when a
+    ///       server restarts.  Note that durable queues do not necessarily
+    ///       hold persistent messages, although it does not make sense to
+    ///       send persistent messages to a transient queue.
+    ///     
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///       Exclusive queues may only be consumed from by the current connection.
+    ///       Setting the 'exclusive' flag always implies 'auto-delete'.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///       If set, the queue is deleted when all consumers have finished
+    ///       using it. Last consumer can be cancelled either explicitly or because
+    ///       its channel is closed. If there was no consumer ever on the queue, it
+    ///       won't be deleted.
+    ///     
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the declaration. The syntax and semantics
+    ///       of these arguments depends on the server implementation.  This
+    ///       field is ignored if passive is 1.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Declare method and confirms the name of the
+  ///     queue, essential for automatically-named queues.
+  ///   
+  /// </remarks>
+  public interface IQueueDeclareOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the name of the queue. If the server generated a queue
+    ///       name, this field contains that name.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Reports the number of messages in the queue, which will be zero
+    ///       for newly-created queues.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+    /// <summary>
+    /// 
+    ///       Reports the number of active consumers for the queue. Note that
+    ///       consumers can suspend activity (Channel.Flow) in which case they
+    ///       do not appear in this count.
+    ///     
+    /// </summary>
+    uint ConsumerCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind".</summary>
+  /// <remarks>
+  /// 
+  ///     This method binds a queue to an exchange.  Until a queue is
+  ///     bound it will not receive any messages.  In a classic messaging
+  ///     model, store-and-forward queues are bound to a dest exchange
+  ///     and subscription queues are bound to a dest_wild exchange.
+  ///   
+  /// </remarks>
+  public interface IQueueBind: IMethod {
+    /// <summary>
+    /// 
+    ///       The client provides a valid access ticket giving "active"
+    ///       access rights to the queue's access realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to bind.  If the queue name is
+    ///       empty, refers to the current queue for the channel, which is
+    ///       the last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the binding.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///       Not all exchanges use a routing key - refer to the specific
+    ///       exchange documentation.  If the routing key is empty and the queue
+    ///       name is empty, the routing key will be the current queue for the
+    ///       channel, which is the last declared queue.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the binding.  The syntax and semantics of
+    ///       these arguments depends on the exchange class.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the bind was successful.
+  ///   
+  /// </remarks>
+  public interface IQueueBindOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge".</summary>
+  /// <remarks>
+  /// 
+  ///     This method removes all messages from a queue.  It does not cancel
+  ///     consumers.  Purged messages are deleted without any formal "undo"
+  ///     mechanism.
+  ///   
+  /// </remarks>
+  public interface IQueuePurge: IMethod {
+    /// <summary>
+    /// 
+    ///       The access ticket must be for the access realm that holds the
+    ///       queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to purge.  If the queue name is
+    ///       empty, refers to the current queue for the channel, which is
+    ///       the last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the purge of a queue.
+  ///   
+  /// </remarks>
+  public interface IQueuePurgeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the number of messages purged.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete".</summary>
+  /// <remarks>
+  /// 
+  ///     This method deletes a queue.  When a queue is deleted any pending
+  ///     messages are sent to a dead-letter queue if this is defined in the
+  ///     server configuration, and all consumers on the queue are cancelled.
+  ///   
+  /// </remarks>
+  public interface IQueueDelete: IMethod {
+    /// <summary>
+    /// 
+    ///       The client provides a valid access ticket giving "active"
+    ///       access rights to the queue's access realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to delete. If the queue name is
+    ///       empty, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the queue if it has no
+    ///       consumers. If the queue has consumers the server does does not
+    ///       delete it but raises a channel exception instead.
+    ///     
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the queue if it has no
+    ///       messages. If the queue is not empty the server raises a channel
+    ///       exception.
+    ///     
+    /// </summary>
+    bool IfEmpty { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the deletion of a queue.
+  ///   
+  /// </remarks>
+  public interface IQueueDeleteOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the number of messages purged.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IBasicQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets.  The
+    ///       server will send a message in advance if it is equal to or
+    ///       smaller in size than the available prefetch size (and also falls
+    ///       into other prefetch limits). May be set to zero, meaning "no
+    ///       specific limit", although other prefetch limits may still apply.
+    ///       The prefetch-size is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       field may be used in combination with the prefetch-size field;
+    ///       a message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///       The prefetch-count is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IBasicQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IBasicConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     The server provides the client with a consumer tag, which is used
+  ///     by the client for methods called on the consumer at a later stage.
+  ///   
+  /// </remarks>
+  public interface IBasicConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer. This does not affect already
+  ///     delivered messages, but it does mean the server will not send any
+  ///     more messages for that consumer.  The client may receive an
+  ///     abitrary number of messages in between sending the cancel method
+  ///     and receiving the cancel-ok reply.
+  ///   
+  /// </remarks>
+  public interface IBasicCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IBasicCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a message to a specific exchange. The message
+  ///     will be routed to queues as defined by the exchange configuration
+  ///     and distributed to any active consumers when the transaction, if any,
+  ///     is committed.
+  ///   
+  /// </remarks>
+  public interface IBasicPublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IBasicReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client, via a consumer.  In
+  ///     the asynchronous message delivery model, the client starts a
+  ///     consumer using the Consume method, then the server responds with
+  ///     Deliver methods as and when messages arrive for that consumer.
+  ///   
+  /// </remarks>
+  public interface IBasicDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides a direct access to the messages in a queue
+  ///     using a synchronous dialogue that is designed for specific types of
+  ///     application where synchronous functionality is more important than
+  ///     performance.
+  ///   
+  /// </remarks>
+  public interface IBasicGet: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read"
+    ///       access rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    bool NoAck { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client following a get
+  ///     method.  A message delivered by 'get-ok' must be acknowledged
+  ///     unless the no-ack option was set in the get method.
+  ///   
+  /// </remarks>
+  public interface IBasicGetOk: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.  If empty, the message was published to the default
+    ///       exchange.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This field reports the number of messages pending on the queue,
+    ///       excluding the message being delivered.  Note that this figure is
+    ///       indicative, not reliable, and can change arbitrarily as messages
+    ///       are added to the queue and removed by other clients.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-empty".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the queue has no messages
+  ///     available for the client.
+  ///   
+  /// </remarks>
+  public interface IBasicGetEmpty: IMethod {
+    /// <summary>
+    /// 
+    ///       For use by cluster applications, should not be used by
+    ///       client applications.
+    ///     
+    /// </summary>
+    string ClusterId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.ack".</summary>
+  /// <remarks>
+  /// 
+  ///     This method acknowledges one or more messages delivered via the
+  ///     Deliver or Get-Ok methods.  The client can ask to confirm a
+  ///     single message or a set of messages up to and including a specific
+  ///     message.
+  ///   
+  /// </remarks>
+  public interface IBasicAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If set to 1, the delivery tag is treated as "up to and including",
+    ///       so that the client can acknowledge multiple messages with a single
+    ///       method.  If set to zero, the delivery tag refers to a single
+    ///       message.  If the multiple field is 1, and the delivery tag is zero,
+    ///       tells the server to acknowledge all outstanding mesages.
+    ///     
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.reject".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows a client to reject a message.  It can be used to
+  ///     interrupt and cancel large incoming messages, or return untreatable
+  ///     messages to their original queue.
+  ///   
+  /// </remarks>
+  public interface IBasicReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be discarded.  If this bit
+    ///       is 1, the server will attempt to requeue the message.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.recover".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the broker to redeliver all unacknowledged messages on a
+  ///     specifieid channel. Zero or more messages may be redelivered.
+  ///   
+  /// </remarks>
+  public interface IBasicRecover: IMethod {
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be redelivered to the original recipient.  If this bit
+    ///       is 1, the server will attempt to requeue the message, potentially then delivering it to an
+    ///       alternative subscriber.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IFileQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets. May be
+    ///       set to zero, meaning "no specific limit".  Note that other
+    ///       prefetch limits may still apply. The prefetch-size is ignored
+    ///       if the no-ack option is set.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       is compatible with some file API implementations.  This field
+    ///       may be used in combination with the prefetch-size field; a
+    ///       message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///       The prefetch-count is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IFileQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IFileConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with a consumer tag which it MUST
+  ///     use in methods that work with the consumer.
+  ///   
+  /// </remarks>
+  public interface IFileConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer. This does not affect already
+  ///     delivered messages, but it does mean the server will not send any
+  ///     more messages for that consumer.
+  ///   
+  /// </remarks>
+  public interface IFileCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IFileCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests permission to start staging a message.  Staging
+  ///     means sending the message into a temporary area at the recipient end
+  ///     and then delivering the message by referring to this temporary area.
+  ///     Staging is how the protocol handles partial file transfers - if a
+  ///     message is partially staged and the connection breaks, the next time
+  ///     the sender starts to stage it, it can restart from where it left off.
+  ///   
+  /// </remarks>
+  public interface IFileOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       This is the staging identifier. This is an arbitrary string chosen
+    ///       by the sender.  For staging to work correctly the sender must use
+    ///       the same staging identifier when staging the same message a second
+    ///       time after recovery from a failure.  A good choice for the staging
+    ///       identifier would be the SHA1 hash of the message properties data
+    ///       (including the original filename, revised time, etc.).
+    ///     
+    /// </summary>
+    string Identifier { get; }
+    /// <summary>
+    /// 
+    ///       The size of the content in octets.  The recipient may use this
+    ///       information to allocate or check available space in advance, to
+    ///       avoid "disk full" errors during staging of very large messages.
+    ///     
+    /// </summary>
+    ulong ContentSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the recipient is ready to accept staged
+  ///     data.  If the message was already partially-staged at a previous
+  ///     time the recipient will report the number of octets already staged.
+  ///   
+  /// </remarks>
+  public interface IFileOpenOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The amount of previously-staged content in octets.  For a new
+    ///       message this will be zero.
+    ///     
+    /// </summary>
+    ulong StagedSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.stage".</summary>
+  /// <remarks>
+  /// 
+  ///     This method stages the message, sending the message content to the
+  ///     recipient from the octet offset specified in the Open-Ok method.
+  ///   
+  /// </remarks>
+  public interface IFileStage: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a staged file message to a specific exchange.
+  ///     The file message will be routed to queues as defined by the exchange
+  ///     configuration and distributed to any active consumers when the
+  ///     transaction, if any, is committed.
+  ///   
+  /// </remarks>
+  public interface IFilePublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+    /// <summary>
+    /// 
+    ///       This is the staging identifier of the message to publish.  The
+    ///       message must have been staged.  Note that a client can send the
+    ///       Publish method asynchronously without waiting for staging to
+    ///       finish.
+    ///     
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IFileReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a staged file message to the client, via a
+  ///     consumer. In the asynchronous message delivery model, the client
+  ///     starts a consumer using the Consume method, then the server
+  ///     responds with Deliver methods as and when messages arrive for
+  ///     that consumer.
+  ///   
+  /// </remarks>
+  public interface IFileDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This is the staging identifier of the message to deliver.  The
+    ///       message must have been staged.  Note that a server can send the
+    ///       Deliver method asynchronously without waiting for staging to
+    ///       finish.
+    ///     
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.ack".</summary>
+  /// <remarks>
+  /// 
+  ///     This method acknowledges one or more messages delivered via the
+  ///     Deliver method.  The client can ask to confirm a single message or
+  ///     a set of messages up to and including a specific message.
+  ///   
+  /// </remarks>
+  public interface IFileAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If set to 1, the delivery tag is treated as "up to and including",
+    ///       so that the client can acknowledge multiple messages with a single
+    ///       method.  If set to zero, the delivery tag refers to a single
+    ///       message.  If the multiple field is 1, and the delivery tag is zero,
+    ///       tells the server to acknowledge all outstanding mesages.
+    ///     
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.reject".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows a client to reject a message.  It can be used to
+  ///     return untreatable messages to their original queue.  Note that file
+  ///     content is staged before delivery, so the client will not use this
+  ///     method to interrupt delivery of a large message.
+  ///   
+  /// </remarks>
+  public interface IFileReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be discarded.  If this bit
+    ///       is 1, the server will attempt to requeue the message.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IStreamQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets. May be
+    ///       set to zero, meaning "no specific limit".  Note that other
+    ///       prefetch limits may still apply.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       field may be used in combination with the prefetch-size field;
+    ///       a message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a desired transfer rate in octets per second. This is
+    ///       usually determined by the application that uses the streaming
+    ///       data.  A value of zero means "no limit", i.e. as rapidly as
+    ///       possible.
+    ///     
+    /// </summary>
+    uint ConsumeRate { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IStreamQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IStreamConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with a consumer tag which it may
+  ///     use in methods that work with the consumer.
+  ///   
+  /// </remarks>
+  public interface IStreamConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer.  Since message delivery is
+  ///     asynchronous the client may continue to receive messages for
+  ///     a short while after canceling a consumer.  It may process or
+  ///     discard these as appropriate.
+  ///   
+  /// </remarks>
+  public interface IStreamCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IStreamCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a message to a specific exchange. The message
+  ///     will be routed to queues as defined by the exchange configuration
+  ///     and distributed to any active consumers as appropriate.
+  ///   
+  /// </remarks>
+  public interface IStreamPublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IStreamReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client, via a consumer.  In
+  ///     the asynchronous message delivery model, the client starts a
+  ///     consumer using the Consume method, then the server responds with
+  ///     Deliver methods as and when messages arrive for that consumer.
+  ///   
+  /// </remarks>
+  public interface IStreamDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue that the message came from. Note
+    ///       that a single channel can start many consumers on different
+    ///       queues.
+    ///     
+    /// </summary>
+    string Queue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sets the channel to use standard transactions.  The
+  ///     client must use this method at least once on a channel before
+  ///     using the Commit or Rollback methods.
+  ///   
+  /// </remarks>
+  public interface ITxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the channel was successfully
+  ///     set to use standard transactions.
+  ///   
+  /// </remarks>
+  public interface ITxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit".</summary>
+  /// <remarks>
+  /// 
+  ///     This method commits all messages published and acknowledged in
+  ///     the current transaction.  A new transaction starts immediately
+  ///     after a commit.
+  ///   
+  /// </remarks>
+  public interface ITxCommit: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the commit succeeded.
+  ///     Note that if a commit fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface ITxCommitOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback".</summary>
+  /// <remarks>
+  /// 
+  ///     This method abandons all messages published and acknowledged in
+  ///     the current transaction.  A new transaction starts immediately
+  ///     after a rollback.
+  ///   
+  /// </remarks>
+  public interface ITxRollback: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the rollback succeeded.
+  ///     Note that if an rollback fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface ITxRollbackOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sets the channel to use distributed transactions.  The
+  ///     client must use this method at least once on a channel before
+  ///     using the Start method.
+  ///   
+  /// </remarks>
+  public interface IDtxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the channel was successfully
+  ///     set to use distributed transactions.
+  ///   
+  /// </remarks>
+  public interface IDtxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start".</summary>
+  /// <remarks>
+  /// 
+  ///     This method starts a new distributed transaction.  This must be
+  ///     the first method on a new channel that uses the distributed
+  ///     transaction mode, before any methods that publish or consume
+  ///     messages.
+  ///   
+  /// </remarks>
+  public interface IDtxStart: IMethod {
+    /// <summary>
+    /// 
+    ///       The distributed transaction key. This identifies the transaction
+    ///       so that the AMQP server can coordinate with the distributed
+    ///       transaction coordinator.
+    ///     
+    /// </summary>
+    string DtxIdentifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the transaction started.
+  ///     Note that if a start fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface IDtxStartOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tunnel.request".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tunnels a block of binary data, which can be an
+  ///     encoded AMQP method or other data.  The binary data is sent
+  ///     as the content for the Tunnel.Request method.
+  ///   
+  /// </remarks>
+  public interface ITunnelRequest: IMethod {
+    /// <summary>
+    /// 
+    ///     This field table holds arbitrary meta-data that the sender needs
+    ///     to pass to the recipient.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary MetaData { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.integer".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal integer
+  ///     data.
+  ///   
+  /// </remarks>
+  public interface ITestInteger: IMethod {
+    /// <summary>
+    /// 
+    ///       An octet integer test value.
+    ///     
+    /// </summary>
+    byte Integer1 { get; }
+    /// <summary>
+    /// 
+    ///       A short integer test value.
+    ///     
+    /// </summary>
+    ushort Integer2 { get; }
+    /// <summary>
+    /// 
+    ///       A long integer test value.
+    ///     
+    /// </summary>
+    uint Integer3 { get; }
+    /// <summary>
+    /// 
+    ///       A long long integer test value.
+    ///     
+    /// </summary>
+    ulong Integer4 { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided integer
+    ///       test fields and return the result.
+    ///     
+    /// </summary>
+    byte Operation { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.integer-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of an Integer method.
+  ///   
+  /// </remarks>
+  public interface ITestIntegerOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested operation.
+    ///     
+    /// </summary>
+    ulong Result { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.string".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal string
+  ///     data.
+  ///   
+  /// </remarks>
+  public interface ITestString: IMethod {
+    /// <summary>
+    /// 
+    ///       An short string test value.
+    ///     
+    /// </summary>
+    string String1 { get; }
+    /// <summary>
+    /// 
+    ///       A long string test value.
+    ///     
+    /// </summary>
+    byte[] String2 { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided string
+    ///       test fields and return the result.
+    ///     
+    /// </summary>
+    byte Operation { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.string-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a String method.
+  ///   
+  /// </remarks>
+  public interface ITestStringOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested operation.
+    ///     
+    /// </summary>
+    byte[] Result { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.table".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal field
+  ///     table data.
+  ///   
+  /// </remarks>
+  public interface ITestTable: IMethod {
+    /// <summary>
+    /// 
+    ///       A field table of test values.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Table { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided field
+    ///       table integer values and return the result.
+    ///     
+    /// </summary>
+    byte IntegerOp { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided field
+    ///       table string values and return the result.
+    ///     
+    /// </summary>
+    byte StringOp { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.table-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a Table method.
+  ///   
+  /// </remarks>
+  public interface ITestTableOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested integer operation.
+    ///     
+    /// </summary>
+    ulong IntegerResult { get; }
+    /// <summary>
+    /// 
+    ///       The result of the tested string operation.
+    ///     
+    /// </summary>
+    byte[] StringResult { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.content".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal content.
+  ///   
+  /// </remarks>
+  public interface ITestContent: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.content-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a Content method.  It contains the
+  ///     content checksum and echoes the original content as provided.
+  ///   
+  /// </remarks>
+  public interface ITestContentOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The 32-bit checksum of the content, calculated by adding the
+    ///       content into a 32-bit accumulator.
+    ///     
+    /// </summary>
+    uint ContentChecksum { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "basic"</summary>
+  /// <remarks>
+  /// 
+  ///   The Basic class provides methods that support an industry-standard
+  ///   messaging model.
+  /// 
+  /// </remarks>
+  public class BasicProperties: RabbitMQ.Client.Impl.BasicProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_deliveryMode;
+    private byte m_priority;
+    private string m_correlationId;
+    private string m_replyTo;
+    private string m_expiration;
+    private string m_messageId;
+    private AmqpTimestamp m_timestamp;
+    private string m_type;
+    private string m_userId;
+    private string m_appId;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool deliveryMode_present = false;
+    private bool priority_present = false;
+    private bool correlationId_present = false;
+    private bool replyTo_present = false;
+    private bool expiration_present = false;
+    private bool messageId_present = false;
+    private bool timestamp_present = false;
+    private bool type_present = false;
+    private bool userId_present = false;
+    private bool appId_present = false;
+    private bool clusterId_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte DeliveryMode {
+      get {
+        return m_deliveryMode;
+      }
+      set {
+        deliveryMode_present = true;
+        m_deliveryMode = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override string CorrelationId {
+      get {
+        return m_correlationId;
+      }
+      set {
+        correlationId_present = true;
+        m_correlationId = value;
+      }
+    }
+    // (no documentation)
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    // (no documentation)
+    public override string Expiration {
+      get {
+        return m_expiration;
+      }
+      set {
+        expiration_present = true;
+        m_expiration = value;
+      }
+    }
+    // (no documentation)
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    // (no documentation)
+    public override string Type {
+      get {
+        return m_type;
+      }
+      set {
+        type_present = true;
+        m_type = value;
+      }
+    }
+    // (no documentation)
+    public override string UserId {
+      get {
+        return m_userId;
+      }
+      set {
+        userId_present = true;
+        m_userId = value;
+      }
+    }
+    // (no documentation)
+    public override string AppId {
+      get {
+        return m_appId;
+      }
+      set {
+        appId_present = true;
+        m_appId = value;
+      }
+    }
+    // (no documentation)
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearDeliveryMode() { deliveryMode_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearCorrelationId() { correlationId_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearExpiration() { expiration_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearType() { type_present = false; }
+    public override void ClearUserId() { userId_present = false; }
+    public override void ClearAppId() { appId_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public BasicProperties() {}
+    public override int ProtocolClassId { get { return 60; } }
+    public override string ProtocolClassName { get { return "basic"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      deliveryMode_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      correlationId_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      expiration_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      type_present = reader.ReadPresence();
+      userId_present = reader.ReadPresence();
+      appId_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (deliveryMode_present) { m_deliveryMode = reader.ReadOctet(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (correlationId_present) { m_correlationId = reader.ReadShortstr(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (expiration_present) { m_expiration = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (type_present) { m_type = reader.ReadShortstr(); }
+      if (userId_present) { m_userId = reader.ReadShortstr(); }
+      if (appId_present) { m_appId = reader.ReadShortstr(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(deliveryMode_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(correlationId_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(expiration_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(type_present);
+      writer.WritePresence(userId_present);
+      writer.WritePresence(appId_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (deliveryMode_present) { writer.WriteOctet(m_deliveryMode); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (correlationId_present) { writer.WriteShortstr(m_correlationId); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (expiration_present) { writer.WriteShortstr(m_expiration); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (type_present) { writer.WriteShortstr(m_type); }
+      if (userId_present) { writer.WriteShortstr(m_userId); }
+      if (appId_present) { writer.WriteShortstr(m_appId); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("delivery mode="); sb.Append(deliveryMode_present ? m_deliveryMode.ToString() : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("correlation id="); sb.Append(correlationId_present ? (m_correlationId == null ? "(null)" : m_correlationId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("expiration="); sb.Append(expiration_present ? (m_expiration == null ? "(null)" : m_expiration.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("type="); sb.Append(type_present ? (m_type == null ? "(null)" : m_type.ToString()) : "_"); sb.Append(", ");
+      sb.Append("user id="); sb.Append(userId_present ? (m_userId == null ? "(null)" : m_userId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("app id="); sb.Append(appId_present ? (m_appId == null ? "(null)" : m_appId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "file"</summary>
+  /// <remarks>
+  /// 
+  ///   The file class provides methods that support reliable file transfer.
+  ///   File messages have a specific set of properties that are required for
+  ///   interoperability with file transfer applications. File messages and
+  ///   acknowledgements are subject to channel transactions.  Note that the
+  ///   file class does not provide message browsing methods; these are not
+  ///   compatible with the staging model.  Applications that need browsable
+  ///   file transfer should use Basic content and the Basic class.
+  /// 
+  /// </remarks>
+  public class FileProperties: RabbitMQ.Client.Impl.FileProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private string m_replyTo;
+    private string m_messageId;
+    private string m_filename;
+    private AmqpTimestamp m_timestamp;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool replyTo_present = false;
+    private bool messageId_present = false;
+    private bool filename_present = false;
+    private bool timestamp_present = false;
+    private bool clusterId_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    // (no documentation)
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    // (no documentation)
+    public override string Filename {
+      get {
+        return m_filename;
+      }
+      set {
+        filename_present = true;
+        m_filename = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    // (no documentation)
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearFilename() { filename_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public FileProperties() {}
+    public override int ProtocolClassId { get { return 70; } }
+    public override string ProtocolClassName { get { return "file"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      filename_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (filename_present) { m_filename = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(filename_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (filename_present) { writer.WriteShortstr(m_filename); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("filename="); sb.Append(filename_present ? (m_filename == null ? "(null)" : m_filename.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "stream"</summary>
+  /// <remarks>
+  /// 
+  ///   The stream class provides methods that support multimedia streaming.
+  ///   The stream class uses the following semantics: one message is one
+  ///   packet of data; delivery is unacknowleged and unreliable; the consumer
+  ///   can specify quality of service parameters that the server can try to
+  ///   adhere to; lower-priority messages may be discarded in favour of high
+  ///   priority messages.
+  /// 
+  /// </remarks>
+  public class StreamProperties: RabbitMQ.Client.Impl.StreamProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private AmqpTimestamp m_timestamp;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool timestamp_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+
+    public StreamProperties() {}
+    public override int ProtocolClassId { get { return 80; } }
+    public override string ProtocolClassName { get { return "stream"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(timestamp_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "tunnel"</summary>
+  /// <remarks>
+  /// 
+  ///   The tunnel methods are used to send blocks of binary data - which
+  ///   can be serialised AMQP methods or other protocol frames - between
+  ///   AMQP peers.
+  /// 
+  /// </remarks>
+  public class TunnelProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
+    private System.Collections.IDictionary m_headers;
+    private string m_proxyName;
+    private string m_dataName;
+    private byte m_durable;
+    private byte m_broadcast;
+
+    private bool headers_present = false;
+    private bool proxyName_present = false;
+    private bool dataName_present = false;
+    private bool durable_present = false;
+    private bool broadcast_present = false;
+
+    // (no documentation)
+    public System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public string ProxyName {
+      get {
+        return m_proxyName;
+      }
+      set {
+        proxyName_present = true;
+        m_proxyName = value;
+      }
+    }
+    // (no documentation)
+    public string DataName {
+      get {
+        return m_dataName;
+      }
+      set {
+        dataName_present = true;
+        m_dataName = value;
+      }
+    }
+    // (no documentation)
+    public byte Durable {
+      get {
+        return m_durable;
+      }
+      set {
+        durable_present = true;
+        m_durable = value;
+      }
+    }
+    // (no documentation)
+    public byte Broadcast {
+      get {
+        return m_broadcast;
+      }
+      set {
+        broadcast_present = true;
+        m_broadcast = value;
+      }
+    }
+
+    public void ClearHeaders() { headers_present = false; }
+    public void ClearProxyName() { proxyName_present = false; }
+    public void ClearDataName() { dataName_present = false; }
+    public void ClearDurable() { durable_present = false; }
+    public void ClearBroadcast() { broadcast_present = false; }
+
+    public TunnelProperties() {}
+    public override int ProtocolClassId { get { return 110; } }
+    public override string ProtocolClassName { get { return "tunnel"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      headers_present = reader.ReadPresence();
+      proxyName_present = reader.ReadPresence();
+      dataName_present = reader.ReadPresence();
+      durable_present = reader.ReadPresence();
+      broadcast_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (proxyName_present) { m_proxyName = reader.ReadShortstr(); }
+      if (dataName_present) { m_dataName = reader.ReadShortstr(); }
+      if (durable_present) { m_durable = reader.ReadOctet(); }
+      if (broadcast_present) { m_broadcast = reader.ReadOctet(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(headers_present);
+      writer.WritePresence(proxyName_present);
+      writer.WritePresence(dataName_present);
+      writer.WritePresence(durable_present);
+      writer.WritePresence(broadcast_present);
+      writer.FinishPresence();
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (proxyName_present) { writer.WriteShortstr(m_proxyName); }
+      if (dataName_present) { writer.WriteShortstr(m_dataName); }
+      if (durable_present) { writer.WriteOctet(m_durable); }
+      if (broadcast_present) { writer.WriteOctet(m_broadcast); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("proxy name="); sb.Append(proxyName_present ? (m_proxyName == null ? "(null)" : m_proxyName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("data name="); sb.Append(dataName_present ? (m_dataName == null ? "(null)" : m_dataName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("durable="); sb.Append(durable_present ? m_durable.ToString() : "_"); sb.Append(", ");
+      sb.Append("broadcast="); sb.Append(broadcast_present ? m_broadcast.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "test"</summary>
+  /// <remarks>
+  /// 
+  ///   The test class provides methods for a peer to test the basic
+  ///   operational correctness of another peer. The test methods are
+  ///   intended to ensure that all peers respect at least the basic
+  ///   elements of the protocol, such as frame and content organisation
+  ///   and field types. We assume that a specially-designed peer, a
+  ///   "monitor client" would perform such tests.
+  /// 
+  /// </remarks>
+  public class TestProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
+
+
+
+
+    public TestProperties() {}
+    public override int ProtocolClassId { get { return 120; } }
+    public override string ProtocolClassName { get { return "test"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      reader.FinishPresence();
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.FinishPresence();
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+}
+namespace RabbitMQ.Client.Framing.Impl.v0_8 {
+  using RabbitMQ.Client.Framing.v0_8;
+  public enum ClassId {
+    Connection = 10,
+    Channel = 20,
+    Access = 30,
+    Exchange = 40,
+    Queue = 50,
+    Basic = 60,
+    File = 70,
+    Stream = 80,
+    Tx = 90,
+    Dtx = 100,
+    Tunnel = 110,
+    Test = 120,
+    Invalid = -1
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStart: RabbitMQ.Client.Impl.MethodBase, IConnectionStart {
+    public const int ClassId = 10;
+    public const int MethodId = 10;
+
+    public byte m_versionMajor;
+    public byte m_versionMinor;
+    public System.Collections.IDictionary m_serverProperties;
+    public byte[] m_mechanisms;
+    public byte[] m_locales;
+
+    byte IConnectionStart.VersionMajor { get { return m_versionMajor; } }
+    byte IConnectionStart.VersionMinor { get { return m_versionMinor; } }
+    System.Collections.IDictionary IConnectionStart.ServerProperties { get { return m_serverProperties; } }
+    byte[] IConnectionStart.Mechanisms { get { return m_mechanisms; } }
+    byte[] IConnectionStart.Locales { get { return m_locales; } }
+
+    public ConnectionStart() {}
+    public ConnectionStart(
+      byte initVersionMajor,
+      byte initVersionMinor,
+      System.Collections.IDictionary initServerProperties,
+      byte[] initMechanisms,
+      byte[] initLocales)
+    {
+      m_versionMajor = initVersionMajor;
+      m_versionMinor = initVersionMinor;
+      m_serverProperties = initServerProperties;
+      m_mechanisms = initMechanisms;
+      m_locales = initLocales;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "connection.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_versionMajor = reader.ReadOctet();
+      m_versionMinor = reader.ReadOctet();
+      m_serverProperties = reader.ReadTable();
+      m_mechanisms = reader.ReadLongstr();
+      m_locales = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteOctet(m_versionMajor);
+      writer.WriteOctet(m_versionMinor);
+      writer.WriteTable(m_serverProperties);
+      writer.WriteLongstr(m_mechanisms);
+      writer.WriteLongstr(m_locales);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_versionMajor); sb.Append(",");
+      sb.Append(m_versionMinor); sb.Append(",");
+      sb.Append(m_serverProperties); sb.Append(",");
+      sb.Append(m_mechanisms); sb.Append(",");
+      sb.Append(m_locales);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStartOk: RabbitMQ.Client.Impl.MethodBase, IConnectionStartOk {
+    public const int ClassId = 10;
+    public const int MethodId = 11;
+
+    public System.Collections.IDictionary m_clientProperties;
+    public string m_mechanism;
+    public byte[] m_response;
+    public string m_locale;
+
+    System.Collections.IDictionary IConnectionStartOk.ClientProperties { get { return m_clientProperties; } }
+    string IConnectionStartOk.Mechanism { get { return m_mechanism; } }
+    byte[] IConnectionStartOk.Response { get { return m_response; } }
+    string IConnectionStartOk.Locale { get { return m_locale; } }
+
+    public ConnectionStartOk() {}
+    public ConnectionStartOk(
+      System.Collections.IDictionary initClientProperties,
+      string initMechanism,
+      byte[] initResponse,
+      string initLocale)
+    {
+      m_clientProperties = initClientProperties;
+      m_mechanism = initMechanism;
+      m_response = initResponse;
+      m_locale = initLocale;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "connection.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clientProperties = reader.ReadTable();
+      m_mechanism = reader.ReadShortstr();
+      m_response = reader.ReadLongstr();
+      m_locale = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_clientProperties);
+      writer.WriteShortstr(m_mechanism);
+      writer.WriteLongstr(m_response);
+      writer.WriteShortstr(m_locale);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clientProperties); sb.Append(",");
+      sb.Append(m_mechanism); sb.Append(",");
+      sb.Append(m_response); sb.Append(",");
+      sb.Append(m_locale);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecure: RabbitMQ.Client.Impl.MethodBase, IConnectionSecure {
+    public const int ClassId = 10;
+    public const int MethodId = 20;
+
+    public byte[] m_challenge;
+
+    byte[] IConnectionSecure.Challenge { get { return m_challenge; } }
+
+    public ConnectionSecure() {}
+    public ConnectionSecure(
+      byte[] initChallenge)
+    {
+      m_challenge = initChallenge;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "connection.secure"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_challenge = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_challenge);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_challenge);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecureOk: RabbitMQ.Client.Impl.MethodBase, IConnectionSecureOk {
+    public const int ClassId = 10;
+    public const int MethodId = 21;
+
+    public byte[] m_response;
+
+    byte[] IConnectionSecureOk.Response { get { return m_response; } }
+
+    public ConnectionSecureOk() {}
+    public ConnectionSecureOk(
+      byte[] initResponse)
+    {
+      m_response = initResponse;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "connection.secure-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_response = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_response);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_response);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTune: RabbitMQ.Client.Impl.MethodBase, IConnectionTune {
+    public const int ClassId = 10;
+    public const int MethodId = 30;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTune.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTune.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTune.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTune() {}
+    public ConnectionTune(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "connection.tune"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTuneOk: RabbitMQ.Client.Impl.MethodBase, IConnectionTuneOk {
+    public const int ClassId = 10;
+    public const int MethodId = 31;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTuneOk.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTuneOk.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTuneOk.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTuneOk() {}
+    public ConnectionTuneOk(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "connection.tune-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpen: RabbitMQ.Client.Impl.MethodBase, IConnectionOpen {
+    public const int ClassId = 10;
+    public const int MethodId = 40;
+
+    public string m_virtualHost;
+    public string m_capabilities;
+    public bool m_insist;
+
+    string IConnectionOpen.VirtualHost { get { return m_virtualHost; } }
+    string IConnectionOpen.Capabilities { get { return m_capabilities; } }
+    bool IConnectionOpen.Insist { get { return m_insist; } }
+
+    public ConnectionOpen() {}
+    public ConnectionOpen(
+      string initVirtualHost,
+      string initCapabilities,
+      bool initInsist)
+    {
+      m_virtualHost = initVirtualHost;
+      m_capabilities = initCapabilities;
+      m_insist = initInsist;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "connection.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_virtualHost = reader.ReadShortstr();
+      m_capabilities = reader.ReadShortstr();
+      m_insist = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_virtualHost);
+      writer.WriteShortstr(m_capabilities);
+      writer.WriteBit(m_insist);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_virtualHost); sb.Append(",");
+      sb.Append(m_capabilities); sb.Append(",");
+      sb.Append(m_insist);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpenOk: RabbitMQ.Client.Impl.MethodBase, IConnectionOpenOk {
+    public const int ClassId = 10;
+    public const int MethodId = 41;
+
+    public string m_knownHosts;
+
+    string IConnectionOpenOk.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionOpenOk() {}
+    public ConnectionOpenOk(
+      string initKnownHosts)
+    {
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "connection.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionRedirect: RabbitMQ.Client.Impl.MethodBase, IConnectionRedirect {
+    public const int ClassId = 10;
+    public const int MethodId = 50;
+
+    public string m_host;
+    public string m_knownHosts;
+
+    string IConnectionRedirect.Host { get { return m_host; } }
+    string IConnectionRedirect.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionRedirect() {}
+    public ConnectionRedirect(
+      string initHost,
+      string initKnownHosts)
+    {
+      m_host = initHost;
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "connection.redirect"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_host = reader.ReadShortstr();
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_host);
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_host); sb.Append(",");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionClose: RabbitMQ.Client.Impl.MethodBase, IConnectionClose {
+    public const int ClassId = 10;
+    public const int MethodId = 60;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IConnectionClose.ReplyCode { get { return m_replyCode; } }
+    string IConnectionClose.ReplyText { get { return m_replyText; } }
+    ushort IConnectionClose.ClassId { get { return m_classId; } }
+    ushort IConnectionClose.MethodId { get { return m_methodId; } }
+
+    public ConnectionClose() {}
+    public ConnectionClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "connection.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionCloseOk: RabbitMQ.Client.Impl.MethodBase, IConnectionCloseOk {
+    public const int ClassId = 10;
+    public const int MethodId = 61;
+
+
+
+    public ConnectionCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 61; } }
+    public override string ProtocolMethodName { get { return "connection.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpen: RabbitMQ.Client.Impl.MethodBase, IChannelOpen {
+    public const int ClassId = 20;
+    public const int MethodId = 10;
+
+    public string m_outOfBand;
+
+    string IChannelOpen.OutOfBand { get { return m_outOfBand; } }
+
+    public ChannelOpen() {}
+    public ChannelOpen(
+      string initOutOfBand)
+    {
+      m_outOfBand = initOutOfBand;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "channel.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_outOfBand = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_outOfBand);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_outOfBand);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpenOk: RabbitMQ.Client.Impl.MethodBase, IChannelOpenOk {
+    public const int ClassId = 20;
+    public const int MethodId = 11;
+
+
+
+    public ChannelOpenOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "channel.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlow: RabbitMQ.Client.Impl.MethodBase, IChannelFlow {
+    public const int ClassId = 20;
+    public const int MethodId = 20;
+
+    public bool m_active;
+
+    bool IChannelFlow.Active { get { return m_active; } }
+
+    public ChannelFlow() {}
+    public ChannelFlow(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "channel.flow"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlowOk: RabbitMQ.Client.Impl.MethodBase, IChannelFlowOk {
+    public const int ClassId = 20;
+    public const int MethodId = 21;
+
+    public bool m_active;
+
+    bool IChannelFlowOk.Active { get { return m_active; } }
+
+    public ChannelFlowOk() {}
+    public ChannelFlowOk(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "channel.flow-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelAlert: RabbitMQ.Client.Impl.MethodBase, IChannelAlert {
+    public const int ClassId = 20;
+    public const int MethodId = 30;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public System.Collections.IDictionary m_details;
+
+    ushort IChannelAlert.ReplyCode { get { return m_replyCode; } }
+    string IChannelAlert.ReplyText { get { return m_replyText; } }
+    System.Collections.IDictionary IChannelAlert.Details { get { return m_details; } }
+
+    public ChannelAlert() {}
+    public ChannelAlert(
+      ushort initReplyCode,
+      string initReplyText,
+      System.Collections.IDictionary initDetails)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_details = initDetails;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "channel.alert"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_details = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteTable(m_details);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_details);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelClose: RabbitMQ.Client.Impl.MethodBase, IChannelClose {
+    public const int ClassId = 20;
+    public const int MethodId = 40;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IChannelClose.ReplyCode { get { return m_replyCode; } }
+    string IChannelClose.ReplyText { get { return m_replyText; } }
+    ushort IChannelClose.ClassId { get { return m_classId; } }
+    ushort IChannelClose.MethodId { get { return m_methodId; } }
+
+    public ChannelClose() {}
+    public ChannelClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "channel.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelCloseOk: RabbitMQ.Client.Impl.MethodBase, IChannelCloseOk {
+    public const int ClassId = 20;
+    public const int MethodId = 41;
+
+
+
+    public ChannelCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "channel.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequest: RabbitMQ.Client.Impl.MethodBase, IAccessRequest {
+    public const int ClassId = 30;
+    public const int MethodId = 10;
+
+    public string m_realm;
+    public bool m_exclusive;
+    public bool m_passive;
+    public bool m_active;
+    public bool m_write;
+    public bool m_read;
+
+    string IAccessRequest.Realm { get { return m_realm; } }
+    bool IAccessRequest.Exclusive { get { return m_exclusive; } }
+    bool IAccessRequest.Passive { get { return m_passive; } }
+    bool IAccessRequest.Active { get { return m_active; } }
+    bool IAccessRequest.Write { get { return m_write; } }
+    bool IAccessRequest.Read { get { return m_read; } }
+
+    public AccessRequest() {}
+    public AccessRequest(
+      string initRealm,
+      bool initExclusive,
+      bool initPassive,
+      bool initActive,
+      bool initWrite,
+      bool initRead)
+    {
+      m_realm = initRealm;
+      m_exclusive = initExclusive;
+      m_passive = initPassive;
+      m_active = initActive;
+      m_write = initWrite;
+      m_read = initRead;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "access.request"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_realm = reader.ReadShortstr();
+      m_exclusive = reader.ReadBit();
+      m_passive = reader.ReadBit();
+      m_active = reader.ReadBit();
+      m_write = reader.ReadBit();
+      m_read = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_realm);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_active);
+      writer.WriteBit(m_write);
+      writer.WriteBit(m_read);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_realm); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_active); sb.Append(",");
+      sb.Append(m_write); sb.Append(",");
+      sb.Append(m_read);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequestOk: RabbitMQ.Client.Impl.MethodBase, IAccessRequestOk {
+    public const int ClassId = 30;
+    public const int MethodId = 11;
+
+    public ushort m_ticket;
+
+    ushort IAccessRequestOk.Ticket { get { return m_ticket; } }
+
+    public AccessRequestOk() {}
+    public AccessRequestOk(
+      ushort initTicket)
+    {
+      m_ticket = initTicket;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "access.request-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclare: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclare {
+    public const int ClassId = 40;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_type;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_autoDelete;
+    public bool m_internal;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IExchangeDeclare.Ticket { get { return m_ticket; } }
+    string IExchangeDeclare.Exchange { get { return m_exchange; } }
+    string IExchangeDeclare.Type { get { return m_type; } }
+    bool IExchangeDeclare.Passive { get { return m_passive; } }
+    bool IExchangeDeclare.Durable { get { return m_durable; } }
+    bool IExchangeDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IExchangeDeclare.Internal { get { return m_internal; } }
+    bool IExchangeDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IExchangeDeclare.Arguments { get { return m_arguments; } }
+
+    public ExchangeDeclare() {}
+    public ExchangeDeclare(
+      ushort initTicket,
+      string initExchange,
+      string initType,
+      bool initPassive,
+      bool initDurable,
+      bool initAutoDelete,
+      bool initInternal,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_type = initType;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_autoDelete = initAutoDelete;
+      m_internal = initInternal;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "exchange.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_type = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_internal = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_type);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_internal);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_type); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_internal); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclareOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclareOk {
+    public const int ClassId = 40;
+    public const int MethodId = 11;
+
+
+
+    public ExchangeDeclareOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "exchange.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDelete: RabbitMQ.Client.Impl.MethodBase, IExchangeDelete {
+    public const int ClassId = 40;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public bool m_ifUnused;
+    public bool m_nowait;
+
+    ushort IExchangeDelete.Ticket { get { return m_ticket; } }
+    string IExchangeDelete.Exchange { get { return m_exchange; } }
+    bool IExchangeDelete.IfUnused { get { return m_ifUnused; } }
+    bool IExchangeDelete.Nowait { get { return m_nowait; } }
+
+    public ExchangeDelete() {}
+    public ExchangeDelete(
+      ushort initTicket,
+      string initExchange,
+      bool initIfUnused,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_ifUnused = initIfUnused;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "exchange.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeleteOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeleteOk {
+    public const int ClassId = 40;
+    public const int MethodId = 21;
+
+
+
+    public ExchangeDeleteOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "exchange.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclare: RabbitMQ.Client.Impl.MethodBase, IQueueDeclare {
+    public const int ClassId = 50;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_exclusive;
+    public bool m_autoDelete;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueDeclare.Ticket { get { return m_ticket; } }
+    string IQueueDeclare.Queue { get { return m_queue; } }
+    bool IQueueDeclare.Passive { get { return m_passive; } }
+    bool IQueueDeclare.Durable { get { return m_durable; } }
+    bool IQueueDeclare.Exclusive { get { return m_exclusive; } }
+    bool IQueueDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IQueueDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueDeclare.Arguments { get { return m_arguments; } }
+
+    public QueueDeclare() {}
+    public QueueDeclare(
+      ushort initTicket,
+      string initQueue,
+      bool initPassive,
+      bool initDurable,
+      bool initExclusive,
+      bool initAutoDelete,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_exclusive = initExclusive;
+      m_autoDelete = initAutoDelete;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "queue.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclareOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeclareOk {
+    public const int ClassId = 50;
+    public const int MethodId = 11;
+
+    public string m_queue;
+    public uint m_messageCount;
+    public uint m_consumerCount;
+
+    string IQueueDeclareOk.Queue { get { return m_queue; } }
+    uint IQueueDeclareOk.MessageCount { get { return m_messageCount; } }
+    uint IQueueDeclareOk.ConsumerCount { get { return m_consumerCount; } }
+
+    public QueueDeclareOk() {}
+    public QueueDeclareOk(
+      string initQueue,
+      uint initMessageCount,
+      uint initConsumerCount)
+    {
+      m_queue = initQueue;
+      m_messageCount = initMessageCount;
+      m_consumerCount = initConsumerCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "queue.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_queue = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+      m_consumerCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_queue);
+      writer.WriteLong(m_messageCount);
+      writer.WriteLong(m_consumerCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_messageCount); sb.Append(",");
+      sb.Append(m_consumerCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBind: RabbitMQ.Client.Impl.MethodBase, IQueueBind {
+    public const int ClassId = 50;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueBind.Ticket { get { return m_ticket; } }
+    string IQueueBind.Queue { get { return m_queue; } }
+    string IQueueBind.Exchange { get { return m_exchange; } }
+    string IQueueBind.RoutingKey { get { return m_routingKey; } }
+    bool IQueueBind.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueBind.Arguments { get { return m_arguments; } }
+
+    public QueueBind() {}
+    public QueueBind(
+      ushort initTicket,
+      string initQueue,
+      string initExchange,
+      string initRoutingKey,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "queue.bind"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBindOk: RabbitMQ.Client.Impl.MethodBase, IQueueBindOk {
+    public const int ClassId = 50;
+    public const int MethodId = 21;
+
+
+
+    public QueueBindOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "queue.bind-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurge: RabbitMQ.Client.Impl.MethodBase, IQueuePurge {
+    public const int ClassId = 50;
+    public const int MethodId = 30;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_nowait;
+
+    ushort IQueuePurge.Ticket { get { return m_ticket; } }
+    string IQueuePurge.Queue { get { return m_queue; } }
+    bool IQueuePurge.Nowait { get { return m_nowait; } }
+
+    public QueuePurge() {}
+    public QueuePurge(
+      ushort initTicket,
+      string initQueue,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "queue.purge"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurgeOk: RabbitMQ.Client.Impl.MethodBase, IQueuePurgeOk {
+    public const int ClassId = 50;
+    public const int MethodId = 31;
+
+    public uint m_messageCount;
+
+    uint IQueuePurgeOk.MessageCount { get { return m_messageCount; } }
+
+    public QueuePurgeOk() {}
+    public QueuePurgeOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "queue.purge-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDelete: RabbitMQ.Client.Impl.MethodBase, IQueueDelete {
+    public const int ClassId = 50;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_ifUnused;
+    public bool m_ifEmpty;
+    public bool m_nowait;
+
+    ushort IQueueDelete.Ticket { get { return m_ticket; } }
+    string IQueueDelete.Queue { get { return m_queue; } }
+    bool IQueueDelete.IfUnused { get { return m_ifUnused; } }
+    bool IQueueDelete.IfEmpty { get { return m_ifEmpty; } }
+    bool IQueueDelete.Nowait { get { return m_nowait; } }
+
+    public QueueDelete() {}
+    public QueueDelete(
+      ushort initTicket,
+      string initQueue,
+      bool initIfUnused,
+      bool initIfEmpty,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_ifUnused = initIfUnused;
+      m_ifEmpty = initIfEmpty;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "queue.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_ifEmpty = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_ifEmpty);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_ifEmpty); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeleteOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeleteOk {
+    public const int ClassId = 50;
+    public const int MethodId = 41;
+
+    public uint m_messageCount;
+
+    uint IQueueDeleteOk.MessageCount { get { return m_messageCount; } }
+
+    public QueueDeleteOk() {}
+    public QueueDeleteOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "queue.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQos: RabbitMQ.Client.Impl.MethodBase, IBasicQos {
+    public const int ClassId = 60;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IBasicQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IBasicQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IBasicQos.Global { get { return m_global; } }
+
+    public BasicQos() {}
+    public BasicQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "basic.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQosOk: RabbitMQ.Client.Impl.MethodBase, IBasicQosOk {
+    public const int ClassId = 60;
+    public const int MethodId = 11;
+
+
+
+    public BasicQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "basic.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsume: RabbitMQ.Client.Impl.MethodBase, IBasicConsume {
+    public const int ClassId = 60;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+
+    ushort IBasicConsume.Ticket { get { return m_ticket; } }
+    string IBasicConsume.Queue { get { return m_queue; } }
+    string IBasicConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicConsume.NoLocal { get { return m_noLocal; } }
+    bool IBasicConsume.NoAck { get { return m_noAck; } }
+    bool IBasicConsume.Exclusive { get { return m_exclusive; } }
+    bool IBasicConsume.Nowait { get { return m_nowait; } }
+
+    public BasicConsume() {}
+    public BasicConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "basic.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsumeOk: RabbitMQ.Client.Impl.MethodBase, IBasicConsumeOk {
+    public const int ClassId = 60;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IBasicConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicConsumeOk() {}
+    public BasicConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "basic.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancel: RabbitMQ.Client.Impl.MethodBase, IBasicCancel {
+    public const int ClassId = 60;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IBasicCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicCancel.Nowait { get { return m_nowait; } }
+
+    public BasicCancel() {}
+    public BasicCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "basic.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancelOk: RabbitMQ.Client.Impl.MethodBase, IBasicCancelOk {
+    public const int ClassId = 60;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IBasicCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicCancelOk() {}
+    public BasicCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "basic.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicPublish: RabbitMQ.Client.Impl.MethodBase, IBasicPublish {
+    public const int ClassId = 60;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IBasicPublish.Ticket { get { return m_ticket; } }
+    string IBasicPublish.Exchange { get { return m_exchange; } }
+    string IBasicPublish.RoutingKey { get { return m_routingKey; } }
+    bool IBasicPublish.Mandatory { get { return m_mandatory; } }
+    bool IBasicPublish.Immediate { get { return m_immediate; } }
+
+    public BasicPublish() {}
+    public BasicPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "basic.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReturn: RabbitMQ.Client.Impl.MethodBase, IBasicReturn {
+    public const int ClassId = 60;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IBasicReturn.ReplyCode { get { return m_replyCode; } }
+    string IBasicReturn.ReplyText { get { return m_replyText; } }
+    string IBasicReturn.Exchange { get { return m_exchange; } }
+    string IBasicReturn.RoutingKey { get { return m_routingKey; } }
+
+    public BasicReturn() {}
+    public BasicReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "basic.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicDeliver: RabbitMQ.Client.Impl.MethodBase, IBasicDeliver {
+    public const int ClassId = 60;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+
+    string IBasicDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IBasicDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicDeliver.Redelivered { get { return m_redelivered; } }
+    string IBasicDeliver.Exchange { get { return m_exchange; } }
+    string IBasicDeliver.RoutingKey { get { return m_routingKey; } }
+
+    public BasicDeliver() {}
+    public BasicDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "basic.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGet: RabbitMQ.Client.Impl.MethodBase, IBasicGet {
+    public const int ClassId = 60;
+    public const int MethodId = 70;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_noAck;
+
+    ushort IBasicGet.Ticket { get { return m_ticket; } }
+    string IBasicGet.Queue { get { return m_queue; } }
+    bool IBasicGet.NoAck { get { return m_noAck; } }
+
+    public BasicGet() {}
+    public BasicGet(
+      ushort initTicket,
+      string initQueue,
+      bool initNoAck)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_noAck = initNoAck;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "basic.get"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_noAck = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_noAck);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_noAck);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetOk: RabbitMQ.Client.Impl.MethodBase, IBasicGetOk {
+    public const int ClassId = 60;
+    public const int MethodId = 71;
+
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public uint m_messageCount;
+
+    ulong IBasicGetOk.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicGetOk.Redelivered { get { return m_redelivered; } }
+    string IBasicGetOk.Exchange { get { return m_exchange; } }
+    string IBasicGetOk.RoutingKey { get { return m_routingKey; } }
+    uint IBasicGetOk.MessageCount { get { return m_messageCount; } }
+
+    public BasicGetOk() {}
+    public BasicGetOk(
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      uint initMessageCount)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 71; } }
+    public override string ProtocolMethodName { get { return "basic.get-ok"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetEmpty: RabbitMQ.Client.Impl.MethodBase, IBasicGetEmpty {
+    public const int ClassId = 60;
+    public const int MethodId = 72;
+
+    public string m_clusterId;
+
+    string IBasicGetEmpty.ClusterId { get { return m_clusterId; } }
+
+    public BasicGetEmpty() {}
+    public BasicGetEmpty(
+      string initClusterId)
+    {
+      m_clusterId = initClusterId;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 72; } }
+    public override string ProtocolMethodName { get { return "basic.get-empty"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clusterId = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_clusterId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clusterId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicAck: RabbitMQ.Client.Impl.MethodBase, IBasicAck {
+    public const int ClassId = 60;
+    public const int MethodId = 80;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IBasicAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicAck.Multiple { get { return m_multiple; } }
+
+    public BasicAck() {}
+    public BasicAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "basic.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReject: RabbitMQ.Client.Impl.MethodBase, IBasicReject {
+    public const int ClassId = 60;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IBasicReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicReject.Requeue { get { return m_requeue; } }
+
+    public BasicReject() {}
+    public BasicReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "basic.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicRecover: RabbitMQ.Client.Impl.MethodBase, IBasicRecover {
+    public const int ClassId = 60;
+    public const int MethodId = 100;
+
+    public bool m_requeue;
+
+    bool IBasicRecover.Requeue { get { return m_requeue; } }
+
+    public BasicRecover() {}
+    public BasicRecover(
+      bool initRequeue)
+    {
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "basic.recover"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQos: RabbitMQ.Client.Impl.MethodBase, IFileQos {
+    public const int ClassId = 70;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IFileQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IFileQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IFileQos.Global { get { return m_global; } }
+
+    public FileQos() {}
+    public FileQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "file.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQosOk: RabbitMQ.Client.Impl.MethodBase, IFileQosOk {
+    public const int ClassId = 70;
+    public const int MethodId = 11;
+
+
+
+    public FileQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "file.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsume: RabbitMQ.Client.Impl.MethodBase, IFileConsume {
+    public const int ClassId = 70;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+
+    ushort IFileConsume.Ticket { get { return m_ticket; } }
+    string IFileConsume.Queue { get { return m_queue; } }
+    string IFileConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileConsume.NoLocal { get { return m_noLocal; } }
+    bool IFileConsume.NoAck { get { return m_noAck; } }
+    bool IFileConsume.Exclusive { get { return m_exclusive; } }
+    bool IFileConsume.Nowait { get { return m_nowait; } }
+
+    public FileConsume() {}
+    public FileConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "file.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsumeOk: RabbitMQ.Client.Impl.MethodBase, IFileConsumeOk {
+    public const int ClassId = 70;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IFileConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileConsumeOk() {}
+    public FileConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "file.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancel: RabbitMQ.Client.Impl.MethodBase, IFileCancel {
+    public const int ClassId = 70;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IFileCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileCancel.Nowait { get { return m_nowait; } }
+
+    public FileCancel() {}
+    public FileCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "file.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancelOk: RabbitMQ.Client.Impl.MethodBase, IFileCancelOk {
+    public const int ClassId = 70;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IFileCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileCancelOk() {}
+    public FileCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "file.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpen: RabbitMQ.Client.Impl.MethodBase, IFileOpen {
+    public const int ClassId = 70;
+    public const int MethodId = 40;
+
+    public string m_identifier;
+    public ulong m_contentSize;
+
+    string IFileOpen.Identifier { get { return m_identifier; } }
+    ulong IFileOpen.ContentSize { get { return m_contentSize; } }
+
+    public FileOpen() {}
+    public FileOpen(
+      string initIdentifier,
+      ulong initContentSize)
+    {
+      m_identifier = initIdentifier;
+      m_contentSize = initContentSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "file.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_identifier = reader.ReadShortstr();
+      m_contentSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_identifier);
+      writer.WriteLonglong(m_contentSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_identifier); sb.Append(",");
+      sb.Append(m_contentSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpenOk: RabbitMQ.Client.Impl.MethodBase, IFileOpenOk {
+    public const int ClassId = 70;
+    public const int MethodId = 41;
+
+    public ulong m_stagedSize;
+
+    ulong IFileOpenOk.StagedSize { get { return m_stagedSize; } }
+
+    public FileOpenOk() {}
+    public FileOpenOk(
+      ulong initStagedSize)
+    {
+      m_stagedSize = initStagedSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "file.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_stagedSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_stagedSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_stagedSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileStage: RabbitMQ.Client.Impl.MethodBase, IFileStage {
+    public const int ClassId = 70;
+    public const int MethodId = 50;
+
+
+
+    public FileStage(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "file.stage"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FilePublish: RabbitMQ.Client.Impl.MethodBase, IFilePublish {
+    public const int ClassId = 70;
+    public const int MethodId = 60;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+    public string m_identifier;
+
+    ushort IFilePublish.Ticket { get { return m_ticket; } }
+    string IFilePublish.Exchange { get { return m_exchange; } }
+    string IFilePublish.RoutingKey { get { return m_routingKey; } }
+    bool IFilePublish.Mandatory { get { return m_mandatory; } }
+    bool IFilePublish.Immediate { get { return m_immediate; } }
+    string IFilePublish.Identifier { get { return m_identifier; } }
+
+    public FilePublish() {}
+    public FilePublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate,
+      string initIdentifier)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "file.publish"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReturn: RabbitMQ.Client.Impl.MethodBase, IFileReturn {
+    public const int ClassId = 70;
+    public const int MethodId = 70;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IFileReturn.ReplyCode { get { return m_replyCode; } }
+    string IFileReturn.ReplyText { get { return m_replyText; } }
+    string IFileReturn.Exchange { get { return m_exchange; } }
+    string IFileReturn.RoutingKey { get { return m_routingKey; } }
+
+    public FileReturn() {}
+    public FileReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "file.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileDeliver: RabbitMQ.Client.Impl.MethodBase, IFileDeliver {
+    public const int ClassId = 70;
+    public const int MethodId = 80;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public string m_identifier;
+
+    string IFileDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IFileDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileDeliver.Redelivered { get { return m_redelivered; } }
+    string IFileDeliver.Exchange { get { return m_exchange; } }
+    string IFileDeliver.RoutingKey { get { return m_routingKey; } }
+    string IFileDeliver.Identifier { get { return m_identifier; } }
+
+    public FileDeliver() {}
+    public FileDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      string initIdentifier)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "file.deliver"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileAck: RabbitMQ.Client.Impl.MethodBase, IFileAck {
+    public const int ClassId = 70;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IFileAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileAck.Multiple { get { return m_multiple; } }
+
+    public FileAck() {}
+    public FileAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "file.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReject: RabbitMQ.Client.Impl.MethodBase, IFileReject {
+    public const int ClassId = 70;
+    public const int MethodId = 100;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IFileReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileReject.Requeue { get { return m_requeue; } }
+
+    public FileReject() {}
+    public FileReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "file.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQos: RabbitMQ.Client.Impl.MethodBase, IStreamQos {
+    public const int ClassId = 80;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public uint m_consumeRate;
+    public bool m_global;
+
+    uint IStreamQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IStreamQos.PrefetchCount { get { return m_prefetchCount; } }
+    uint IStreamQos.ConsumeRate { get { return m_consumeRate; } }
+    bool IStreamQos.Global { get { return m_global; } }
+
+    public StreamQos() {}
+    public StreamQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      uint initConsumeRate,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_consumeRate = initConsumeRate;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "stream.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_consumeRate = reader.ReadLong();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteLong(m_consumeRate);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_consumeRate); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQosOk: RabbitMQ.Client.Impl.MethodBase, IStreamQosOk {
+    public const int ClassId = 80;
+    public const int MethodId = 11;
+
+
+
+    public StreamQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "stream.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsume: RabbitMQ.Client.Impl.MethodBase, IStreamConsume {
+    public const int ClassId = 80;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_exclusive;
+    public bool m_nowait;
+
+    ushort IStreamConsume.Ticket { get { return m_ticket; } }
+    string IStreamConsume.Queue { get { return m_queue; } }
+    string IStreamConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamConsume.NoLocal { get { return m_noLocal; } }
+    bool IStreamConsume.Exclusive { get { return m_exclusive; } }
+    bool IStreamConsume.Nowait { get { return m_nowait; } }
+
+    public StreamConsume() {}
+    public StreamConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initExclusive,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "stream.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsumeOk: RabbitMQ.Client.Impl.MethodBase, IStreamConsumeOk {
+    public const int ClassId = 80;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IStreamConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamConsumeOk() {}
+    public StreamConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "stream.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancel: RabbitMQ.Client.Impl.MethodBase, IStreamCancel {
+    public const int ClassId = 80;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IStreamCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamCancel.Nowait { get { return m_nowait; } }
+
+    public StreamCancel() {}
+    public StreamCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "stream.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancelOk: RabbitMQ.Client.Impl.MethodBase, IStreamCancelOk {
+    public const int ClassId = 80;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IStreamCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamCancelOk() {}
+    public StreamCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "stream.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamPublish: RabbitMQ.Client.Impl.MethodBase, IStreamPublish {
+    public const int ClassId = 80;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IStreamPublish.Ticket { get { return m_ticket; } }
+    string IStreamPublish.Exchange { get { return m_exchange; } }
+    string IStreamPublish.RoutingKey { get { return m_routingKey; } }
+    bool IStreamPublish.Mandatory { get { return m_mandatory; } }
+    bool IStreamPublish.Immediate { get { return m_immediate; } }
+
+    public StreamPublish() {}
+    public StreamPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "stream.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamReturn: RabbitMQ.Client.Impl.MethodBase, IStreamReturn {
+    public const int ClassId = 80;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IStreamReturn.ReplyCode { get { return m_replyCode; } }
+    string IStreamReturn.ReplyText { get { return m_replyText; } }
+    string IStreamReturn.Exchange { get { return m_exchange; } }
+    string IStreamReturn.RoutingKey { get { return m_routingKey; } }
+
+    public StreamReturn() {}
+    public StreamReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "stream.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamDeliver: RabbitMQ.Client.Impl.MethodBase, IStreamDeliver {
+    public const int ClassId = 80;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public string m_exchange;
+    public string m_queue;
+
+    string IStreamDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IStreamDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    string IStreamDeliver.Exchange { get { return m_exchange; } }
+    string IStreamDeliver.Queue { get { return m_queue; } }
+
+    public StreamDeliver() {}
+    public StreamDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      string initExchange,
+      string initQueue)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_exchange = initExchange;
+      m_queue = initQueue;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "stream.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_exchange = reader.ReadShortstr();
+      m_queue = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_queue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_queue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelect: RabbitMQ.Client.Impl.MethodBase, ITxSelect {
+    public const int ClassId = 90;
+    public const int MethodId = 10;
+
+
+
+    public TxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelectOk: RabbitMQ.Client.Impl.MethodBase, ITxSelectOk {
+    public const int ClassId = 90;
+    public const int MethodId = 11;
+
+
+
+    public TxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "tx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommit: RabbitMQ.Client.Impl.MethodBase, ITxCommit {
+    public const int ClassId = 90;
+    public const int MethodId = 20;
+
+
+
+    public TxCommit(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "tx.commit"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommitOk: RabbitMQ.Client.Impl.MethodBase, ITxCommitOk {
+    public const int ClassId = 90;
+    public const int MethodId = 21;
+
+
+
+    public TxCommitOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "tx.commit-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollback: RabbitMQ.Client.Impl.MethodBase, ITxRollback {
+    public const int ClassId = 90;
+    public const int MethodId = 30;
+
+
+
+    public TxRollback(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "tx.rollback"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollbackOk: RabbitMQ.Client.Impl.MethodBase, ITxRollbackOk {
+    public const int ClassId = 90;
+    public const int MethodId = 31;
+
+
+
+    public TxRollbackOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "tx.rollback-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelect: RabbitMQ.Client.Impl.MethodBase, IDtxSelect {
+    public const int ClassId = 100;
+    public const int MethodId = 10;
+
+
+
+    public DtxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "dtx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelectOk: RabbitMQ.Client.Impl.MethodBase, IDtxSelectOk {
+    public const int ClassId = 100;
+    public const int MethodId = 11;
+
+
+
+    public DtxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "dtx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStart: RabbitMQ.Client.Impl.MethodBase, IDtxStart {
+    public const int ClassId = 100;
+    public const int MethodId = 20;
+
+    public string m_dtxIdentifier;
+
+    string IDtxStart.DtxIdentifier { get { return m_dtxIdentifier; } }
+
+    public DtxStart() {}
+    public DtxStart(
+      string initDtxIdentifier)
+    {
+      m_dtxIdentifier = initDtxIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "dtx.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_dtxIdentifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_dtxIdentifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_dtxIdentifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStartOk: RabbitMQ.Client.Impl.MethodBase, IDtxStartOk {
+    public const int ClassId = 100;
+    public const int MethodId = 21;
+
+
+
+    public DtxStartOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "dtx.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TunnelRequest: RabbitMQ.Client.Impl.MethodBase, ITunnelRequest {
+    public const int ClassId = 110;
+    public const int MethodId = 10;
+
+    public System.Collections.IDictionary m_metaData;
+
+    System.Collections.IDictionary ITunnelRequest.MetaData { get { return m_metaData; } }
+
+    public TunnelRequest() {}
+    public TunnelRequest(
+      System.Collections.IDictionary initMetaData)
+    {
+      m_metaData = initMetaData;
+    }
+
+    public override int ProtocolClassId { get { return 110; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tunnel.request"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_metaData = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_metaData);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_metaData);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestInteger: RabbitMQ.Client.Impl.MethodBase, ITestInteger {
+    public const int ClassId = 120;
+    public const int MethodId = 10;
+
+    public byte m_integer1;
+    public ushort m_integer2;
+    public uint m_integer3;
+    public ulong m_integer4;
+    public byte m_operation;
+
+    byte ITestInteger.Integer1 { get { return m_integer1; } }
+    ushort ITestInteger.Integer2 { get { return m_integer2; } }
+    uint ITestInteger.Integer3 { get { return m_integer3; } }
+    ulong ITestInteger.Integer4 { get { return m_integer4; } }
+    byte ITestInteger.Operation { get { return m_operation; } }
+
+    public TestInteger() {}
+    public TestInteger(
+      byte initInteger1,
+      ushort initInteger2,
+      uint initInteger3,
+      ulong initInteger4,
+      byte initOperation)
+    {
+      m_integer1 = initInteger1;
+      m_integer2 = initInteger2;
+      m_integer3 = initInteger3;
+      m_integer4 = initInteger4;
+      m_operation = initOperation;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "test.integer"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_integer1 = reader.ReadOctet();
+      m_integer2 = reader.ReadShort();
+      m_integer3 = reader.ReadLong();
+      m_integer4 = reader.ReadLonglong();
+      m_operation = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteOctet(m_integer1);
+      writer.WriteShort(m_integer2);
+      writer.WriteLong(m_integer3);
+      writer.WriteLonglong(m_integer4);
+      writer.WriteOctet(m_operation);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_integer1); sb.Append(",");
+      sb.Append(m_integer2); sb.Append(",");
+      sb.Append(m_integer3); sb.Append(",");
+      sb.Append(m_integer4); sb.Append(",");
+      sb.Append(m_operation);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestIntegerOk: RabbitMQ.Client.Impl.MethodBase, ITestIntegerOk {
+    public const int ClassId = 120;
+    public const int MethodId = 11;
+
+    public ulong m_result;
+
+    ulong ITestIntegerOk.Result { get { return m_result; } }
+
+    public TestIntegerOk() {}
+    public TestIntegerOk(
+      ulong initResult)
+    {
+      m_result = initResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "test.integer-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_result = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_result);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_result);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestString: RabbitMQ.Client.Impl.MethodBase, ITestString {
+    public const int ClassId = 120;
+    public const int MethodId = 20;
+
+    public string m_string1;
+    public byte[] m_string2;
+    public byte m_operation;
+
+    string ITestString.String1 { get { return m_string1; } }
+    byte[] ITestString.String2 { get { return m_string2; } }
+    byte ITestString.Operation { get { return m_operation; } }
+
+    public TestString() {}
+    public TestString(
+      string initString1,
+      byte[] initString2,
+      byte initOperation)
+    {
+      m_string1 = initString1;
+      m_string2 = initString2;
+      m_operation = initOperation;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "test.string"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_string1 = reader.ReadShortstr();
+      m_string2 = reader.ReadLongstr();
+      m_operation = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_string1);
+      writer.WriteLongstr(m_string2);
+      writer.WriteOctet(m_operation);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_string1); sb.Append(",");
+      sb.Append(m_string2); sb.Append(",");
+      sb.Append(m_operation);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestStringOk: RabbitMQ.Client.Impl.MethodBase, ITestStringOk {
+    public const int ClassId = 120;
+    public const int MethodId = 21;
+
+    public byte[] m_result;
+
+    byte[] ITestStringOk.Result { get { return m_result; } }
+
+    public TestStringOk() {}
+    public TestStringOk(
+      byte[] initResult)
+    {
+      m_result = initResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "test.string-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_result = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_result);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_result);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestTable: RabbitMQ.Client.Impl.MethodBase, ITestTable {
+    public const int ClassId = 120;
+    public const int MethodId = 30;
+
+    public System.Collections.IDictionary m_table;
+    public byte m_integerOp;
+    public byte m_stringOp;
+
+    System.Collections.IDictionary ITestTable.Table { get { return m_table; } }
+    byte ITestTable.IntegerOp { get { return m_integerOp; } }
+    byte ITestTable.StringOp { get { return m_stringOp; } }
+
+    public TestTable() {}
+    public TestTable(
+      System.Collections.IDictionary initTable,
+      byte initIntegerOp,
+      byte initStringOp)
+    {
+      m_table = initTable;
+      m_integerOp = initIntegerOp;
+      m_stringOp = initStringOp;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "test.table"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_table = reader.ReadTable();
+      m_integerOp = reader.ReadOctet();
+      m_stringOp = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_table);
+      writer.WriteOctet(m_integerOp);
+      writer.WriteOctet(m_stringOp);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_table); sb.Append(",");
+      sb.Append(m_integerOp); sb.Append(",");
+      sb.Append(m_stringOp);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestTableOk: RabbitMQ.Client.Impl.MethodBase, ITestTableOk {
+    public const int ClassId = 120;
+    public const int MethodId = 31;
+
+    public ulong m_integerResult;
+    public byte[] m_stringResult;
+
+    ulong ITestTableOk.IntegerResult { get { return m_integerResult; } }
+    byte[] ITestTableOk.StringResult { get { return m_stringResult; } }
+
+    public TestTableOk() {}
+    public TestTableOk(
+      ulong initIntegerResult,
+      byte[] initStringResult)
+    {
+      m_integerResult = initIntegerResult;
+      m_stringResult = initStringResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "test.table-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_integerResult = reader.ReadLonglong();
+      m_stringResult = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_integerResult);
+      writer.WriteLongstr(m_stringResult);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_integerResult); sb.Append(",");
+      sb.Append(m_stringResult);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestContent: RabbitMQ.Client.Impl.MethodBase, ITestContent {
+    public const int ClassId = 120;
+    public const int MethodId = 40;
+
+
+
+    public TestContent(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "test.content"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestContentOk: RabbitMQ.Client.Impl.MethodBase, ITestContentOk {
+    public const int ClassId = 120;
+    public const int MethodId = 41;
+
+    public uint m_contentChecksum;
+
+    uint ITestContentOk.ContentChecksum { get { return m_contentChecksum; } }
+
+    public TestContentOk() {}
+    public TestContentOk(
+      uint initContentChecksum)
+    {
+      m_contentChecksum = initContentChecksum;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "test.content-ok"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_contentChecksum = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_contentChecksum);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_contentChecksum);
+      sb.Append(")");
+    }
+  }
+
+  public class Model: RabbitMQ.Client.Impl.ModelBase {
+    public Model(RabbitMQ.Client.Impl.ISession session): base(session) {}
+    public override System.UInt16 _Private_AccessRequest(
+      System.String @realm,
+      System.Boolean @exclusive,
+      System.Boolean @passive,
+      System.Boolean @active,
+      System.Boolean @write,
+      System.Boolean @read)
+    {
+      AccessRequest __req = new AccessRequest();
+      __req.m_realm = @realm;
+      __req.m_exclusive = @exclusive;
+      __req.m_passive = @passive;
+      __req.m_active = @active;
+      __req.m_write = @write;
+      __req.m_read = @read;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      AccessRequestOk __rep = __repBase as AccessRequestOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_ticket;
+    }
+    public override void _Private_BasicPublish(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @mandatory,
+      System.Boolean @immediate,
+      RabbitMQ.Client.IBasicProperties @basicProperties,
+      System.Byte[] @body)
+    {
+      BasicPublish __req = new BasicPublish();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_mandatory = @mandatory;
+      __req.m_immediate = @immediate;
+      ModelSend(__req, (BasicProperties) basicProperties,body);
+    }
+    public override void _Private_BasicConsume(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @consumerTag,
+      System.Boolean @noLocal,
+      System.Boolean @noAck,
+      System.Boolean @exclusive,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @filter)
+    {
+      BasicConsume __req = new BasicConsume();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_consumerTag = @consumerTag;
+      __req.m_noLocal = @noLocal;
+      __req.m_noAck = @noAck;
+      __req.m_exclusive = @exclusive;
+      __req.m_nowait = @nowait;
+      if (@filter != null) {
+        throw new UnsupportedMethodFieldException("_Private_BasicConsume","filter");
+      }
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicCancel(
+      System.String @consumerTag,
+      System.Boolean @nowait)
+    {
+      BasicCancel __req = new BasicCancel();
+      __req.m_consumerTag = @consumerTag;
+      __req.m_nowait = @nowait;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelOpen(
+      System.String @outOfBand)
+    {
+      ChannelOpen __req = new ChannelOpen();
+      __req.m_outOfBand = @outOfBand;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelOpenOk __rep = __repBase as ChannelOpenOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ChannelCloseOk()
+    {
+      ChannelCloseOk __req = new ChannelCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ChannelClose __req = new ChannelClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicGet(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @noAck)
+    {
+      BasicGet __req = new BasicGet();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_noAck = @noAck;
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.Impl.ConnectionTuneDetails ConnectionStartOk(
+      System.Collections.IDictionary @clientProperties,
+      System.String @mechanism,
+      System.Byte[] @response,
+      System.String @locale)
+    {
+      ConnectionStartOk __req = new ConnectionStartOk();
+      __req.m_clientProperties = @clientProperties;
+      __req.m_mechanism = @mechanism;
+      __req.m_response = @response;
+      __req.m_locale = @locale;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionTune __rep = __repBase as ConnectionTune;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      RabbitMQ.Client.Impl.ConnectionTuneDetails __result = new RabbitMQ.Client.Impl.ConnectionTuneDetails();
+      __result.channelMax = __rep.m_channelMax;
+      __result.frameMax = __rep.m_frameMax;
+      __result.heartbeat = __rep.m_heartbeat;
+      return __result;
+    }
+    public override void ConnectionTuneOk(
+      System.UInt16 @channelMax,
+      System.UInt32 @frameMax,
+      System.UInt16 @heartbeat)
+    {
+      ConnectionTuneOk __req = new ConnectionTuneOk();
+      __req.m_channelMax = @channelMax;
+      __req.m_frameMax = @frameMax;
+      __req.m_heartbeat = @heartbeat;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionOpen(
+      System.String @virtualHost,
+      System.String @capabilities,
+      System.Boolean @insist)
+    {
+      ConnectionOpen __req = new ConnectionOpen();
+      __req.m_virtualHost = @virtualHost;
+      __req.m_capabilities = @capabilities;
+      __req.m_insist = @insist;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ConnectionClose __req = new ConnectionClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionCloseOk __rep = __repBase as ConnectionCloseOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ConnectionCloseOk()
+    {
+      ConnectionCloseOk __req = new ConnectionCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.IBasicProperties CreateBasicProperties()
+    {
+      return new BasicProperties();
+    }
+    public override RabbitMQ.Client.IFileProperties CreateFileProperties()
+    {
+      return new FileProperties();
+    }
+    public override RabbitMQ.Client.IStreamProperties CreateStreamProperties()
+    {
+      return new StreamProperties();
+    }
+    public override void ChannelFlow(
+      System.Boolean @active)
+    {
+      ChannelFlow __req = new ChannelFlow();
+      __req.m_active = @active;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelFlowOk __rep = __repBase as ChannelFlowOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDeclare(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @type,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @autoDelete,
+      System.Boolean @internal,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      ExchangeDeclare __req = new ExchangeDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_type = @type;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_internal = @internal;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeclareOk __rep = __repBase as ExchangeDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDelete(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.Boolean @ifUnused,
+      System.Boolean @nowait)
+    {
+      ExchangeDelete __req = new ExchangeDelete();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeleteOk __rep = __repBase as ExchangeDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override System.String QueueDeclare(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @exclusive,
+      System.Boolean @autoDelete,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueDeclare __req = new QueueDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_exclusive = @exclusive;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return null;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeclareOk __rep = __repBase as QueueDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_queue;
+    }
+    public override void QueueBind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueBind __req = new QueueBind();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueBindOk __rep = __repBase as QueueBindOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void QueueUnbind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Collections.IDictionary @arguments)
+    {
+      throw new UnsupportedMethodException("QueueUnbind");
+    }
+    public override System.UInt32 QueuePurge(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @nowait)
+    {
+      QueuePurge __req = new QueuePurge();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueuePurgeOk __rep = __repBase as QueuePurgeOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override System.UInt32 QueueDelete(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @ifUnused,
+      System.Boolean @ifEmpty,
+      System.Boolean @nowait)
+    {
+      QueueDelete __req = new QueueDelete();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_ifEmpty = @ifEmpty;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeleteOk __rep = __repBase as QueueDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override void BasicQos(
+      System.UInt32 @prefetchSize,
+      System.UInt16 @prefetchCount,
+      System.Boolean @global)
+    {
+      BasicQos __req = new BasicQos();
+      __req.m_prefetchSize = @prefetchSize;
+      __req.m_prefetchCount = @prefetchCount;
+      __req.m_global = @global;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      BasicQosOk __rep = __repBase as BasicQosOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void BasicAck(
+      System.UInt64 @deliveryTag,
+      System.Boolean @multiple)
+    {
+      BasicAck __req = new BasicAck();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_multiple = @multiple;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicReject(
+      System.UInt64 @deliveryTag,
+      System.Boolean @requeue)
+    {
+      BasicReject __req = new BasicReject();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_requeue = @requeue;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicRecover(
+      System.Boolean @requeue)
+    {
+      BasicRecover __req = new BasicRecover();
+      __req.m_requeue = @requeue;
+      ModelSend(__req,null,null);
+    }
+    public override void TxSelect()
+    {
+      TxSelect __req = new TxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxSelectOk __rep = __repBase as TxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxCommit()
+    {
+      TxCommit __req = new TxCommit();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxCommitOk __rep = __repBase as TxCommitOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxRollback()
+    {
+      TxRollback __req = new TxRollback();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxRollbackOk __rep = __repBase as TxRollbackOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxSelect()
+    {
+      DtxSelect __req = new DtxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxSelectOk __rep = __repBase as DtxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxStart(
+      System.String @dtxIdentifier)
+    {
+      DtxStart __req = new DtxStart();
+      __req.m_dtxIdentifier = @dtxIdentifier;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxStartOk __rep = __repBase as DtxStartOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override bool DispatchAsynchronous(RabbitMQ.Client.Impl.Command cmd) {
+      RabbitMQ.Client.Impl.MethodBase __method = (RabbitMQ.Client.Impl.MethodBase) cmd.Method;
+      switch ((__method.ProtocolClassId << 16) | __method.ProtocolMethodId) {
+        case 3932181: {
+          BasicConsumeOk __impl = (BasicConsumeOk) __method;
+          HandleBasicConsumeOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932191: {
+          BasicCancelOk __impl = (BasicCancelOk) __method;
+          HandleBasicCancelOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932231: {
+          BasicGetOk __impl = (BasicGetOk) __method;
+          HandleBasicGetOk(
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            __impl.m_messageCount,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932232: {
+          HandleBasicGetEmpty();
+          return true;
+        }
+        case 3932220: {
+          BasicDeliver __impl = (BasicDeliver) __method;
+          HandleBasicDeliver(
+            __impl.m_consumerTag,
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932210: {
+          BasicReturn __impl = (BasicReturn) __method;
+          HandleBasicReturn(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 1310760: {
+          ChannelClose __impl = (ChannelClose) __method;
+          HandleChannelClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        case 1310761: {
+          HandleChannelCloseOk();
+          return true;
+        }
+        case 655370: {
+          ConnectionStart __impl = (ConnectionStart) __method;
+          HandleConnectionStart(
+            __impl.m_versionMajor,
+            __impl.m_versionMinor,
+            __impl.m_serverProperties,
+            __impl.m_mechanisms,
+            __impl.m_locales);
+          return true;
+        }
+        case 655401: {
+          ConnectionOpenOk __impl = (ConnectionOpenOk) __method;
+          HandleConnectionOpenOk(
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655410: {
+          ConnectionRedirect __impl = (ConnectionRedirect) __method;
+          HandleConnectionRedirect(
+            __impl.m_host,
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655420: {
+          ConnectionClose __impl = (ConnectionClose) __method;
+          HandleConnectionClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        default: return false;
+      }
+    }
+  }
+}
diff --git a/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-9.cs b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-9.cs
new file mode 100644
index 00000000000..d42c0f8c30d
--- /dev/null
+++ b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-0-9.cs
@@ -0,0 +1,8903 @@
+// Autogenerated code. Do not edit.
+
+using RabbitMQ.Client;
+using RabbitMQ.Client.Exceptions;
+
+namespace RabbitMQ.Client.Framing.v0_9 {
+  public class Protocol: RabbitMQ.Client.Framing.Impl.v0_9.ProtocolBase {
+    ///<summary>Protocol major version (= 0)</summary>
+    public override int MajorVersion { get { return 0; } }
+    ///<summary>Protocol minor version (= 9)</summary>
+    public override int MinorVersion { get { return 9; } }
+    ///<summary>Protocol API name (= AMQP_0_9)</summary>
+    public override string ApiName { get { return "AMQP_0_9"; } }
+    ///<summary>Default TCP port (= 5672)</summary>
+    public override int DefaultPort { get { return 5672; } }
+
+    public override RabbitMQ.Client.Impl.MethodBase DecodeMethodFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+      ushort methodId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 10: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionStart result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionStartOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionSecure result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionSecure();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionSecureOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionSecureOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionTune result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionTune();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionTuneOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionTuneOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionOpen result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 42: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionRedirect result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionRedirect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionClose result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 51: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ConnectionCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ConnectionCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 20: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelOpen result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelFlow result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelFlow();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelFlowOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelFlowOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelClose result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelResume result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelResume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelPing result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelPing();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelPong result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelPong();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ChannelOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ChannelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 30: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.AccessRequest result = new RabbitMQ.Client.Framing.Impl.v0_9.AccessRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.AccessRequestOk result = new RabbitMQ.Client.Framing.Impl.v0_9.AccessRequestOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 40: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeclare result = new RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDelete result = new RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_9.ExchangeDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 50: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueDeclare result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueBind result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueBind();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueBindOk result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueBindOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueUnbind result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueUnbind();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 51: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueUnbindOk result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueUnbindOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueuePurge result = new RabbitMQ.Client.Framing.Impl.v0_9.QueuePurge();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueuePurgeOk result = new RabbitMQ.Client.Framing.Impl.v0_9.QueuePurgeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueDelete result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_9.QueueDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_9.QueueDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 60: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicQos result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicQosOk result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicConsume result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicCancel result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicPublish result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicReturn result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicDeliver result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicGet result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicGet();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 71: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicGetOk result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicGetOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 72: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicGetEmpty result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicGetEmpty();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicAck result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicReject result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_9.BasicRecover result = new RabbitMQ.Client.Framing.Impl.v0_9.BasicRecover();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 70: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileQos result = new RabbitMQ.Client.Framing.Impl.v0_9.FileQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileQosOk result = new RabbitMQ.Client.Framing.Impl.v0_9.FileQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileConsume result = new RabbitMQ.Client.Framing.Impl.v0_9.FileConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_9.FileConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileCancel result = new RabbitMQ.Client.Framing.Impl.v0_9.FileCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_9.FileCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileOpen result = new RabbitMQ.Client.Framing.Impl.v0_9.FileOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_9.FileOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileStage result = new RabbitMQ.Client.Framing.Impl.v0_9.FileStage();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FilePublish result = new RabbitMQ.Client.Framing.Impl.v0_9.FilePublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileReturn result = new RabbitMQ.Client.Framing.Impl.v0_9.FileReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileDeliver result = new RabbitMQ.Client.Framing.Impl.v0_9.FileDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileAck result = new RabbitMQ.Client.Framing.Impl.v0_9.FileAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_9.FileReject result = new RabbitMQ.Client.Framing.Impl.v0_9.FileReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 80: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamQos result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamQosOk result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamConsume result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamCancel result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamPublish result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamReturn result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_9.StreamDeliver result = new RabbitMQ.Client.Framing.Impl.v0_9.StreamDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 90: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxSelect result = new RabbitMQ.Client.Framing.Impl.v0_9.TxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_9.TxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxCommit result = new RabbitMQ.Client.Framing.Impl.v0_9.TxCommit();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxCommitOk result = new RabbitMQ.Client.Framing.Impl.v0_9.TxCommitOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxRollback result = new RabbitMQ.Client.Framing.Impl.v0_9.TxRollback();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TxRollbackOk result = new RabbitMQ.Client.Framing.Impl.v0_9.TxRollbackOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 100: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.DtxSelect result = new RabbitMQ.Client.Framing.Impl.v0_9.DtxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_9.DtxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_9.DtxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.DtxStart result = new RabbitMQ.Client.Framing.Impl.v0_9.DtxStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_9.DtxStartOk result = new RabbitMQ.Client.Framing.Impl.v0_9.DtxStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 110: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.TunnelRequest result = new RabbitMQ.Client.Framing.Impl.v0_9.TunnelRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 120: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageTransfer result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageTransfer();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageConsume result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageCancel result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageGet result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageGet();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageRecover result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageRecover();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageOpen result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageClose result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageAppend result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageAppend();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageCheckpoint result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageCheckpoint();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageResume result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageResume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 110: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageQos result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 500: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageOk result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 510: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageEmpty result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageEmpty();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 520: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageReject result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 530: {
+              RabbitMQ.Client.Framing.Impl.v0_9.MessageOffset result = new RabbitMQ.Client.Framing.Impl.v0_9.MessageOffset();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, methodId);
+    }
+
+    public override RabbitMQ.Client.Impl.ContentHeaderBase DecodeContentHeaderFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 60: return new BasicProperties();
+        case 70: return new FileProperties();
+        case 80: return new StreamProperties();
+        case 110: return new TunnelProperties();
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, 0);
+    }
+  }
+  public class Constants {
+    ///<summary>(= 1)</summary>
+    public const int FrameMethod = 1;
+    ///<summary>(= 2)</summary>
+    public const int FrameHeader = 2;
+    ///<summary>(= 3)</summary>
+    public const int FrameBody = 3;
+    ///<summary>(= 4)</summary>
+    public const int FrameOobMethod = 4;
+    ///<summary>(= 5)</summary>
+    public const int FrameOobHeader = 5;
+    ///<summary>(= 6)</summary>
+    public const int FrameOobBody = 6;
+    ///<summary>(= 7)</summary>
+    public const int FrameTrace = 7;
+    ///<summary>(= 8)</summary>
+    public const int FrameHeartbeat = 8;
+    ///<summary>(= 4096)</summary>
+    public const int FrameMinSize = 4096;
+    ///<summary>(= 206)</summary>
+    public const int FrameEnd = 206;
+    ///<summary>(= 200)</summary>
+    public const int ReplySuccess = 200;
+    ///<summary>(= 310)</summary>
+    public const int NotDelivered = 310;
+    ///<summary>(= 311)</summary>
+    public const int ContentTooLarge = 311;
+    ///<summary>(= 312)</summary>
+    public const int NoRoute = 312;
+    ///<summary>(= 313)</summary>
+    public const int NoConsumers = 313;
+    ///<summary>(= 320)</summary>
+    public const int ConnectionForced = 320;
+    ///<summary>(= 402)</summary>
+    public const int InvalidPath = 402;
+    ///<summary>(= 403)</summary>
+    public const int AccessRefused = 403;
+    ///<summary>(= 404)</summary>
+    public const int NotFound = 404;
+    ///<summary>(= 405)</summary>
+    public const int ResourceLocked = 405;
+    ///<summary>(= 406)</summary>
+    public const int PreconditionFailed = 406;
+    ///<summary>(= 501)</summary>
+    public const int FrameError = 501;
+    ///<summary>(= 502)</summary>
+    public const int SyntaxError = 502;
+    ///<summary>(= 503)</summary>
+    public const int CommandInvalid = 503;
+    ///<summary>(= 504)</summary>
+    public const int ChannelError = 504;
+    ///<summary>(= 506)</summary>
+    public const int ResourceError = 506;
+    ///<summary>(= 530)</summary>
+    public const int NotAllowed = 530;
+    ///<summary>(= 540)</summary>
+    public const int NotImplemented = 540;
+    ///<summary>(= 541)</summary>
+    public const int InternalError = 541;
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start".</summary>
+  /// <remarks>
+  /// 
+  ///         This method starts the connection negotiation process by telling the client the
+  ///         protocol version that the server proposes, along with a list of security mechanisms
+  ///         which the client can use for authentication.
+  ///       
+  /// </remarks>
+  public interface IConnectionStart: IMethod {
+    /// <summary>
+    /// 
+    ///           The protocol version, major component, as transmitted in the AMQP protocol
+    ///           header. This, combined with the protocol minor component fully describe the
+    ///           protocol version, which is written in the format major-minor. Hence, with
+    ///           major=1, minor=3, the protocol version would be "1-3".
+    ///         
+    /// </summary>
+    byte VersionMajor { get; }
+    /// <summary>
+    /// 
+    ///           The protocol version, minor component, as transmitted in the AMQP protocol
+    ///           header. This, combined with the protocol major component fully describe the
+    ///           protocol version, which is written in the format major-minor. Hence, with
+    ///           major=1, minor=3, the protocol version would be "1-3".
+    ///         
+    /// </summary>
+    byte VersionMinor { get; }
+    // (no documentation)
+    System.Collections.IDictionary ServerProperties { get; }
+    /// <summary>
+    /// 
+    ///           A list of the security mechanisms that the server supports, delimited by spaces.
+    ///         
+    /// </summary>
+    byte[] Mechanisms { get; }
+    /// <summary>
+    /// 
+    ///           A list of the message locales that the server supports, delimited by spaces. The
+    ///           locale defines the language in which the server will send reply texts.
+    ///         
+    /// </summary>
+    byte[] Locales { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method selects a SASL security mechanism.
+  ///       
+  /// </remarks>
+  public interface IConnectionStartOk: IMethod {
+    // (no documentation)
+    System.Collections.IDictionary ClientProperties { get; }
+    /// <summary>
+    /// 
+    ///           A single security mechanisms selected by the client, which must be one of those
+    ///           specified by the server.
+    ///         
+    /// </summary>
+    string Mechanism { get; }
+    /// <summary>
+    /// 
+    ///           A block of opaque data passed to the security mechanism. The contents of this
+    ///           data are defined by the SASL security mechanism.
+    ///         
+    /// </summary>
+    byte[] Response { get; }
+    /// <summary>
+    /// 
+    ///           A single message locale selected by the client, which must be one of those
+    ///           specified by the server.
+    ///         
+    /// </summary>
+    string Locale { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure".</summary>
+  /// <remarks>
+  /// 
+  ///         The SASL protocol works by exchanging challenges and responses until both peers have
+  ///         received sufficient information to authenticate each other. This method challenges
+  ///         the client to provide more information.
+  ///       
+  /// </remarks>
+  public interface IConnectionSecure: IMethod {
+    /// <summary>
+    /// 
+    ///           Challenge information, a block of opaque binary data passed to the security
+    ///           mechanism.
+    ///         
+    /// </summary>
+    byte[] Challenge { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method attempts to authenticate, passing a block of SASL data for the security
+  ///         mechanism at the server side.
+  ///       
+  /// </remarks>
+  public interface IConnectionSecureOk: IMethod {
+    /// <summary>
+    /// 
+    ///           A block of opaque data passed to the security mechanism. The contents of this
+    ///           data are defined by the SASL security mechanism.
+    ///         
+    /// </summary>
+    byte[] Response { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune".</summary>
+  /// <remarks>
+  /// 
+  ///         This method proposes a set of connection configuration values to the client. The
+  ///         client can accept and/or adjust these.
+  ///       
+  /// </remarks>
+  public interface IConnectionTune: IMethod {
+    /// <summary>
+    /// 
+    ///           The maximum total number of channels that the server allows per connection. Zero
+    ///           means that the server does not impose a fixed limit, but the number of allowed
+    ///           channels may be limited by available server resources.
+    ///         
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///           The largest frame size that the server proposes for the connection. The client
+    ///           can negotiate a lower value. Zero means that the server does not impose any
+    ///           specific limit but may reject very large frames if it cannot allocate resources
+    ///           for them.
+    ///         
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///           The delay, in seconds, of the connection heartbeat that the server wants.
+    ///           Zero means the server does not want a heartbeat.
+    ///         
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method sends the client's connection tuning parameters to the server.
+  ///         Certain fields are negotiated, others provide capability information.
+  ///       
+  /// </remarks>
+  public interface IConnectionTuneOk: IMethod {
+    /// <summary>
+    /// 
+    ///           The maximum total number of channels that the client will use per connection.
+    ///         
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///           The largest frame size that the client and server will use for the connection.
+    ///           Zero means that the client does not impose any specific limit but may reject
+    ///           very large frames if it cannot allocate resources for them. Note that the
+    ///           frame-max limit applies principally to content frames, where large contents can
+    ///           be broken into frames of arbitrary size.
+    ///         
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///           The delay, in seconds, of the connection heartbeat that the client wants. Zero
+    ///           means the client does not want a heartbeat.
+    ///         
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open".</summary>
+  /// <remarks>
+  /// 
+  ///         This method opens a connection to a virtual host, which is a collection of
+  ///         resources, and acts to separate multiple application domains within a server.
+  ///         The server may apply arbitrary limits per virtual host, such as the number
+  ///         of each type of entity that may be used, per connection and/or in total.
+  ///       
+  /// </remarks>
+  public interface IConnectionOpen: IMethod {
+    /// <summary>
+    /// 
+    ///           The name of the virtual host to work with.
+    ///         
+    /// </summary>
+    string VirtualHost { get; }
+    /// <summary>
+    /// 
+    ///           The client can specify zero or more capability names, delimited by spaces.
+    ///           The server can use this string to how to process the client's connection
+    ///           request.
+    ///         
+    /// </summary>
+    string Capabilities { get; }
+    /// <summary>
+    /// 
+    ///           In a configuration with multiple collaborating servers, the server may respond
+    ///           to a Connection.Open method with a Connection.Redirect. The insist option tells
+    ///           the server that the client is insisting on a connection to the specified server.
+    ///         
+    /// </summary>
+    bool Insist { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method signals to the client that the connection is ready for use.
+  ///       
+  /// </remarks>
+  public interface IConnectionOpenOk: IMethod {
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.redirect".</summary>
+  /// <remarks>
+  /// 
+  ///         This method redirects the client to another server, based on the requested virtual
+  ///         host and/or capabilities.
+  ///       
+  /// </remarks>
+  public interface IConnectionRedirect: IMethod {
+    /// <summary>
+    /// 
+    ///           Specifies the server to connect to. This is an IP address or a DNS name,
+    ///           optionally followed by a colon and a port number. If no port number is
+    ///           specified, the client should use the default port number for the protocol.
+    ///         
+    /// </summary>
+    string Host { get; }
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close".</summary>
+  /// <remarks>
+  /// 
+  ///         This method indicates that the sender wants to close the connection. This may be
+  ///         due to internal conditions (e.g. a forced shut-down) or due to an error handling
+  ///         a specific method, i.e. an exception. When a close is due to an exception, the
+  ///         sender provides the class and method id of the method which caused the exception.
+  ///       
+  /// </remarks>
+  public interface IConnectionClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///           When the close is provoked by a method exception, this is the class of the
+    ///           method.
+    ///         
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///           When the close is provoked by a method exception, this is the ID of the method.
+    ///         
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms a Connection.Close method and tells the recipient that it is
+  ///         safe to release resources for the connection and close the socket.
+  ///       
+  /// </remarks>
+  public interface IConnectionCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open".</summary>
+  /// <remarks>
+  /// 
+  ///         This method opens a channel to the server.
+  ///       
+  /// </remarks>
+  public interface IChannelOpen: IMethod {
+    /// <summary>
+    /// 
+    ///           Configures out-of-band transfers on this channel. The syntax and meaning of this
+    ///           field will be formally defined at a later date.
+    ///         
+    /// </summary>
+    string OutOfBand { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method signals to the client that the channel is ready for use.
+  ///       
+  /// </remarks>
+  public interface IChannelOpenOk: IMethod {
+    // (no documentation)
+    byte[] ChannelId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow".</summary>
+  /// <remarks>
+  /// 
+  ///         This method asks the peer to pause or restart the flow of content data. This is a
+  ///         simple flow-control mechanism that a peer can use to avoid overflowing its queues or
+  ///         otherwise finding itself receiving more messages than it can process. Note that this
+  ///         method is not intended for window control. The peer that receives a disable flow
+  ///         method should finish sending the current content frame, if any, then pause.
+  ///       
+  /// </remarks>
+  public interface IChannelFlow: IMethod {
+    /// <summary>
+    /// 
+    ///           If 1, the peer starts sending content frames. If 0, the peer stops sending
+    ///           content frames.
+    ///         
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         Confirms to the peer that a flow command was received and processed.
+  ///       
+  /// </remarks>
+  public interface IChannelFlowOk: IMethod {
+    /// <summary>
+    /// 
+    ///           Confirms the setting of the processed flow method: 1 means the peer will start
+    ///           sending or continue to send content frames; 0 means it will not.
+    ///         
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close".</summary>
+  /// <remarks>
+  /// 
+  ///         This method indicates that the sender wants to close the channel. This may be due to
+  ///         internal conditions (e.g. a forced shut-down) or due to an error handling a specific
+  ///         method, i.e. an exception. When a close is due to an exception, the sender provides
+  ///         the class and method id of the method which caused the exception.
+  ///       
+  /// </remarks>
+  public interface IChannelClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///           When the close is provoked by a method exception, this is the class of the
+    ///           method.
+    ///         
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///           When the close is provoked by a method exception, this is the ID of the method.
+    ///         
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms a Channel.Close method and tells the recipient that it is safe
+  ///         to release resources for the channel.
+  ///       
+  /// </remarks>
+  public interface IChannelCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.resume".</summary>
+  /// <remarks>
+  /// 
+  ///         This method resume a previously interrupted channel.
+  ///       
+  /// </remarks>
+  public interface IChannelResume: IMethod {
+    // (no documentation)
+    byte[] ChannelId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.ping".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Request that the recipient issue a pong request.
+  ///       
+  /// </remarks>
+  public interface IChannelPing: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.pong".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Issued after a ping request is received. Note that this is a
+  ///         request issued after receiving a ping, not a response to
+  ///         receiving a ping.
+  ///       
+  /// </remarks>
+  public interface IChannelPong: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.ok".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Signals normal completion of a method.
+  ///       
+  /// </remarks>
+  public interface IChannelOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request".</summary>
+  /// <remarks>
+  /// 
+  ///         This method requests an access ticket for an access realm. The server
+  ///         responds by granting the access ticket. If the client does not have
+  ///         access rights to the requested realm this causes a connection exception.
+  ///         Access tickets are a per-channel resource.
+  ///       
+  /// </remarks>
+  public interface IAccessRequest: IMethod {
+    /// <summary>
+    /// 
+    ///           Specifies the name of the realm to which the client is requesting access.
+    ///           The realm is a configured server-side object that collects a set of
+    ///           resources (exchanges, queues, etc.).  If the channel has already requested
+    ///           an access ticket onto this realm, the previous ticket is destroyed and a
+    ///           new ticket is created with the requested access rights, if allowed.
+    ///         
+    /// </summary>
+    string Realm { get; }
+    /// <summary>
+    /// 
+    ///           Request exclusive access to the realm, meaning that this will be the only
+    ///           channel that uses the realm's resources.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           Request message passive access to the specified access realm. Passive
+    ///           access lets a client get information about resources in the realm but
+    ///           not to make any changes to them.
+    ///         
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///           Request message active access to the specified access realm. Active access lets
+    ///           a client get create and delete resources in the realm.
+    ///         
+    /// </summary>
+    bool Active { get; }
+    /// <summary>
+    /// 
+    ///           Request write access to the specified access realm. Write access lets a client
+    ///           publish messages to all exchanges in the realm.
+    ///         
+    /// </summary>
+    bool Write { get; }
+    /// <summary>
+    /// 
+    ///           Request read access to the specified access realm. Read access lets a client
+    ///           consume messages from queues in the realm.
+    ///         
+    /// </summary>
+    bool Read { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method provides the client with an access ticket. The access ticket is valid
+  ///         within the current channel and for the lifespan of the channel.
+  ///       
+  /// </remarks>
+  public interface IAccessRequestOk: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare".</summary>
+  /// <remarks>
+  /// 
+  ///         This method creates an exchange if it does not already exist, and if the exchange
+  ///         exists, verifies that it is of the correct and expected class.
+  ///       
+  /// </remarks>
+  public interface IExchangeDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///           When a client defines a new exchange, this belongs to the access realm of the
+    ///           ticket used. All further work done with that exchange must be done with an
+    ///           access ticket for the same realm.
+    ///         
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Each exchange belongs to one of a set of exchange types implemented by the
+    ///           server. The exchange types define the functionality of the exchange - i.e. how
+    ///           messages are routed through it. It is not valid or meaningful to attempt to
+    ///           change the type of an existing exchange.
+    ///         
+    /// </summary>
+    string Type { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not create the exchange. The client can use this to
+    ///           check whether an exchange exists without modifying the server state.
+    ///         
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///           If set when creating a new exchange, the exchange will be marked as durable.
+    ///           Durable exchanges remain active when a server restarts. Non-durable exchanges
+    ///           (transient exchanges) are purged if/when a server restarts.
+    ///         
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///           If set, the exchange is deleted when all queues have finished using it.
+    ///         
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///           If set, the exchange may not be used directly by publishers, but only when bound
+    ///           to other exchanges. Internal exchanges are used to construct wiring that is not
+    ///           visible to applications.
+    ///         
+    /// </summary>
+    bool Internal { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of arguments for the declaration. The syntax and semantics of these
+    ///           arguments depends on the server implementation. This field is ignored if passive
+    ///           is 1.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms a Declare method and confirms the name of the exchange,
+  ///         essential for automatically-named exchanges.
+  ///       
+  /// </remarks>
+  public interface IExchangeDeclareOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete".</summary>
+  /// <remarks>
+  /// 
+  ///         This method deletes an exchange. When an exchange is deleted all queue bindings on
+  ///         the exchange are cancelled.
+  ///       
+  /// </remarks>
+  public interface IExchangeDelete: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will only delete the exchange if it has no queue bindings. If
+    ///           the exchange has queue bindings the server does not delete it but raises a
+    ///           channel exception instead.
+    ///         
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete-ok".</summary>
+  /// <remarks>
+  /// This method confirms the deletion of an exchange.
+  /// </remarks>
+  public interface IExchangeDeleteOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare".</summary>
+  /// <remarks>
+  /// 
+  ///         This method creates or checks a queue. When creating a new queue the client can
+  ///         specify various properties that control the durability of the queue and its
+  ///         contents, and the level of sharing for the queue.
+  ///       
+  /// </remarks>
+  public interface IQueueDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///           When a client defines a new queue, this belongs to the access realm of the
+    ///           ticket used. All further work done with that queue must be done with an access
+    ///           ticket for the same realm.
+    ///         
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not create the queue. This field allows the client
+    ///           to assert the presence of a queue without modifying the server state.
+    ///         
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///           If set when creating a new queue, the queue will be marked as durable. Durable
+    ///           queues remain active when a server restarts. Non-durable queues (transient
+    ///           queues) are purged if/when a server restarts. Note that durable queues do not
+    ///           necessarily hold persistent messages, although it does not make sense to send
+    ///           persistent messages to a transient queue.
+    ///         
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///           Exclusive queues may only be consumed from by the current connection. Setting
+    ///           the 'exclusive' flag always implies 'auto-delete'.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           If set, the queue is deleted when all consumers have finished using it. Last
+    ///           consumer can be cancelled either explicitly or because its channel is closed. If
+    ///           there was no consumer ever on the queue, it won't be deleted.
+    ///         
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of arguments for the declaration. The syntax and semantics of these
+    ///           arguments depends on the server implementation. This field is ignored if passive
+    ///           is 1.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms a Declare method and confirms the name of the queue, essential
+  ///         for automatically-named queues.
+  ///       
+  /// </remarks>
+  public interface IQueueDeclareOk: IMethod {
+    /// <summary>
+    /// 
+    ///           Reports the name of the queue. If the server generated a queue name, this field
+    ///           contains that name.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           Reports the number of messages in the queue, which will be zero for
+    ///           newly-created queues.
+    ///         
+    /// </summary>
+    uint MessageCount { get; }
+    /// <summary>
+    /// 
+    ///           Reports the number of active consumers for the queue. Note that consumers can
+    ///           suspend activity (Channel.Flow) in which case they do not appear in this count.
+    ///         
+    /// </summary>
+    uint ConsumerCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind".</summary>
+  /// <remarks>
+  /// 
+  ///         This method binds a queue to an exchange. Until a queue is bound it will not receive
+  ///         any messages. In a classic messaging model, store-and-forward queues are bound to a
+  ///         direct exchange and subscription queues are bound to a topic exchange.
+  ///       
+  /// </remarks>
+  public interface IQueueBind: IMethod {
+    /// <summary>
+    /// 
+    ///           The client provides a valid access ticket giving "active" access rights to the
+    ///           queue's access realm.
+    ///         
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to bind. If the queue name is empty, refers to
+    ///           the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the routing key for the binding. The routing key is used for routing
+    ///           messages depending on the exchange configuration. Not all exchanges use a
+    ///           routing key - refer to the specific exchange documentation.  If the queue name
+    ///           is empty, the server uses the last queue declared on the channel.  If the
+    ///           routing key is also empty, the server uses this queue name for the routing
+    ///           key as well.  If the queue name is provided but the routing key is empty, the
+    ///           server does the binding with that empty routing key.  The meaning of empty
+    ///           routing keys depends on the exchange implementation.
+    ///         
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of arguments for the binding. The syntax and semantics of these arguments
+    ///           depends on the exchange class.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind-ok".</summary>
+  /// <remarks>
+  /// This method confirms that the bind was successful.
+  /// </remarks>
+  public interface IQueueBindOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.unbind".</summary>
+  /// <remarks>
+  /// This method unbinds a queue from an exchange.
+  /// </remarks>
+  public interface IQueueUnbind: IMethod {
+    /// <summary>
+    /// 
+    ///           The client provides a valid access ticket giving "active"
+    ///           access rights to the queue's access realm.
+    ///         
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// Specifies the name of the queue to unbind.
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// The name of the exchange to unbind from.
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key of the binding to unbind.
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// Specifies the arguments of the binding to unbind.
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.unbind-ok".</summary>
+  /// <remarks>
+  /// This method confirms that the unbind was successful.
+  /// </remarks>
+  public interface IQueueUnbindOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge".</summary>
+  /// <remarks>
+  /// 
+  ///         This method removes all messages from a queue. It does not cancel consumers. Purged
+  ///         messages are deleted without any formal "undo" mechanism.
+  ///       
+  /// </remarks>
+  public interface IQueuePurge: IMethod {
+    /// <summary>
+    /// The access ticket must be for the access realm that holds the queue.
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to purge. If the queue name is empty, refers to
+    ///           the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge-ok".</summary>
+  /// <remarks>
+  /// This method confirms the purge of a queue.
+  /// </remarks>
+  public interface IQueuePurgeOk: IMethod {
+    /// <summary>
+    /// Reports the number of messages purged.
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete".</summary>
+  /// <remarks>
+  /// 
+  ///         This method deletes a queue. When a queue is deleted any pending messages are sent
+  ///         to a dead-letter queue if this is defined in the server configuration, and all
+  ///         consumers on the queue are cancelled.
+  ///       
+  /// </remarks>
+  public interface IQueueDelete: IMethod {
+    /// <summary>
+    /// 
+    ///           The client provides a valid access ticket giving "active" access rights to the
+    ///           queue's access realm.
+    ///         
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to delete. If the queue name is empty, refers to
+    ///           the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will only delete the queue if it has no consumers. If the
+    ///           queue has consumers the server does does not delete it but raises a channel
+    ///           exception instead.
+    ///         
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will only delete the queue if it has no messages.
+    ///         
+    /// </summary>
+    bool IfEmpty { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete-ok".</summary>
+  /// <remarks>
+  /// This method confirms the deletion of a queue.
+  /// </remarks>
+  public interface IQueueDeleteOk: IMethod {
+    /// <summary>
+    /// Reports the number of messages purged.
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos".</summary>
+  /// <remarks>
+  /// 
+  ///         This method requests a specific quality of service. The QoS can be specified for the
+  ///         current channel or for all channels on the connection. The particular properties and
+  ///         semantics of a qos method always depend on the content class semantics. Though the
+  ///         qos method could in principle apply to both peers, it is currently meaningful only
+  ///         for the server.
+  ///       
+  /// </remarks>
+  public interface IBasicQos: IMethod {
+    /// <summary>
+    /// 
+    ///           The client can request that messages be sent in advance so that when the client
+    ///           finishes processing a message, the following message is already held locally,
+    ///           rather than needing to be sent down the channel. Prefetching gives a performance
+    ///           improvement. This field specifies the prefetch window size in octets. The server
+    ///           will send a message in advance if it is equal to or smaller in size than the
+    ///           available prefetch size (and also falls into other prefetch limits). May be set
+    ///           to zero, meaning "no specific limit", although other prefetch limits may still
+    ///           apply. The prefetch-size is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///           Specifies a prefetch window in terms of whole messages. This field may be used
+    ///           in combination with the prefetch-size field; a message will only be sent in
+    ///           advance if both prefetch windows (and those at the channel and connection level)
+    ///           allow it. The prefetch-count is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///           By default the QoS settings apply to the current channel only. If this field is
+    ///           set, they are applied to the entire connection.
+    ///         
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method tells the client that the requested QoS levels could be handled by the
+  ///         server. The requested QoS applies to all active consumers until a new QoS is
+  ///         defined.
+  ///       
+  /// </remarks>
+  public interface IBasicQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume".</summary>
+  /// <remarks>
+  /// 
+  ///         This method asks the server to start a "consumer", which is a transient request for
+  ///         messages from a specific queue. Consumers last as long as the channel they were
+  ///         created on, or until the client cancels them.
+  ///       
+  /// </remarks>
+  public interface IBasicConsume: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the identifier for the consumer. The consumer tag is local to a
+    ///           connection, so two clients can use the same consumer tags. If this field is
+    ///           empty the server will generate a unique tag.
+    ///         
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///           Request exclusive consumer access, meaning only this consumer can access the
+    ///           queue.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise
+    ///           a channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of filters for the consume. The syntax and semantics
+    /// 		  of these filters depends on the providers implementation.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Filter { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         The server provides the client with a consumer tag, which is used by the client
+  ///         for methods called on the consumer at a later stage.
+  ///       
+  /// </remarks>
+  public interface IBasicConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///           Holds the consumer tag specified by the client or provided by the server.
+    ///         
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///         This method cancels a consumer. This does not affect already delivered
+  ///         messages, but it does mean the server will not send any more messages for
+  ///         that consumer. The client may receive an arbitrary number of messages in
+  ///         between sending the cancel method and receiving the cancel-ok reply.
+  ///       
+  /// </remarks>
+  public interface IBasicCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms that the cancellation was completed.
+  ///       
+  /// </remarks>
+  public interface IBasicCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.publish".</summary>
+  /// <remarks>
+  /// 
+  ///         This method publishes a message to a specific exchange. The message will be routed
+  ///         to queues as defined by the exchange configuration and distributed to any active
+  ///         consumers when the transaction, if any, is committed.
+  ///       
+  /// </remarks>
+  public interface IBasicPublish: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange to publish to. The exchange name can be
+    ///           empty, meaning the default exchange. If the exchange name is specified, and that
+    ///           exchange does not exist, the server will raise a channel exception.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the routing key for the message. The routing key is used for routing
+    ///           messages depending on the exchange configuration.
+    ///         
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue. If this flag is set, the server will return an unroutable message with a
+    ///           Return method. If this flag is zero, the server silently drops the message.
+    ///         
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue consumer immediately. If this flag is set, the server will return an
+    ///           undeliverable message with a Return method. If this flag is zero, the server
+    ///           will queue the message, but with no guarantee that it will ever be consumed.
+    ///         
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.return".</summary>
+  /// <remarks>
+  /// 
+  ///         This method returns an undeliverable message that was published with the "immediate"
+  ///         flag set, or an unroutable message published with the "mandatory" flag set. The
+  ///         reply code and text provide information about the reason that the message was
+  ///         undeliverable.
+  ///       
+  /// </remarks>
+  public interface IBasicReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the routing key name specified when the message was published.
+    ///         
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///         This method delivers a message to the client, via a consumer. In the asynchronous
+  ///         message delivery model, the client starts a consumer using the Consume method, then
+  ///         the server responds with Deliver methods as and when messages arrive for that
+  ///         consumer.
+  ///       
+  /// </remarks>
+  public interface IBasicDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key name specified when the message was published.
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get".</summary>
+  /// <remarks>
+  /// 
+  ///         This method provides a direct access to the messages in a queue using a synchronous
+  ///         dialogue that is designed for specific types of application where synchronous
+  ///         functionality is more important than performance.
+  ///       
+  /// </remarks>
+  public interface IBasicGet: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    bool NoAck { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method delivers a message to the client following a get method. A message
+  ///         delivered by 'get-ok' must be acknowledged unless the no-ack option was set in the
+  ///         get method.
+  ///       
+  /// </remarks>
+  public interface IBasicGetOk: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///           If empty, the message was published to the default exchange.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key name specified when the message was published.
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           This field reports the number of messages pending on the queue, excluding the
+    ///           message being delivered. Note that this figure is indicative, not reliable, and
+    ///           can change arbitrarily as messages are added to the queue and removed by other
+    ///           clients.
+    ///         
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-empty".</summary>
+  /// <remarks>
+  /// 
+  ///         This method tells the client that the queue has no messages available for the
+  ///         client.
+  ///       
+  /// </remarks>
+  public interface IBasicGetEmpty: IMethod {
+    /// <summary>
+    /// 
+    ///           For use by cluster applications, should not be used by client applications.
+    ///         
+    /// </summary>
+    string ClusterId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.ack".</summary>
+  /// <remarks>
+  /// 
+  ///         This method acknowledges one or more messages delivered via the Deliver or Get-Ok
+  ///         methods. The client can ask to confirm a single message or a set of messages up to
+  ///         and including a specific message.
+  ///       
+  /// </remarks>
+  public interface IBasicAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///           If set to 1, the delivery tag is treated as "up to and including", so that the
+    ///           client can acknowledge multiple messages with a single method. If set to zero,
+    ///           the delivery tag refers to a single message. If the multiple field is 1, and the
+    ///           delivery tag is zero, tells the server to acknowledge all outstanding messages.
+    ///         
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.reject".</summary>
+  /// <remarks>
+  /// 
+  ///         This method allows a client to reject a message. It can be used to interrupt and
+  ///         cancel large incoming messages, or return untreatable messages to their original
+  ///         queue.
+  ///       
+  /// </remarks>
+  public interface IBasicReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///           If this field is zero, the message will be discarded. If this bit is 1, the
+    ///           server will attempt to requeue the message.
+    ///         
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.recover".</summary>
+  /// <remarks>
+  /// 
+  ///         This method asks the broker to redeliver all unacknowledged messages on a specified
+  ///         channel. Zero or more messages may be redelivered. This method is only allowed on
+  ///         non-transacted channels.
+  ///       
+  /// </remarks>
+  public interface IBasicRecover: IMethod {
+    /// <summary>
+    /// 
+    ///           If this field is zero, the message will be redelivered to the original
+    ///           recipient. If this bit is 1, the server will attempt to requeue the message,
+    ///           potentially then delivering it to an alternative subscriber.
+    ///         
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos".</summary>
+  /// <remarks>
+  /// 
+  ///         This method requests a specific quality of service. The QoS can be specified for the
+  ///         current channel or for all channels on the connection. The particular properties and
+  ///         semantics of a qos method always depend on the content class semantics. Though the
+  ///         qos method could in principle apply to both peers, it is currently meaningful only
+  ///         for the server.
+  ///       
+  /// </remarks>
+  public interface IFileQos: IMethod {
+    /// <summary>
+    /// 
+    ///           The client can request that messages be sent in advance so that when the client
+    ///           finishes processing a message, the following message is already held locally,
+    ///           rather than needing to be sent down the channel. Prefetching gives a performance
+    ///           improvement. This field specifies the prefetch window size in octets. May be set
+    ///           to zero, meaning "no specific limit". Note that other prefetch limits may still
+    ///           apply. The prefetch-size is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///           Specifies a prefetch window in terms of whole messages. This is compatible with
+    ///           some file API implementations. This field may be used in combination with the
+    ///           prefetch-size field; a message will only be sent in advance if both prefetch
+    ///           windows (and those at the channel and connection level) allow it. The
+    ///           prefetch-count is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///           By default the QoS settings apply to the current channel only. If this field is
+    ///           set, they are applied to the entire connection.
+    ///         
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method tells the client that the requested QoS levels could be handled by the
+  ///         server. The requested QoS applies to all active consumers until a new QoS is
+  ///         defined.
+  ///       
+  /// </remarks>
+  public interface IFileQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume".</summary>
+  /// <remarks>
+  /// 
+  ///         This method asks the server to start a "consumer", which is a transient request for
+  ///         messages from a specific queue. Consumers last as long as the channel they were
+  ///         created on, or until the client cancels them.
+  ///       
+  /// </remarks>
+  public interface IFileConsume: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the identifier for the consumer. The consumer tag is local to a
+    ///           connection, so two clients can use the same consumer tags. If this field is
+    ///           empty the server will generate a unique tag.
+    ///         
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///           Request exclusive consumer access, meaning only this consumer can access the
+    ///           queue.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of filters for the consume. The syntax and semantics
+    /// 		  of these filters depends on the providers implementation.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Filter { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method provides the client with a consumer tag which it MUST use in methods
+  ///         that work with the consumer.
+  ///       
+  /// </remarks>
+  public interface IFileConsumeOk: IMethod {
+    /// <summary>
+    /// Holds the consumer tag specified by the client or provided by the server.
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///         This method cancels a consumer. This does not affect already delivered messages, but
+  ///         it does mean the server will not send any more messages for that consumer.
+  ///       
+  /// </remarks>
+  public interface IFileCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel-ok".</summary>
+  /// <remarks>
+  /// This method confirms that the cancellation was completed.
+  /// </remarks>
+  public interface IFileCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open".</summary>
+  /// <remarks>
+  /// 
+  ///         This method requests permission to start staging a message. Staging means sending
+  ///         the message into a temporary area at the recipient end and then delivering the
+  ///         message by referring to this temporary area. Staging is how the protocol handles
+  ///         partial file transfers - if a message is partially staged and the connection breaks,
+  ///         the next time the sender starts to stage it, it can restart from where it left off.
+  ///       
+  /// </remarks>
+  public interface IFileOpen: IMethod {
+    /// <summary>
+    /// 
+    ///           This is the staging identifier. This is an arbitrary string chosen by the
+    ///           sender. For staging to work correctly the sender must use the same staging
+    ///           identifier when staging the same message a second time after recovery from a
+    ///           failure. A good choice for the staging identifier would be the SHA1 hash of the
+    ///           message properties data (including the original filename, revised time, etc.).
+    ///         
+    /// </summary>
+    string Identifier { get; }
+    /// <summary>
+    /// 
+    ///           The size of the content in octets. The recipient may use this information to
+    ///           allocate or check available space in advance, to avoid "disk full" errors during
+    ///           staging of very large messages.
+    ///         
+    /// </summary>
+    ulong ContentSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms that the recipient is ready to accept staged data. If the
+  ///         message was already partially-staged at a previous time the recipient will report
+  ///         the number of octets already staged.
+  ///       
+  /// </remarks>
+  public interface IFileOpenOk: IMethod {
+    /// <summary>
+    /// 
+    ///           The amount of previously-staged content in octets. For a new message this will
+    ///           be zero.
+    ///         
+    /// </summary>
+    ulong StagedSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.stage".</summary>
+  /// <remarks>
+  /// 
+  ///         This method stages the message, sending the message content to the recipient from
+  ///         the octet offset specified in the Open-Ok method.
+  ///       
+  /// </remarks>
+  public interface IFileStage: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.publish".</summary>
+  /// <remarks>
+  /// 
+  ///         This method publishes a staged file message to a specific exchange. The file message
+  ///         will be routed to queues as defined by the exchange configuration and distributed to
+  ///         any active consumers when the transaction, if any, is committed.
+  ///       
+  /// </remarks>
+  public interface IFilePublish: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange to publish to. The exchange name can be
+    ///           empty, meaning the default exchange. If the exchange name is specified, and that
+    ///           exchange does not exist, the server will raise a channel exception.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the routing key for the message. The routing key is used for routing
+    ///           messages depending on the exchange configuration.
+    ///         
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue. If this flag is set, the server will return an unroutable message with a
+    ///           Return method. If this flag is zero, the server silently drops the message.
+    ///         
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue consumer immediately. If this flag is set, the server will return an
+    ///           undeliverable message with a Return method. If this flag is zero, the server
+    ///           will queue the message, but with no guarantee that it will ever be consumed.
+    ///         
+    /// </summary>
+    bool Immediate { get; }
+    /// <summary>
+    /// 
+    ///           This is the staging identifier of the message to publish. The message must have
+    ///           been staged. Note that a client can send the Publish method asynchronously
+    ///           without waiting for staging to finish.
+    ///         
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.return".</summary>
+  /// <remarks>
+  /// 
+  ///         This method returns an undeliverable message that was published with the "immediate"
+  ///         flag set, or an unroutable message published with the "mandatory" flag set. The
+  ///         reply code and text provide information about the reason that the message was
+  ///         undeliverable.
+  ///       
+  /// </remarks>
+  public interface IFileReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key name specified when the message was published.
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///         This method delivers a staged file message to the client, via a consumer. In the
+  ///         asynchronous message delivery model, the client starts a consumer using the Consume
+  ///         method, then the server responds with Deliver methods as and when messages arrive
+  ///         for that consumer.
+  ///       
+  /// </remarks>
+  public interface IFileDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key name specified when the message was published.
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           This is the staging identifier of the message to deliver. The message must have
+    ///           been staged. Note that a server can send the Deliver method asynchronously
+    ///           without waiting for staging to finish.
+    ///         
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.ack".</summary>
+  /// <remarks>
+  /// 
+  ///         This method acknowledges one or more messages delivered via the Deliver method. The
+  ///         client can ask to confirm a single message or a set of messages up to and including
+  ///         a specific message.
+  ///       
+  /// </remarks>
+  public interface IFileAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///           If set to 1, the delivery tag is treated as "up to and including", so that the
+    ///           client can acknowledge multiple messages with a single method. If set to zero,
+    ///           the delivery tag refers to a single message. If the multiple field is 1, and the
+    ///           delivery tag is zero, tells the server to acknowledge all outstanding messages.
+    ///         
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.reject".</summary>
+  /// <remarks>
+  /// 
+  ///         This method allows a client to reject a message. It can be used to return
+  ///         untreatable messages to their original queue. Note that file content is staged
+  ///         before delivery, so the client will not use this method to interrupt delivery of a
+  ///         large message.
+  ///       
+  /// </remarks>
+  public interface IFileReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///           If this field is zero, the message will be discarded. If this bit is 1, the
+    ///           server will attempt to requeue the message.
+    ///         
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos".</summary>
+  /// <remarks>
+  /// 
+  ///         This method requests a specific quality of service. The QoS can be specified for the
+  ///         current channel or for all channels on the connection. The particular properties and
+  ///         semantics of a qos method always depend on the content class semantics. Though the
+  ///         qos method could in principle apply to both peers, it is currently meaningful only
+  ///         for the server.
+  ///       
+  /// </remarks>
+  public interface IStreamQos: IMethod {
+    /// <summary>
+    /// 
+    ///           The client can request that messages be sent in advance so that when the client
+    ///           finishes processing a message, the following message is already held locally,
+    ///           rather than needing to be sent down the channel. Prefetching gives a performance
+    ///           improvement. This field specifies the prefetch window size in octets. May be set
+    ///           to zero, meaning "no specific limit". Note that other prefetch limits may still
+    ///           apply.
+    ///         
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///           Specifies a prefetch window in terms of whole messages. This field may be used
+    ///           in combination with the prefetch-size field; a message will only be sent in
+    ///           advance if both prefetch windows (and those at the channel and connection level)
+    ///           allow it.
+    ///         
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///           Specifies a desired transfer rate in octets per second. This is usually
+    ///           determined by the application that uses the streaming data. A value of zero
+    ///           means "no limit", i.e. as rapidly as possible.
+    ///         
+    /// </summary>
+    uint ConsumeRate { get; }
+    /// <summary>
+    /// 
+    ///           By default the QoS settings apply to the current channel only. If this field is
+    ///           set, they are applied to the entire connection.
+    ///         
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method tells the client that the requested QoS levels could be handled by the
+  ///         server. The requested QoS applies to all active consumers until a new QoS is
+  ///         defined.
+  ///       
+  /// </remarks>
+  public interface IStreamQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume".</summary>
+  /// <remarks>
+  /// 
+  ///         This method asks the server to start a "consumer", which is a transient request for
+  ///         messages from a specific queue. Consumers last as long as the channel they were
+  ///         created on, or until the client cancels them.
+  ///       
+  /// </remarks>
+  public interface IStreamConsume: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the identifier for the consumer. The consumer tag is local to a
+    ///           connection, so two clients can use the same consumer tags. If this field is
+    ///           empty the server will generate a unique tag.
+    ///         
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    /// <summary>
+    /// 
+    ///           Request exclusive consumer access, meaning only this consumer can access the
+    ///           queue.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///           A set of filters for the consume. The syntax and semantics
+    /// 		  of these filters depends on the providers implementation.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Filter { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method provides the client with a consumer tag which it may use in methods that
+  ///         work with the consumer.
+  ///       
+  /// </remarks>
+  public interface IStreamConsumeOk: IMethod {
+    /// <summary>
+    /// Holds the consumer tag specified by the client or provided by the server.
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///         This method cancels a consumer. Since message delivery is asynchronous the client
+  ///         may continue to receive messages for a short while after cancelling a consumer. It
+  ///         may process or discard these as appropriate.
+  ///       
+  /// </remarks>
+  public interface IStreamCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///           If set, the server will not respond to the method. The client should not wait
+    ///           for a reply method. If the server could not complete the method it will raise a
+    ///           channel or connection exception.
+    ///         
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel-ok".</summary>
+  /// <remarks>
+  /// This method confirms that the cancellation was completed.
+  /// </remarks>
+  public interface IStreamCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.publish".</summary>
+  /// <remarks>
+  /// 
+  ///         This method publishes a message to a specific exchange. The message will be routed
+  ///         to queues as defined by the exchange configuration and distributed to any active
+  ///         consumers as appropriate.
+  ///       
+  /// </remarks>
+  public interface IStreamPublish: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange to publish to. The exchange name can be
+    ///           empty, meaning the default exchange. If the exchange name is specified, and that
+    ///           exchange does not exist, the server will raise a channel exception.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the routing key for the message. The routing key is used for routing
+    ///           messages depending on the exchange configuration.
+    ///         
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue. If this flag is set, the server will return an unroutable message with a
+    ///           Return method. If this flag is zero, the server silently drops the message.
+    ///         
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message cannot be routed to a
+    ///           queue consumer immediately. If this flag is set, the server will return an
+    ///           undeliverable message with a Return method. If this flag is zero, the server
+    ///           will queue the message, but with no guarantee that it will ever be consumed.
+    ///         
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.return".</summary>
+  /// <remarks>
+  /// 
+  ///         This method returns an undeliverable message that was published with the "immediate"
+  ///         flag set, or an unroutable message published with the "mandatory" flag set. The
+  ///         reply code and text provide information about the reason that the message was
+  ///         undeliverable.
+  ///       
+  /// </remarks>
+  public interface IStreamReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// Specifies the routing key name specified when the message was published.
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///         This method delivers a message to the client, via a consumer. In the asynchronous
+  ///         message delivery model, the client starts a consumer using the Consume method, then
+  ///         the server responds with Deliver methods as and when messages arrive for that
+  ///         consumer.
+  ///       
+  /// </remarks>
+  public interface IStreamDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the exchange that the message was originally published to.
+    ///         
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue that the message came from. Note that a single
+    ///           channel can start many consumers on different queues.
+    ///         
+    /// </summary>
+    string Queue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select".</summary>
+  /// <remarks>
+  /// 
+  ///         This method sets the channel to use standard transactions. The client must use this
+  ///         method at least once on a channel before using the Commit or Rollback methods.
+  ///       
+  /// </remarks>
+  public interface ITxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms to the client that the channel was successfully set to use
+  ///         standard transactions.
+  ///       
+  /// </remarks>
+  public interface ITxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit".</summary>
+  /// <remarks>
+  /// 
+  ///         This method commits all messages published and acknowledged in the current
+  ///         transaction. A new transaction starts immediately after a commit.
+  ///       
+  /// </remarks>
+  public interface ITxCommit: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms to the client that the commit succeeded. Note that if a commit
+  ///         fails, the server raises a channel exception.
+  ///       
+  /// </remarks>
+  public interface ITxCommitOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback".</summary>
+  /// <remarks>
+  /// 
+  ///         This method abandons all messages published and acknowledged in the current
+  ///         transaction. A new transaction starts immediately after a rollback.
+  ///       
+  /// </remarks>
+  public interface ITxRollback: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms to the client that the rollback succeeded. Note that if an
+  ///         rollback fails, the server raises a channel exception.
+  ///       
+  /// </remarks>
+  public interface ITxRollbackOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select".</summary>
+  /// <remarks>
+  /// 
+  ///         This method sets the channel to use distributed transactions. The client must use
+  ///         this method at least once on a channel before using the Start method.
+  ///       
+  /// </remarks>
+  public interface IDtxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms to the client that the channel was successfully set to use
+  ///         distributed transactions.
+  ///       
+  /// </remarks>
+  public interface IDtxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start".</summary>
+  /// <remarks>
+  /// 
+  ///         This method starts a new distributed transaction. This must be the first method on a
+  ///         new channel that uses the distributed transaction mode, before any methods that
+  ///         publish or consume messages.
+  ///       
+  /// </remarks>
+  public interface IDtxStart: IMethod {
+    /// <summary>
+    /// 
+    ///           The distributed transaction key. This identifies the transaction so that the
+    ///           AMQP server can coordinate with the distributed transaction coordinator.
+    ///         
+    /// </summary>
+    string DtxIdentifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///         This method confirms to the client that the transaction started. Note that if a
+  ///         start fails, the server raises a channel exception.
+  ///       
+  /// </remarks>
+  public interface IDtxStartOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tunnel.request".</summary>
+  /// <remarks>
+  /// 
+  ///         This method tunnels a block of binary data, which can be an encoded
+  ///         AMQP method or other data. The binary data is sent as the content for
+  ///         the Tunnel.Request method.
+  ///       
+  /// </remarks>
+  public interface ITunnelRequest: IMethod {
+    /// <summary>
+    /// 
+    ///           This field table holds arbitrary meta-data that the sender needs to
+    ///           pass to the recipient.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary MetaData { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.transfer".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method transfers a message between two peers. When a
+  ///         client uses this method to publish a message to a broker, the
+  ///         destination identifies a specific exchange. The message will
+  ///         then be routed to queues as defined by the exchange
+  ///         configuration and distributed to any active consumers when the
+  ///         transaction, if any, is committed.
+  /// 
+  ///         In the asynchronous message delivery model, the client starts
+  ///         a consumer using the Consume method and passing in a
+  ///         destination, then the broker responds with transfer methods to
+  ///         the specified destination as and when messages arrive for that
+  ///         consumer.
+  /// 
+  ///         If synchronous message delivery is required, the client may
+  ///         issue a get request which on success causes a single message
+  ///         to be transferred to the specified destination.
+  /// 
+  ///         Message acknowledgement is signalled by the return result of
+  ///         this method.
+  ///       
+  /// </remarks>
+  public interface IMessageTransfer: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the destination to which the message is to be
+    ///           transferred. The destination can be empty, meaning the
+    ///           default exchange or consumer. If the destination is
+    ///           specified, and that exchange or consumer does not exist, the
+    ///           peer must raise a channel exception.
+    ///         
+    /// </summary>
+    string Destination { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///           This flag tells the server how to react if the message
+    ///           cannot be routed to a queue consumer immediately. If this
+    ///           flag is set, the server will reject the message. If this
+    ///           flag is zero, the server will queue the message, but with no
+    ///           guarantee that it will ever be consumed.
+    ///         
+    /// </summary>
+    bool Immediate { get; }
+    /// <summary>
+    /// 
+    ///           If this is set to a non zero value then a message expiration
+    ///           time will be computed based on the current time plus this
+    ///           value. Messages that live longer than their expiration time
+    ///           will be discarded (or dead lettered).
+    ///         
+    /// </summary>
+    ulong Ttl { get; }
+    // (no documentation)
+    byte Priority { get; }
+    /// <summary>
+    /// 
+    ///           Set on arrival by the broker.
+    ///         
+    /// </summary>
+    AmqpTimestamp Timestamp { get; }
+    // (no documentation)
+    byte DeliveryMode { get; }
+    /// <summary>
+    /// 
+    ///           The expiration header assigned by the broker. After
+    ///           receiving the message the broker sets expiration to the sum
+    ///           of the ttl specified in the publish method and the current
+    ///           time. (ttl = expiration - timestamp)
+    ///         
+    /// </summary>
+    AmqpTimestamp Expiration { get; }
+    // (no documentation)
+    string Exchange { get; }
+    // (no documentation)
+    string RoutingKey { get; }
+    // (no documentation)
+    string MessageId { get; }
+    // (no documentation)
+    string CorrelationId { get; }
+    // (no documentation)
+    string ReplyTo { get; }
+    // (no documentation)
+    string ContentType { get; }
+    // (no documentation)
+    string ContentEncoding { get; }
+    // (no documentation)
+    string UserId { get; }
+    // (no documentation)
+    string AppId { get; }
+    // (no documentation)
+    string TransactionId { get; }
+    // (no documentation)
+    byte[] SecurityToken { get; }
+    // (no documentation)
+    System.Collections.IDictionary ApplicationHeaders { get; }
+    // (no documentation)
+    byte[] Body { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.consume".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method asks the server to start a "consumer", which is a transient request for
+  ///         messages from a specific queue. Consumers last as long as the channel they were
+  ///         created on, or until the client cancels them.
+  ///       
+  /// </remarks>
+  public interface IMessageConsume: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the destination for the consumer. The destination is local to a
+    ///           connection, so two clients can use the same destination.
+    ///         
+    /// </summary>
+    string Destination { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///           Request exclusive consumer access, meaning only this consumer can access the
+    ///           queue.
+    ///         
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///           A set of filters for the consume. The syntax and semantics
+    /// 		  of these filters depends on the providers implementation.
+    ///         
+    /// </summary>
+    System.Collections.IDictionary Filter { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method cancels a consumer. This does not affect already delivered
+  ///         messages, but it does mean the server will not send any more messages for
+  ///         that consumer. The client may receive an arbitrary number of messages in
+  ///         between sending the cancel method and receiving the cancel-ok reply.
+  ///       
+  /// </remarks>
+  public interface IMessageCancel: IMethod {
+    // (no documentation)
+    string Destination { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.get".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method provides a direct access to the messages in a queue using a synchronous
+  ///         dialogue that is designed for specific types of application where synchronous
+  ///         functionality is more important than performance.
+  ///       
+  /// </remarks>
+  public interface IMessageGet: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///           Specifies the name of the queue to consume from. If the queue name is null,
+    ///           refers to the current queue for the channel, which is the last declared queue.
+    ///         
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///           On normal completion of the get request (i.e. a response of
+    ///           ok). A message will be transferred to the supplied destination.
+    ///         
+    /// </summary>
+    string Destination { get; }
+    // (no documentation)
+    bool NoAck { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.recover".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method asks the broker to redeliver all unacknowledged
+  ///         messages on a specified channel. Zero or more messages may be
+  ///         redelivered. This method is only allowed on non-transacted
+  ///         channels.
+  ///       
+  /// </remarks>
+  public interface IMessageRecover: IMethod {
+    /// <summary>
+    /// 
+    ///           If this field is zero, the message will be redelivered to
+    ///           the original recipient. If this bit is 1, the server will
+    ///           attempt to requeue the message, potentially then delivering
+    ///           it to an alternative subscriber.
+    ///         
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.open".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method creates a reference. A references provides a means
+  ///         to send a message body into a temporary area at the recipient
+  ///         end and then deliver the message by referring to this
+  ///         temporary area. This is how the protocol handles large message
+  ///         transfers.
+  /// 
+  ///         The scope of a ref is defined to be between calls to
+  ///         open (or resume) and close. Between these points it is valid
+  ///         for a ref to be used from any content data type, and so the
+  ///         receiver must hold onto its contents. Should the channel be
+  ///         closed when a ref is still in scope, the receiver may discard
+  ///         its contents (unless it is checkpointed). A ref that is in
+  ///         scope is considered open.
+  ///       
+  /// </remarks>
+  public interface IMessageOpen: IMethod {
+    // (no documentation)
+    byte[] Reference { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.close".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method signals the recipient that no more data will be
+  ///         appended to the reference.
+  ///       
+  /// </remarks>
+  public interface IMessageClose: IMethod {
+    // (no documentation)
+    byte[] Reference { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.append".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method appends data to a reference.
+  ///       
+  /// </remarks>
+  public interface IMessageAppend: IMethod {
+    // (no documentation)
+    byte[] Reference { get; }
+    // (no documentation)
+    byte[] Bytes { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.checkpoint".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method provides a means to checkpoint large message
+  ///         transfer. The sender may ask the recipient to checkpoint the
+  ///         contents of a reference using the supplied identifier. The
+  ///         sender may then resume the transfer at a later point. It is at
+  ///         the discretion of the recipient how much data to save with the
+  ///         checkpoint, and the sender MUST honour the offset returned by
+  ///         the resume method.
+  ///       
+  /// </remarks>
+  public interface IMessageCheckpoint: IMethod {
+    // (no documentation)
+    byte[] Reference { get; }
+    /// <summary>
+    /// 
+    ///           This is the checkpoint identifier. This is an arbitrary
+    ///           string chosen by the sender. For checkpointing to work
+    ///           correctly the sender must use the same checkpoint identifier
+    ///           when resuming the message. A good choice for the checkpoint
+    ///           identifier would be the SHA1 hash of the message properties
+    ///           data (including the original filename, revised time, etc.).
+    ///         
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.resume".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method resumes a reference from the last checkpoint. A
+  ///         reference is considered to be open (in scope) after a resume
+  ///         even though it will not have been opened via the open method
+  ///         during this session.
+  ///       
+  /// </remarks>
+  public interface IMessageResume: IMethod {
+    // (no documentation)
+    byte[] Reference { get; }
+    // (no documentation)
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.qos".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This method requests a specific quality of service. The QoS can be specified for the
+  ///         current channel or for all channels on the connection. The particular properties and
+  ///         semantics of a qos method always depend on the content class semantics. Though the
+  ///         qos method could in principle apply to both peers, it is currently meaningful only
+  ///         for the server.
+  ///       
+  /// </remarks>
+  public interface IMessageQos: IMethod {
+    /// <summary>
+    /// 
+    ///           The client can request that messages be sent in advance so that when the client
+    ///           finishes processing a message, the following message is already held locally,
+    ///           rather than needing to be sent down the channel. Prefetching gives a performance
+    ///           improvement. This field specifies the prefetch window size in octets. The server
+    ///           will send a message in advance if it is equal to or smaller in size than the
+    ///           available prefetch size (and also falls into other prefetch limits). May be set
+    ///           to zero, meaning "no specific limit", although other prefetch limits may still
+    ///           apply. The prefetch-size is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///           Specifies a prefetch window in terms of whole messages. This field may be used
+    ///           in combination with the prefetch-size field; a message will only be sent in
+    ///           advance if both prefetch windows (and those at the channel and connection level)
+    ///           allow it. The prefetch-count is ignored if the no-ack option is set.
+    ///         
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///           By default the QoS settings apply to the current channel only. If this field is
+    ///           set, they are applied to the entire connection.
+    ///         
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.ok".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Signals the normal completion of a method.
+  ///       
+  /// </remarks>
+  public interface IMessageOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.empty".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Signals that a queue does not contain any messages.
+  ///       
+  /// </remarks>
+  public interface IMessageEmpty: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.reject".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] This response rejects a message. A message may be rejected for
+  ///         a number of reasons.
+  ///       
+  /// </remarks>
+  public interface IMessageReject: IMethod {
+    // (no documentation)
+    ushort Code { get; }
+    // (no documentation)
+    string Text { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "message.offset".</summary>
+  /// <remarks>
+  /// 
+  ///         [WORK IN PROGRESS] Returns the data offset into a reference body.
+  ///       
+  /// </remarks>
+  public interface IMessageOffset: IMethod {
+    // (no documentation)
+    ulong Value { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "basic"</summary>
+  /// <remarks>
+  /// 
+  ///       The Basic class provides methods that support an industry-standard messaging model.
+  ///     
+  /// </remarks>
+  public class BasicProperties: RabbitMQ.Client.Impl.BasicProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_deliveryMode;
+    private byte m_priority;
+    private string m_correlationId;
+    private string m_replyTo;
+    private string m_expiration;
+    private string m_messageId;
+    private AmqpTimestamp m_timestamp;
+    private string m_type;
+    private string m_userId;
+    private string m_appId;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool deliveryMode_present = false;
+    private bool priority_present = false;
+    private bool correlationId_present = false;
+    private bool replyTo_present = false;
+    private bool expiration_present = false;
+    private bool messageId_present = false;
+    private bool timestamp_present = false;
+    private bool type_present = false;
+    private bool userId_present = false;
+    private bool appId_present = false;
+    private bool clusterId_present = false;
+
+    /// <summary>
+    /// MIME content type
+    /// </summary>
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    /// <summary>
+    /// MIME content encoding
+    /// </summary>
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    /// <summary>
+    /// message header field table
+    /// </summary>
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    /// <summary>
+    /// non-persistent (1) or persistent (2)
+    /// </summary>
+    public override byte DeliveryMode {
+      get {
+        return m_deliveryMode;
+      }
+      set {
+        deliveryMode_present = true;
+        m_deliveryMode = value;
+      }
+    }
+    /// <summary>
+    /// message priority, 0 to 9
+    /// </summary>
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    /// <summary>
+    /// application correlation identifier
+    /// </summary>
+    public override string CorrelationId {
+      get {
+        return m_correlationId;
+      }
+      set {
+        correlationId_present = true;
+        m_correlationId = value;
+      }
+    }
+    /// <summary>
+    /// destination to reply to
+    /// </summary>
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    /// <summary>
+    /// message expiration specification
+    /// </summary>
+    public override string Expiration {
+      get {
+        return m_expiration;
+      }
+      set {
+        expiration_present = true;
+        m_expiration = value;
+      }
+    }
+    /// <summary>
+    /// application message identifier
+    /// </summary>
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    /// <summary>
+    /// message timestamp
+    /// </summary>
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    /// <summary>
+    /// message type name
+    /// </summary>
+    public override string Type {
+      get {
+        return m_type;
+      }
+      set {
+        type_present = true;
+        m_type = value;
+      }
+    }
+    /// <summary>
+    /// creating user id
+    /// </summary>
+    public override string UserId {
+      get {
+        return m_userId;
+      }
+      set {
+        userId_present = true;
+        m_userId = value;
+      }
+    }
+    /// <summary>
+    /// creating application id
+    /// </summary>
+    public override string AppId {
+      get {
+        return m_appId;
+      }
+      set {
+        appId_present = true;
+        m_appId = value;
+      }
+    }
+    /// <summary>
+    /// intra-cluster routing identifier
+    /// </summary>
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearDeliveryMode() { deliveryMode_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearCorrelationId() { correlationId_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearExpiration() { expiration_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearType() { type_present = false; }
+    public override void ClearUserId() { userId_present = false; }
+    public override void ClearAppId() { appId_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public BasicProperties() {}
+    public override int ProtocolClassId { get { return 60; } }
+    public override string ProtocolClassName { get { return "basic"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      deliveryMode_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      correlationId_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      expiration_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      type_present = reader.ReadPresence();
+      userId_present = reader.ReadPresence();
+      appId_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (deliveryMode_present) { m_deliveryMode = reader.ReadOctet(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (correlationId_present) { m_correlationId = reader.ReadShortstr(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (expiration_present) { m_expiration = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (type_present) { m_type = reader.ReadShortstr(); }
+      if (userId_present) { m_userId = reader.ReadShortstr(); }
+      if (appId_present) { m_appId = reader.ReadShortstr(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(deliveryMode_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(correlationId_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(expiration_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(type_present);
+      writer.WritePresence(userId_present);
+      writer.WritePresence(appId_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (deliveryMode_present) { writer.WriteOctet(m_deliveryMode); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (correlationId_present) { writer.WriteShortstr(m_correlationId); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (expiration_present) { writer.WriteShortstr(m_expiration); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (type_present) { writer.WriteShortstr(m_type); }
+      if (userId_present) { writer.WriteShortstr(m_userId); }
+      if (appId_present) { writer.WriteShortstr(m_appId); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content-type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content-encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("delivery-mode="); sb.Append(deliveryMode_present ? m_deliveryMode.ToString() : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("correlation-id="); sb.Append(correlationId_present ? (m_correlationId == null ? "(null)" : m_correlationId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("reply-to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("expiration="); sb.Append(expiration_present ? (m_expiration == null ? "(null)" : m_expiration.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message-id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("type="); sb.Append(type_present ? (m_type == null ? "(null)" : m_type.ToString()) : "_"); sb.Append(", ");
+      sb.Append("user-id="); sb.Append(userId_present ? (m_userId == null ? "(null)" : m_userId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("app-id="); sb.Append(appId_present ? (m_appId == null ? "(null)" : m_appId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("cluster-id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "file"</summary>
+  /// <remarks>
+  /// 
+  ///       The file class provides methods that support reliable file transfer. File
+  ///       messages have a specific set of properties that are required for interoperability
+  ///       with file transfer applications. File messages and acknowledgements are subject to
+  ///       channel transactions. Note that the file class does not provide message browsing
+  ///       methods; these are not compatible with the staging model. Applications that need
+  ///       browsable file transfer should use Basic content and the Basic class.
+  ///     
+  /// </remarks>
+  public class FileProperties: RabbitMQ.Client.Impl.FileProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private string m_replyTo;
+    private string m_messageId;
+    private string m_filename;
+    private AmqpTimestamp m_timestamp;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool replyTo_present = false;
+    private bool messageId_present = false;
+    private bool filename_present = false;
+    private bool timestamp_present = false;
+    private bool clusterId_present = false;
+
+    /// <summary>
+    /// MIME content type
+    /// </summary>
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    /// <summary>
+    /// MIME content encoding
+    /// </summary>
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    /// <summary>
+    /// message header field table
+    /// </summary>
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    /// <summary>
+    /// message priority, 0 to 9
+    /// </summary>
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    /// <summary>
+    /// destination to reply to
+    /// </summary>
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    /// <summary>
+    /// application message identifier
+    /// </summary>
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    /// <summary>
+    /// message filename
+    /// </summary>
+    public override string Filename {
+      get {
+        return m_filename;
+      }
+      set {
+        filename_present = true;
+        m_filename = value;
+      }
+    }
+    /// <summary>
+    /// message timestamp
+    /// </summary>
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    /// <summary>
+    /// intra-cluster routing identifier
+    /// </summary>
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearFilename() { filename_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public FileProperties() {}
+    public override int ProtocolClassId { get { return 70; } }
+    public override string ProtocolClassName { get { return "file"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      filename_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (filename_present) { m_filename = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(filename_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (filename_present) { writer.WriteShortstr(m_filename); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content-type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content-encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("reply-to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message-id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("filename="); sb.Append(filename_present ? (m_filename == null ? "(null)" : m_filename.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("cluster-id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "stream"</summary>
+  /// <remarks>
+  /// 
+  ///       The stream class provides methods that support multimedia streaming. The stream class
+  ///       uses the following semantics: one message is one packet of data; delivery is
+  ///       unacknowledged and unreliable; the consumer can specify quality of service parameters
+  ///       that the server can try to adhere to; lower-priority messages may be discarded in favour
+  ///       of high priority messages.
+  ///     
+  /// </remarks>
+  public class StreamProperties: RabbitMQ.Client.Impl.StreamProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private AmqpTimestamp m_timestamp;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool timestamp_present = false;
+
+    /// <summary>
+    /// MIME content type
+    /// </summary>
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    /// <summary>
+    /// MIME content encoding
+    /// </summary>
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    /// <summary>
+    /// message header field table
+    /// </summary>
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    /// <summary>
+    /// message priority, 0 to 9
+    /// </summary>
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    /// <summary>
+    /// message timestamp
+    /// </summary>
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+
+    public StreamProperties() {}
+    public override int ProtocolClassId { get { return 80; } }
+    public override string ProtocolClassName { get { return "stream"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(timestamp_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content-type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content-encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "tunnel"</summary>
+  /// <remarks>
+  /// 
+  ///       The tunnel methods are used to send blocks of binary data - which can be serialised AMQP
+  ///       methods or other protocol frames - between AMQP peers.
+  ///     
+  /// </remarks>
+  public class TunnelProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
+    private System.Collections.IDictionary m_headers;
+    private string m_proxyName;
+    private string m_dataName;
+    private byte m_durable;
+    private byte m_broadcast;
+
+    private bool headers_present = false;
+    private bool proxyName_present = false;
+    private bool dataName_present = false;
+    private bool durable_present = false;
+    private bool broadcast_present = false;
+
+    /// <summary>
+    /// message header field table
+    /// </summary>
+    public System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    /// <summary>
+    /// identity of tunnelling proxy
+    /// </summary>
+    public string ProxyName {
+      get {
+        return m_proxyName;
+      }
+      set {
+        proxyName_present = true;
+        m_proxyName = value;
+      }
+    }
+    /// <summary>
+    /// name or type of message being tunnelled
+    /// </summary>
+    public string DataName {
+      get {
+        return m_dataName;
+      }
+      set {
+        dataName_present = true;
+        m_dataName = value;
+      }
+    }
+    /// <summary>
+    /// message durability indicator
+    /// </summary>
+    public byte Durable {
+      get {
+        return m_durable;
+      }
+      set {
+        durable_present = true;
+        m_durable = value;
+      }
+    }
+    /// <summary>
+    /// message broadcast mode
+    /// </summary>
+    public byte Broadcast {
+      get {
+        return m_broadcast;
+      }
+      set {
+        broadcast_present = true;
+        m_broadcast = value;
+      }
+    }
+
+    public void ClearHeaders() { headers_present = false; }
+    public void ClearProxyName() { proxyName_present = false; }
+    public void ClearDataName() { dataName_present = false; }
+    public void ClearDurable() { durable_present = false; }
+    public void ClearBroadcast() { broadcast_present = false; }
+
+    public TunnelProperties() {}
+    public override int ProtocolClassId { get { return 110; } }
+    public override string ProtocolClassName { get { return "tunnel"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      headers_present = reader.ReadPresence();
+      proxyName_present = reader.ReadPresence();
+      dataName_present = reader.ReadPresence();
+      durable_present = reader.ReadPresence();
+      broadcast_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (proxyName_present) { m_proxyName = reader.ReadShortstr(); }
+      if (dataName_present) { m_dataName = reader.ReadShortstr(); }
+      if (durable_present) { m_durable = reader.ReadOctet(); }
+      if (broadcast_present) { m_broadcast = reader.ReadOctet(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(headers_present);
+      writer.WritePresence(proxyName_present);
+      writer.WritePresence(dataName_present);
+      writer.WritePresence(durable_present);
+      writer.WritePresence(broadcast_present);
+      writer.FinishPresence();
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (proxyName_present) { writer.WriteShortstr(m_proxyName); }
+      if (dataName_present) { writer.WriteShortstr(m_dataName); }
+      if (durable_present) { writer.WriteOctet(m_durable); }
+      if (broadcast_present) { writer.WriteOctet(m_broadcast); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("proxy-name="); sb.Append(proxyName_present ? (m_proxyName == null ? "(null)" : m_proxyName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("data-name="); sb.Append(dataName_present ? (m_dataName == null ? "(null)" : m_dataName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("durable="); sb.Append(durable_present ? m_durable.ToString() : "_"); sb.Append(", ");
+      sb.Append("broadcast="); sb.Append(broadcast_present ? m_broadcast.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+}
+namespace RabbitMQ.Client.Framing.Impl.v0_9 {
+  using RabbitMQ.Client.Framing.v0_9;
+  public enum ClassId {
+    Connection = 10,
+    Channel = 20,
+    Access = 30,
+    Exchange = 40,
+    Queue = 50,
+    Basic = 60,
+    File = 70,
+    Stream = 80,
+    Tx = 90,
+    Dtx = 100,
+    Tunnel = 110,
+    Message = 120,
+    Invalid = -1
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStart: RabbitMQ.Client.Impl.MethodBase, IConnectionStart {
+    public const int ClassId = 10;
+    public const int MethodId = 10;
+
+    public byte m_versionMajor;
+    public byte m_versionMinor;
+    public System.Collections.IDictionary m_serverProperties;
+    public byte[] m_mechanisms;
+    public byte[] m_locales;
+
+    byte IConnectionStart.VersionMajor { get { return m_versionMajor; } }
+    byte IConnectionStart.VersionMinor { get { return m_versionMinor; } }
+    System.Collections.IDictionary IConnectionStart.ServerProperties { get { return m_serverProperties; } }
+    byte[] IConnectionStart.Mechanisms { get { return m_mechanisms; } }
+    byte[] IConnectionStart.Locales { get { return m_locales; } }
+
+    public ConnectionStart() {}
+    public ConnectionStart(
+      byte initVersionMajor,
+      byte initVersionMinor,
+      System.Collections.IDictionary initServerProperties,
+      byte[] initMechanisms,
+      byte[] initLocales)
+    {
+      m_versionMajor = initVersionMajor;
+      m_versionMinor = initVersionMinor;
+      m_serverProperties = initServerProperties;
+      m_mechanisms = initMechanisms;
+      m_locales = initLocales;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "connection.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_versionMajor = reader.ReadOctet();
+      m_versionMinor = reader.ReadOctet();
+      m_serverProperties = reader.ReadTable();
+      m_mechanisms = reader.ReadLongstr();
+      m_locales = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteOctet(m_versionMajor);
+      writer.WriteOctet(m_versionMinor);
+      writer.WriteTable(m_serverProperties);
+      writer.WriteLongstr(m_mechanisms);
+      writer.WriteLongstr(m_locales);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_versionMajor); sb.Append(",");
+      sb.Append(m_versionMinor); sb.Append(",");
+      sb.Append(m_serverProperties); sb.Append(",");
+      sb.Append(m_mechanisms); sb.Append(",");
+      sb.Append(m_locales);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStartOk: RabbitMQ.Client.Impl.MethodBase, IConnectionStartOk {
+    public const int ClassId = 10;
+    public const int MethodId = 11;
+
+    public System.Collections.IDictionary m_clientProperties;
+    public string m_mechanism;
+    public byte[] m_response;
+    public string m_locale;
+
+    System.Collections.IDictionary IConnectionStartOk.ClientProperties { get { return m_clientProperties; } }
+    string IConnectionStartOk.Mechanism { get { return m_mechanism; } }
+    byte[] IConnectionStartOk.Response { get { return m_response; } }
+    string IConnectionStartOk.Locale { get { return m_locale; } }
+
+    public ConnectionStartOk() {}
+    public ConnectionStartOk(
+      System.Collections.IDictionary initClientProperties,
+      string initMechanism,
+      byte[] initResponse,
+      string initLocale)
+    {
+      m_clientProperties = initClientProperties;
+      m_mechanism = initMechanism;
+      m_response = initResponse;
+      m_locale = initLocale;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "connection.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clientProperties = reader.ReadTable();
+      m_mechanism = reader.ReadShortstr();
+      m_response = reader.ReadLongstr();
+      m_locale = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_clientProperties);
+      writer.WriteShortstr(m_mechanism);
+      writer.WriteLongstr(m_response);
+      writer.WriteShortstr(m_locale);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clientProperties); sb.Append(",");
+      sb.Append(m_mechanism); sb.Append(",");
+      sb.Append(m_response); sb.Append(",");
+      sb.Append(m_locale);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecure: RabbitMQ.Client.Impl.MethodBase, IConnectionSecure {
+    public const int ClassId = 10;
+    public const int MethodId = 20;
+
+    public byte[] m_challenge;
+
+    byte[] IConnectionSecure.Challenge { get { return m_challenge; } }
+
+    public ConnectionSecure() {}
+    public ConnectionSecure(
+      byte[] initChallenge)
+    {
+      m_challenge = initChallenge;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "connection.secure"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_challenge = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_challenge);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_challenge);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecureOk: RabbitMQ.Client.Impl.MethodBase, IConnectionSecureOk {
+    public const int ClassId = 10;
+    public const int MethodId = 21;
+
+    public byte[] m_response;
+
+    byte[] IConnectionSecureOk.Response { get { return m_response; } }
+
+    public ConnectionSecureOk() {}
+    public ConnectionSecureOk(
+      byte[] initResponse)
+    {
+      m_response = initResponse;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "connection.secure-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_response = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_response);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_response);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTune: RabbitMQ.Client.Impl.MethodBase, IConnectionTune {
+    public const int ClassId = 10;
+    public const int MethodId = 30;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTune.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTune.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTune.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTune() {}
+    public ConnectionTune(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "connection.tune"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTuneOk: RabbitMQ.Client.Impl.MethodBase, IConnectionTuneOk {
+    public const int ClassId = 10;
+    public const int MethodId = 31;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTuneOk.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTuneOk.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTuneOk.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTuneOk() {}
+    public ConnectionTuneOk(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "connection.tune-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpen: RabbitMQ.Client.Impl.MethodBase, IConnectionOpen {
+    public const int ClassId = 10;
+    public const int MethodId = 40;
+
+    public string m_virtualHost;
+    public string m_capabilities;
+    public bool m_insist;
+
+    string IConnectionOpen.VirtualHost { get { return m_virtualHost; } }
+    string IConnectionOpen.Capabilities { get { return m_capabilities; } }
+    bool IConnectionOpen.Insist { get { return m_insist; } }
+
+    public ConnectionOpen() {}
+    public ConnectionOpen(
+      string initVirtualHost,
+      string initCapabilities,
+      bool initInsist)
+    {
+      m_virtualHost = initVirtualHost;
+      m_capabilities = initCapabilities;
+      m_insist = initInsist;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "connection.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_virtualHost = reader.ReadShortstr();
+      m_capabilities = reader.ReadShortstr();
+      m_insist = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_virtualHost);
+      writer.WriteShortstr(m_capabilities);
+      writer.WriteBit(m_insist);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_virtualHost); sb.Append(",");
+      sb.Append(m_capabilities); sb.Append(",");
+      sb.Append(m_insist);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpenOk: RabbitMQ.Client.Impl.MethodBase, IConnectionOpenOk {
+    public const int ClassId = 10;
+    public const int MethodId = 41;
+
+    public string m_knownHosts;
+
+    string IConnectionOpenOk.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionOpenOk() {}
+    public ConnectionOpenOk(
+      string initKnownHosts)
+    {
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "connection.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionRedirect: RabbitMQ.Client.Impl.MethodBase, IConnectionRedirect {
+    public const int ClassId = 10;
+    public const int MethodId = 42;
+
+    public string m_host;
+    public string m_knownHosts;
+
+    string IConnectionRedirect.Host { get { return m_host; } }
+    string IConnectionRedirect.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionRedirect() {}
+    public ConnectionRedirect(
+      string initHost,
+      string initKnownHosts)
+    {
+      m_host = initHost;
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 42; } }
+    public override string ProtocolMethodName { get { return "connection.redirect"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_host = reader.ReadShortstr();
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_host);
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_host); sb.Append(",");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionClose: RabbitMQ.Client.Impl.MethodBase, IConnectionClose {
+    public const int ClassId = 10;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IConnectionClose.ReplyCode { get { return m_replyCode; } }
+    string IConnectionClose.ReplyText { get { return m_replyText; } }
+    ushort IConnectionClose.ClassId { get { return m_classId; } }
+    ushort IConnectionClose.MethodId { get { return m_methodId; } }
+
+    public ConnectionClose() {}
+    public ConnectionClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "connection.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionCloseOk: RabbitMQ.Client.Impl.MethodBase, IConnectionCloseOk {
+    public const int ClassId = 10;
+    public const int MethodId = 51;
+
+
+
+    public ConnectionCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 51; } }
+    public override string ProtocolMethodName { get { return "connection.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpen: RabbitMQ.Client.Impl.MethodBase, IChannelOpen {
+    public const int ClassId = 20;
+    public const int MethodId = 10;
+
+    public string m_outOfBand;
+
+    string IChannelOpen.OutOfBand { get { return m_outOfBand; } }
+
+    public ChannelOpen() {}
+    public ChannelOpen(
+      string initOutOfBand)
+    {
+      m_outOfBand = initOutOfBand;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "channel.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_outOfBand = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_outOfBand);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_outOfBand);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpenOk: RabbitMQ.Client.Impl.MethodBase, IChannelOpenOk {
+    public const int ClassId = 20;
+    public const int MethodId = 11;
+
+    public byte[] m_channelId;
+
+    byte[] IChannelOpenOk.ChannelId { get { return m_channelId; } }
+
+    public ChannelOpenOk() {}
+    public ChannelOpenOk(
+      byte[] initChannelId)
+    {
+      m_channelId = initChannelId;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "channel.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelId = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_channelId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlow: RabbitMQ.Client.Impl.MethodBase, IChannelFlow {
+    public const int ClassId = 20;
+    public const int MethodId = 20;
+
+    public bool m_active;
+
+    bool IChannelFlow.Active { get { return m_active; } }
+
+    public ChannelFlow() {}
+    public ChannelFlow(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "channel.flow"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlowOk: RabbitMQ.Client.Impl.MethodBase, IChannelFlowOk {
+    public const int ClassId = 20;
+    public const int MethodId = 21;
+
+    public bool m_active;
+
+    bool IChannelFlowOk.Active { get { return m_active; } }
+
+    public ChannelFlowOk() {}
+    public ChannelFlowOk(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "channel.flow-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelClose: RabbitMQ.Client.Impl.MethodBase, IChannelClose {
+    public const int ClassId = 20;
+    public const int MethodId = 40;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IChannelClose.ReplyCode { get { return m_replyCode; } }
+    string IChannelClose.ReplyText { get { return m_replyText; } }
+    ushort IChannelClose.ClassId { get { return m_classId; } }
+    ushort IChannelClose.MethodId { get { return m_methodId; } }
+
+    public ChannelClose() {}
+    public ChannelClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "channel.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelCloseOk: RabbitMQ.Client.Impl.MethodBase, IChannelCloseOk {
+    public const int ClassId = 20;
+    public const int MethodId = 41;
+
+
+
+    public ChannelCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "channel.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelResume: RabbitMQ.Client.Impl.MethodBase, IChannelResume {
+    public const int ClassId = 20;
+    public const int MethodId = 50;
+
+    public byte[] m_channelId;
+
+    byte[] IChannelResume.ChannelId { get { return m_channelId; } }
+
+    public ChannelResume() {}
+    public ChannelResume(
+      byte[] initChannelId)
+    {
+      m_channelId = initChannelId;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "channel.resume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelId = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_channelId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelPing: RabbitMQ.Client.Impl.MethodBase, IChannelPing {
+    public const int ClassId = 20;
+    public const int MethodId = 60;
+
+
+
+    public ChannelPing(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "channel.ping"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelPong: RabbitMQ.Client.Impl.MethodBase, IChannelPong {
+    public const int ClassId = 20;
+    public const int MethodId = 70;
+
+
+
+    public ChannelPong(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "channel.pong"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOk: RabbitMQ.Client.Impl.MethodBase, IChannelOk {
+    public const int ClassId = 20;
+    public const int MethodId = 80;
+
+
+
+    public ChannelOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "channel.ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequest: RabbitMQ.Client.Impl.MethodBase, IAccessRequest {
+    public const int ClassId = 30;
+    public const int MethodId = 10;
+
+    public string m_realm;
+    public bool m_exclusive;
+    public bool m_passive;
+    public bool m_active;
+    public bool m_write;
+    public bool m_read;
+
+    string IAccessRequest.Realm { get { return m_realm; } }
+    bool IAccessRequest.Exclusive { get { return m_exclusive; } }
+    bool IAccessRequest.Passive { get { return m_passive; } }
+    bool IAccessRequest.Active { get { return m_active; } }
+    bool IAccessRequest.Write { get { return m_write; } }
+    bool IAccessRequest.Read { get { return m_read; } }
+
+    public AccessRequest() {}
+    public AccessRequest(
+      string initRealm,
+      bool initExclusive,
+      bool initPassive,
+      bool initActive,
+      bool initWrite,
+      bool initRead)
+    {
+      m_realm = initRealm;
+      m_exclusive = initExclusive;
+      m_passive = initPassive;
+      m_active = initActive;
+      m_write = initWrite;
+      m_read = initRead;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "access.request"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_realm = reader.ReadShortstr();
+      m_exclusive = reader.ReadBit();
+      m_passive = reader.ReadBit();
+      m_active = reader.ReadBit();
+      m_write = reader.ReadBit();
+      m_read = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_realm);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_active);
+      writer.WriteBit(m_write);
+      writer.WriteBit(m_read);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_realm); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_active); sb.Append(",");
+      sb.Append(m_write); sb.Append(",");
+      sb.Append(m_read);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequestOk: RabbitMQ.Client.Impl.MethodBase, IAccessRequestOk {
+    public const int ClassId = 30;
+    public const int MethodId = 11;
+
+    public ushort m_ticket;
+
+    ushort IAccessRequestOk.Ticket { get { return m_ticket; } }
+
+    public AccessRequestOk() {}
+    public AccessRequestOk(
+      ushort initTicket)
+    {
+      m_ticket = initTicket;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "access.request-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclare: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclare {
+    public const int ClassId = 40;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_type;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_autoDelete;
+    public bool m_internal;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IExchangeDeclare.Ticket { get { return m_ticket; } }
+    string IExchangeDeclare.Exchange { get { return m_exchange; } }
+    string IExchangeDeclare.Type { get { return m_type; } }
+    bool IExchangeDeclare.Passive { get { return m_passive; } }
+    bool IExchangeDeclare.Durable { get { return m_durable; } }
+    bool IExchangeDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IExchangeDeclare.Internal { get { return m_internal; } }
+    bool IExchangeDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IExchangeDeclare.Arguments { get { return m_arguments; } }
+
+    public ExchangeDeclare() {}
+    public ExchangeDeclare(
+      ushort initTicket,
+      string initExchange,
+      string initType,
+      bool initPassive,
+      bool initDurable,
+      bool initAutoDelete,
+      bool initInternal,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_type = initType;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_autoDelete = initAutoDelete;
+      m_internal = initInternal;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "exchange.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_type = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_internal = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_type);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_internal);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_type); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_internal); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclareOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclareOk {
+    public const int ClassId = 40;
+    public const int MethodId = 11;
+
+
+
+    public ExchangeDeclareOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "exchange.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDelete: RabbitMQ.Client.Impl.MethodBase, IExchangeDelete {
+    public const int ClassId = 40;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public bool m_ifUnused;
+    public bool m_nowait;
+
+    ushort IExchangeDelete.Ticket { get { return m_ticket; } }
+    string IExchangeDelete.Exchange { get { return m_exchange; } }
+    bool IExchangeDelete.IfUnused { get { return m_ifUnused; } }
+    bool IExchangeDelete.Nowait { get { return m_nowait; } }
+
+    public ExchangeDelete() {}
+    public ExchangeDelete(
+      ushort initTicket,
+      string initExchange,
+      bool initIfUnused,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_ifUnused = initIfUnused;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "exchange.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeleteOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeleteOk {
+    public const int ClassId = 40;
+    public const int MethodId = 21;
+
+
+
+    public ExchangeDeleteOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "exchange.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclare: RabbitMQ.Client.Impl.MethodBase, IQueueDeclare {
+    public const int ClassId = 50;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_exclusive;
+    public bool m_autoDelete;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueDeclare.Ticket { get { return m_ticket; } }
+    string IQueueDeclare.Queue { get { return m_queue; } }
+    bool IQueueDeclare.Passive { get { return m_passive; } }
+    bool IQueueDeclare.Durable { get { return m_durable; } }
+    bool IQueueDeclare.Exclusive { get { return m_exclusive; } }
+    bool IQueueDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IQueueDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueDeclare.Arguments { get { return m_arguments; } }
+
+    public QueueDeclare() {}
+    public QueueDeclare(
+      ushort initTicket,
+      string initQueue,
+      bool initPassive,
+      bool initDurable,
+      bool initExclusive,
+      bool initAutoDelete,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_exclusive = initExclusive;
+      m_autoDelete = initAutoDelete;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "queue.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclareOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeclareOk {
+    public const int ClassId = 50;
+    public const int MethodId = 11;
+
+    public string m_queue;
+    public uint m_messageCount;
+    public uint m_consumerCount;
+
+    string IQueueDeclareOk.Queue { get { return m_queue; } }
+    uint IQueueDeclareOk.MessageCount { get { return m_messageCount; } }
+    uint IQueueDeclareOk.ConsumerCount { get { return m_consumerCount; } }
+
+    public QueueDeclareOk() {}
+    public QueueDeclareOk(
+      string initQueue,
+      uint initMessageCount,
+      uint initConsumerCount)
+    {
+      m_queue = initQueue;
+      m_messageCount = initMessageCount;
+      m_consumerCount = initConsumerCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "queue.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_queue = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+      m_consumerCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_queue);
+      writer.WriteLong(m_messageCount);
+      writer.WriteLong(m_consumerCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_messageCount); sb.Append(",");
+      sb.Append(m_consumerCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBind: RabbitMQ.Client.Impl.MethodBase, IQueueBind {
+    public const int ClassId = 50;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueBind.Ticket { get { return m_ticket; } }
+    string IQueueBind.Queue { get { return m_queue; } }
+    string IQueueBind.Exchange { get { return m_exchange; } }
+    string IQueueBind.RoutingKey { get { return m_routingKey; } }
+    bool IQueueBind.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueBind.Arguments { get { return m_arguments; } }
+
+    public QueueBind() {}
+    public QueueBind(
+      ushort initTicket,
+      string initQueue,
+      string initExchange,
+      string initRoutingKey,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "queue.bind"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBindOk: RabbitMQ.Client.Impl.MethodBase, IQueueBindOk {
+    public const int ClassId = 50;
+    public const int MethodId = 21;
+
+
+
+    public QueueBindOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "queue.bind-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueUnbind: RabbitMQ.Client.Impl.MethodBase, IQueueUnbind {
+    public const int ClassId = 50;
+    public const int MethodId = 50;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_exchange;
+    public string m_routingKey;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueUnbind.Ticket { get { return m_ticket; } }
+    string IQueueUnbind.Queue { get { return m_queue; } }
+    string IQueueUnbind.Exchange { get { return m_exchange; } }
+    string IQueueUnbind.RoutingKey { get { return m_routingKey; } }
+    System.Collections.IDictionary IQueueUnbind.Arguments { get { return m_arguments; } }
+
+    public QueueUnbind() {}
+    public QueueUnbind(
+      ushort initTicket,
+      string initQueue,
+      string initExchange,
+      string initRoutingKey,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "queue.unbind"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueUnbindOk: RabbitMQ.Client.Impl.MethodBase, IQueueUnbindOk {
+    public const int ClassId = 50;
+    public const int MethodId = 51;
+
+
+
+    public QueueUnbindOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 51; } }
+    public override string ProtocolMethodName { get { return "queue.unbind-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurge: RabbitMQ.Client.Impl.MethodBase, IQueuePurge {
+    public const int ClassId = 50;
+    public const int MethodId = 30;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_nowait;
+
+    ushort IQueuePurge.Ticket { get { return m_ticket; } }
+    string IQueuePurge.Queue { get { return m_queue; } }
+    bool IQueuePurge.Nowait { get { return m_nowait; } }
+
+    public QueuePurge() {}
+    public QueuePurge(
+      ushort initTicket,
+      string initQueue,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "queue.purge"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurgeOk: RabbitMQ.Client.Impl.MethodBase, IQueuePurgeOk {
+    public const int ClassId = 50;
+    public const int MethodId = 31;
+
+    public uint m_messageCount;
+
+    uint IQueuePurgeOk.MessageCount { get { return m_messageCount; } }
+
+    public QueuePurgeOk() {}
+    public QueuePurgeOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "queue.purge-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDelete: RabbitMQ.Client.Impl.MethodBase, IQueueDelete {
+    public const int ClassId = 50;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_ifUnused;
+    public bool m_ifEmpty;
+    public bool m_nowait;
+
+    ushort IQueueDelete.Ticket { get { return m_ticket; } }
+    string IQueueDelete.Queue { get { return m_queue; } }
+    bool IQueueDelete.IfUnused { get { return m_ifUnused; } }
+    bool IQueueDelete.IfEmpty { get { return m_ifEmpty; } }
+    bool IQueueDelete.Nowait { get { return m_nowait; } }
+
+    public QueueDelete() {}
+    public QueueDelete(
+      ushort initTicket,
+      string initQueue,
+      bool initIfUnused,
+      bool initIfEmpty,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_ifUnused = initIfUnused;
+      m_ifEmpty = initIfEmpty;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "queue.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_ifEmpty = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_ifEmpty);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_ifEmpty); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeleteOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeleteOk {
+    public const int ClassId = 50;
+    public const int MethodId = 41;
+
+    public uint m_messageCount;
+
+    uint IQueueDeleteOk.MessageCount { get { return m_messageCount; } }
+
+    public QueueDeleteOk() {}
+    public QueueDeleteOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "queue.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQos: RabbitMQ.Client.Impl.MethodBase, IBasicQos {
+    public const int ClassId = 60;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IBasicQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IBasicQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IBasicQos.Global { get { return m_global; } }
+
+    public BasicQos() {}
+    public BasicQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "basic.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQosOk: RabbitMQ.Client.Impl.MethodBase, IBasicQosOk {
+    public const int ClassId = 60;
+    public const int MethodId = 11;
+
+
+
+    public BasicQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "basic.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsume: RabbitMQ.Client.Impl.MethodBase, IBasicConsume {
+    public const int ClassId = 60;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_filter;
+
+    ushort IBasicConsume.Ticket { get { return m_ticket; } }
+    string IBasicConsume.Queue { get { return m_queue; } }
+    string IBasicConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicConsume.NoLocal { get { return m_noLocal; } }
+    bool IBasicConsume.NoAck { get { return m_noAck; } }
+    bool IBasicConsume.Exclusive { get { return m_exclusive; } }
+    bool IBasicConsume.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IBasicConsume.Filter { get { return m_filter; } }
+
+    public BasicConsume() {}
+    public BasicConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait,
+      System.Collections.IDictionary initFilter)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+      m_filter = initFilter;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "basic.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_filter = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_filter);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_filter);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsumeOk: RabbitMQ.Client.Impl.MethodBase, IBasicConsumeOk {
+    public const int ClassId = 60;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IBasicConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicConsumeOk() {}
+    public BasicConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "basic.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancel: RabbitMQ.Client.Impl.MethodBase, IBasicCancel {
+    public const int ClassId = 60;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IBasicCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicCancel.Nowait { get { return m_nowait; } }
+
+    public BasicCancel() {}
+    public BasicCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "basic.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancelOk: RabbitMQ.Client.Impl.MethodBase, IBasicCancelOk {
+    public const int ClassId = 60;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IBasicCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicCancelOk() {}
+    public BasicCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "basic.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicPublish: RabbitMQ.Client.Impl.MethodBase, IBasicPublish {
+    public const int ClassId = 60;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IBasicPublish.Ticket { get { return m_ticket; } }
+    string IBasicPublish.Exchange { get { return m_exchange; } }
+    string IBasicPublish.RoutingKey { get { return m_routingKey; } }
+    bool IBasicPublish.Mandatory { get { return m_mandatory; } }
+    bool IBasicPublish.Immediate { get { return m_immediate; } }
+
+    public BasicPublish() {}
+    public BasicPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "basic.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReturn: RabbitMQ.Client.Impl.MethodBase, IBasicReturn {
+    public const int ClassId = 60;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IBasicReturn.ReplyCode { get { return m_replyCode; } }
+    string IBasicReturn.ReplyText { get { return m_replyText; } }
+    string IBasicReturn.Exchange { get { return m_exchange; } }
+    string IBasicReturn.RoutingKey { get { return m_routingKey; } }
+
+    public BasicReturn() {}
+    public BasicReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "basic.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicDeliver: RabbitMQ.Client.Impl.MethodBase, IBasicDeliver {
+    public const int ClassId = 60;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+
+    string IBasicDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IBasicDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicDeliver.Redelivered { get { return m_redelivered; } }
+    string IBasicDeliver.Exchange { get { return m_exchange; } }
+    string IBasicDeliver.RoutingKey { get { return m_routingKey; } }
+
+    public BasicDeliver() {}
+    public BasicDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "basic.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGet: RabbitMQ.Client.Impl.MethodBase, IBasicGet {
+    public const int ClassId = 60;
+    public const int MethodId = 70;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_noAck;
+
+    ushort IBasicGet.Ticket { get { return m_ticket; } }
+    string IBasicGet.Queue { get { return m_queue; } }
+    bool IBasicGet.NoAck { get { return m_noAck; } }
+
+    public BasicGet() {}
+    public BasicGet(
+      ushort initTicket,
+      string initQueue,
+      bool initNoAck)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_noAck = initNoAck;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "basic.get"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_noAck = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_noAck);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_noAck);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetOk: RabbitMQ.Client.Impl.MethodBase, IBasicGetOk {
+    public const int ClassId = 60;
+    public const int MethodId = 71;
+
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public uint m_messageCount;
+
+    ulong IBasicGetOk.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicGetOk.Redelivered { get { return m_redelivered; } }
+    string IBasicGetOk.Exchange { get { return m_exchange; } }
+    string IBasicGetOk.RoutingKey { get { return m_routingKey; } }
+    uint IBasicGetOk.MessageCount { get { return m_messageCount; } }
+
+    public BasicGetOk() {}
+    public BasicGetOk(
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      uint initMessageCount)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 71; } }
+    public override string ProtocolMethodName { get { return "basic.get-ok"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetEmpty: RabbitMQ.Client.Impl.MethodBase, IBasicGetEmpty {
+    public const int ClassId = 60;
+    public const int MethodId = 72;
+
+    public string m_clusterId;
+
+    string IBasicGetEmpty.ClusterId { get { return m_clusterId; } }
+
+    public BasicGetEmpty() {}
+    public BasicGetEmpty(
+      string initClusterId)
+    {
+      m_clusterId = initClusterId;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 72; } }
+    public override string ProtocolMethodName { get { return "basic.get-empty"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clusterId = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_clusterId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clusterId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicAck: RabbitMQ.Client.Impl.MethodBase, IBasicAck {
+    public const int ClassId = 60;
+    public const int MethodId = 80;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IBasicAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicAck.Multiple { get { return m_multiple; } }
+
+    public BasicAck() {}
+    public BasicAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "basic.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReject: RabbitMQ.Client.Impl.MethodBase, IBasicReject {
+    public const int ClassId = 60;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IBasicReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicReject.Requeue { get { return m_requeue; } }
+
+    public BasicReject() {}
+    public BasicReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "basic.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicRecover: RabbitMQ.Client.Impl.MethodBase, IBasicRecover {
+    public const int ClassId = 60;
+    public const int MethodId = 100;
+
+    public bool m_requeue;
+
+    bool IBasicRecover.Requeue { get { return m_requeue; } }
+
+    public BasicRecover() {}
+    public BasicRecover(
+      bool initRequeue)
+    {
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "basic.recover"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQos: RabbitMQ.Client.Impl.MethodBase, IFileQos {
+    public const int ClassId = 70;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IFileQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IFileQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IFileQos.Global { get { return m_global; } }
+
+    public FileQos() {}
+    public FileQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "file.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQosOk: RabbitMQ.Client.Impl.MethodBase, IFileQosOk {
+    public const int ClassId = 70;
+    public const int MethodId = 11;
+
+
+
+    public FileQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "file.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsume: RabbitMQ.Client.Impl.MethodBase, IFileConsume {
+    public const int ClassId = 70;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_filter;
+
+    ushort IFileConsume.Ticket { get { return m_ticket; } }
+    string IFileConsume.Queue { get { return m_queue; } }
+    string IFileConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileConsume.NoLocal { get { return m_noLocal; } }
+    bool IFileConsume.NoAck { get { return m_noAck; } }
+    bool IFileConsume.Exclusive { get { return m_exclusive; } }
+    bool IFileConsume.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IFileConsume.Filter { get { return m_filter; } }
+
+    public FileConsume() {}
+    public FileConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait,
+      System.Collections.IDictionary initFilter)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+      m_filter = initFilter;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "file.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_filter = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_filter);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_filter);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsumeOk: RabbitMQ.Client.Impl.MethodBase, IFileConsumeOk {
+    public const int ClassId = 70;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IFileConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileConsumeOk() {}
+    public FileConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "file.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancel: RabbitMQ.Client.Impl.MethodBase, IFileCancel {
+    public const int ClassId = 70;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IFileCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileCancel.Nowait { get { return m_nowait; } }
+
+    public FileCancel() {}
+    public FileCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "file.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancelOk: RabbitMQ.Client.Impl.MethodBase, IFileCancelOk {
+    public const int ClassId = 70;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IFileCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileCancelOk() {}
+    public FileCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "file.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpen: RabbitMQ.Client.Impl.MethodBase, IFileOpen {
+    public const int ClassId = 70;
+    public const int MethodId = 40;
+
+    public string m_identifier;
+    public ulong m_contentSize;
+
+    string IFileOpen.Identifier { get { return m_identifier; } }
+    ulong IFileOpen.ContentSize { get { return m_contentSize; } }
+
+    public FileOpen() {}
+    public FileOpen(
+      string initIdentifier,
+      ulong initContentSize)
+    {
+      m_identifier = initIdentifier;
+      m_contentSize = initContentSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "file.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_identifier = reader.ReadShortstr();
+      m_contentSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_identifier);
+      writer.WriteLonglong(m_contentSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_identifier); sb.Append(",");
+      sb.Append(m_contentSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpenOk: RabbitMQ.Client.Impl.MethodBase, IFileOpenOk {
+    public const int ClassId = 70;
+    public const int MethodId = 41;
+
+    public ulong m_stagedSize;
+
+    ulong IFileOpenOk.StagedSize { get { return m_stagedSize; } }
+
+    public FileOpenOk() {}
+    public FileOpenOk(
+      ulong initStagedSize)
+    {
+      m_stagedSize = initStagedSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "file.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_stagedSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_stagedSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_stagedSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileStage: RabbitMQ.Client.Impl.MethodBase, IFileStage {
+    public const int ClassId = 70;
+    public const int MethodId = 50;
+
+
+
+    public FileStage(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "file.stage"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FilePublish: RabbitMQ.Client.Impl.MethodBase, IFilePublish {
+    public const int ClassId = 70;
+    public const int MethodId = 60;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+    public string m_identifier;
+
+    ushort IFilePublish.Ticket { get { return m_ticket; } }
+    string IFilePublish.Exchange { get { return m_exchange; } }
+    string IFilePublish.RoutingKey { get { return m_routingKey; } }
+    bool IFilePublish.Mandatory { get { return m_mandatory; } }
+    bool IFilePublish.Immediate { get { return m_immediate; } }
+    string IFilePublish.Identifier { get { return m_identifier; } }
+
+    public FilePublish() {}
+    public FilePublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate,
+      string initIdentifier)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "file.publish"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReturn: RabbitMQ.Client.Impl.MethodBase, IFileReturn {
+    public const int ClassId = 70;
+    public const int MethodId = 70;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IFileReturn.ReplyCode { get { return m_replyCode; } }
+    string IFileReturn.ReplyText { get { return m_replyText; } }
+    string IFileReturn.Exchange { get { return m_exchange; } }
+    string IFileReturn.RoutingKey { get { return m_routingKey; } }
+
+    public FileReturn() {}
+    public FileReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "file.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileDeliver: RabbitMQ.Client.Impl.MethodBase, IFileDeliver {
+    public const int ClassId = 70;
+    public const int MethodId = 80;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public string m_identifier;
+
+    string IFileDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IFileDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileDeliver.Redelivered { get { return m_redelivered; } }
+    string IFileDeliver.Exchange { get { return m_exchange; } }
+    string IFileDeliver.RoutingKey { get { return m_routingKey; } }
+    string IFileDeliver.Identifier { get { return m_identifier; } }
+
+    public FileDeliver() {}
+    public FileDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      string initIdentifier)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "file.deliver"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileAck: RabbitMQ.Client.Impl.MethodBase, IFileAck {
+    public const int ClassId = 70;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IFileAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileAck.Multiple { get { return m_multiple; } }
+
+    public FileAck() {}
+    public FileAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "file.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReject: RabbitMQ.Client.Impl.MethodBase, IFileReject {
+    public const int ClassId = 70;
+    public const int MethodId = 100;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IFileReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileReject.Requeue { get { return m_requeue; } }
+
+    public FileReject() {}
+    public FileReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "file.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQos: RabbitMQ.Client.Impl.MethodBase, IStreamQos {
+    public const int ClassId = 80;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public uint m_consumeRate;
+    public bool m_global;
+
+    uint IStreamQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IStreamQos.PrefetchCount { get { return m_prefetchCount; } }
+    uint IStreamQos.ConsumeRate { get { return m_consumeRate; } }
+    bool IStreamQos.Global { get { return m_global; } }
+
+    public StreamQos() {}
+    public StreamQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      uint initConsumeRate,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_consumeRate = initConsumeRate;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "stream.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_consumeRate = reader.ReadLong();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteLong(m_consumeRate);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_consumeRate); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQosOk: RabbitMQ.Client.Impl.MethodBase, IStreamQosOk {
+    public const int ClassId = 80;
+    public const int MethodId = 11;
+
+
+
+    public StreamQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "stream.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsume: RabbitMQ.Client.Impl.MethodBase, IStreamConsume {
+    public const int ClassId = 80;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_exclusive;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_filter;
+
+    ushort IStreamConsume.Ticket { get { return m_ticket; } }
+    string IStreamConsume.Queue { get { return m_queue; } }
+    string IStreamConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamConsume.NoLocal { get { return m_noLocal; } }
+    bool IStreamConsume.Exclusive { get { return m_exclusive; } }
+    bool IStreamConsume.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IStreamConsume.Filter { get { return m_filter; } }
+
+    public StreamConsume() {}
+    public StreamConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initExclusive,
+      bool initNowait,
+      System.Collections.IDictionary initFilter)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+      m_filter = initFilter;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "stream.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_filter = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_filter);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_filter);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsumeOk: RabbitMQ.Client.Impl.MethodBase, IStreamConsumeOk {
+    public const int ClassId = 80;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IStreamConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamConsumeOk() {}
+    public StreamConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "stream.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancel: RabbitMQ.Client.Impl.MethodBase, IStreamCancel {
+    public const int ClassId = 80;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IStreamCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamCancel.Nowait { get { return m_nowait; } }
+
+    public StreamCancel() {}
+    public StreamCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "stream.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancelOk: RabbitMQ.Client.Impl.MethodBase, IStreamCancelOk {
+    public const int ClassId = 80;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IStreamCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamCancelOk() {}
+    public StreamCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "stream.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamPublish: RabbitMQ.Client.Impl.MethodBase, IStreamPublish {
+    public const int ClassId = 80;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IStreamPublish.Ticket { get { return m_ticket; } }
+    string IStreamPublish.Exchange { get { return m_exchange; } }
+    string IStreamPublish.RoutingKey { get { return m_routingKey; } }
+    bool IStreamPublish.Mandatory { get { return m_mandatory; } }
+    bool IStreamPublish.Immediate { get { return m_immediate; } }
+
+    public StreamPublish() {}
+    public StreamPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "stream.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamReturn: RabbitMQ.Client.Impl.MethodBase, IStreamReturn {
+    public const int ClassId = 80;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IStreamReturn.ReplyCode { get { return m_replyCode; } }
+    string IStreamReturn.ReplyText { get { return m_replyText; } }
+    string IStreamReturn.Exchange { get { return m_exchange; } }
+    string IStreamReturn.RoutingKey { get { return m_routingKey; } }
+
+    public StreamReturn() {}
+    public StreamReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "stream.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamDeliver: RabbitMQ.Client.Impl.MethodBase, IStreamDeliver {
+    public const int ClassId = 80;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public string m_exchange;
+    public string m_queue;
+
+    string IStreamDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IStreamDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    string IStreamDeliver.Exchange { get { return m_exchange; } }
+    string IStreamDeliver.Queue { get { return m_queue; } }
+
+    public StreamDeliver() {}
+    public StreamDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      string initExchange,
+      string initQueue)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_exchange = initExchange;
+      m_queue = initQueue;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "stream.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_exchange = reader.ReadShortstr();
+      m_queue = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_queue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_queue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelect: RabbitMQ.Client.Impl.MethodBase, ITxSelect {
+    public const int ClassId = 90;
+    public const int MethodId = 10;
+
+
+
+    public TxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelectOk: RabbitMQ.Client.Impl.MethodBase, ITxSelectOk {
+    public const int ClassId = 90;
+    public const int MethodId = 11;
+
+
+
+    public TxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "tx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommit: RabbitMQ.Client.Impl.MethodBase, ITxCommit {
+    public const int ClassId = 90;
+    public const int MethodId = 20;
+
+
+
+    public TxCommit(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "tx.commit"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommitOk: RabbitMQ.Client.Impl.MethodBase, ITxCommitOk {
+    public const int ClassId = 90;
+    public const int MethodId = 21;
+
+
+
+    public TxCommitOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "tx.commit-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollback: RabbitMQ.Client.Impl.MethodBase, ITxRollback {
+    public const int ClassId = 90;
+    public const int MethodId = 30;
+
+
+
+    public TxRollback(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "tx.rollback"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollbackOk: RabbitMQ.Client.Impl.MethodBase, ITxRollbackOk {
+    public const int ClassId = 90;
+    public const int MethodId = 31;
+
+
+
+    public TxRollbackOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "tx.rollback-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelect: RabbitMQ.Client.Impl.MethodBase, IDtxSelect {
+    public const int ClassId = 100;
+    public const int MethodId = 10;
+
+
+
+    public DtxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "dtx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelectOk: RabbitMQ.Client.Impl.MethodBase, IDtxSelectOk {
+    public const int ClassId = 100;
+    public const int MethodId = 11;
+
+
+
+    public DtxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "dtx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStart: RabbitMQ.Client.Impl.MethodBase, IDtxStart {
+    public const int ClassId = 100;
+    public const int MethodId = 20;
+
+    public string m_dtxIdentifier;
+
+    string IDtxStart.DtxIdentifier { get { return m_dtxIdentifier; } }
+
+    public DtxStart() {}
+    public DtxStart(
+      string initDtxIdentifier)
+    {
+      m_dtxIdentifier = initDtxIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "dtx.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_dtxIdentifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_dtxIdentifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_dtxIdentifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStartOk: RabbitMQ.Client.Impl.MethodBase, IDtxStartOk {
+    public const int ClassId = 100;
+    public const int MethodId = 21;
+
+
+
+    public DtxStartOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "dtx.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TunnelRequest: RabbitMQ.Client.Impl.MethodBase, ITunnelRequest {
+    public const int ClassId = 110;
+    public const int MethodId = 10;
+
+    public System.Collections.IDictionary m_metaData;
+
+    System.Collections.IDictionary ITunnelRequest.MetaData { get { return m_metaData; } }
+
+    public TunnelRequest() {}
+    public TunnelRequest(
+      System.Collections.IDictionary initMetaData)
+    {
+      m_metaData = initMetaData;
+    }
+
+    public override int ProtocolClassId { get { return 110; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tunnel.request"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_metaData = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_metaData);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_metaData);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageTransfer: RabbitMQ.Client.Impl.MethodBase, IMessageTransfer {
+    public const int ClassId = 120;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_destination;
+    public bool m_redelivered;
+    public bool m_immediate;
+    public ulong m_ttl;
+    public byte m_priority;
+    public AmqpTimestamp m_timestamp;
+    public byte m_deliveryMode;
+    public AmqpTimestamp m_expiration;
+    public string m_exchange;
+    public string m_routingKey;
+    public string m_messageId;
+    public string m_correlationId;
+    public string m_replyTo;
+    public string m_contentType;
+    public string m_contentEncoding;
+    public string m_userId;
+    public string m_appId;
+    public string m_transactionId;
+    public byte[] m_securityToken;
+    public System.Collections.IDictionary m_applicationHeaders;
+    public byte[] m_body;
+
+    ushort IMessageTransfer.Ticket { get { return m_ticket; } }
+    string IMessageTransfer.Destination { get { return m_destination; } }
+    bool IMessageTransfer.Redelivered { get { return m_redelivered; } }
+    bool IMessageTransfer.Immediate { get { return m_immediate; } }
+    ulong IMessageTransfer.Ttl { get { return m_ttl; } }
+    byte IMessageTransfer.Priority { get { return m_priority; } }
+    AmqpTimestamp IMessageTransfer.Timestamp { get { return m_timestamp; } }
+    byte IMessageTransfer.DeliveryMode { get { return m_deliveryMode; } }
+    AmqpTimestamp IMessageTransfer.Expiration { get { return m_expiration; } }
+    string IMessageTransfer.Exchange { get { return m_exchange; } }
+    string IMessageTransfer.RoutingKey { get { return m_routingKey; } }
+    string IMessageTransfer.MessageId { get { return m_messageId; } }
+    string IMessageTransfer.CorrelationId { get { return m_correlationId; } }
+    string IMessageTransfer.ReplyTo { get { return m_replyTo; } }
+    string IMessageTransfer.ContentType { get { return m_contentType; } }
+    string IMessageTransfer.ContentEncoding { get { return m_contentEncoding; } }
+    string IMessageTransfer.UserId { get { return m_userId; } }
+    string IMessageTransfer.AppId { get { return m_appId; } }
+    string IMessageTransfer.TransactionId { get { return m_transactionId; } }
+    byte[] IMessageTransfer.SecurityToken { get { return m_securityToken; } }
+    System.Collections.IDictionary IMessageTransfer.ApplicationHeaders { get { return m_applicationHeaders; } }
+    byte[] IMessageTransfer.Body { get { return m_body; } }
+
+    public MessageTransfer() {}
+    public MessageTransfer(
+      ushort initTicket,
+      string initDestination,
+      bool initRedelivered,
+      bool initImmediate,
+      ulong initTtl,
+      byte initPriority,
+      AmqpTimestamp initTimestamp,
+      byte initDeliveryMode,
+      AmqpTimestamp initExpiration,
+      string initExchange,
+      string initRoutingKey,
+      string initMessageId,
+      string initCorrelationId,
+      string initReplyTo,
+      string initContentType,
+      string initContentEncoding,
+      string initUserId,
+      string initAppId,
+      string initTransactionId,
+      byte[] initSecurityToken,
+      System.Collections.IDictionary initApplicationHeaders,
+      byte[] initBody)
+    {
+      m_ticket = initTicket;
+      m_destination = initDestination;
+      m_redelivered = initRedelivered;
+      m_immediate = initImmediate;
+      m_ttl = initTtl;
+      m_priority = initPriority;
+      m_timestamp = initTimestamp;
+      m_deliveryMode = initDeliveryMode;
+      m_expiration = initExpiration;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_messageId = initMessageId;
+      m_correlationId = initCorrelationId;
+      m_replyTo = initReplyTo;
+      m_contentType = initContentType;
+      m_contentEncoding = initContentEncoding;
+      m_userId = initUserId;
+      m_appId = initAppId;
+      m_transactionId = initTransactionId;
+      m_securityToken = initSecurityToken;
+      m_applicationHeaders = initApplicationHeaders;
+      m_body = initBody;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "message.transfer"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_destination = reader.ReadShortstr();
+      m_redelivered = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+      m_ttl = reader.ReadLonglong();
+      m_priority = reader.ReadOctet();
+      m_timestamp = reader.ReadTimestamp();
+      m_deliveryMode = reader.ReadOctet();
+      m_expiration = reader.ReadTimestamp();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_messageId = reader.ReadShortstr();
+      m_correlationId = reader.ReadShortstr();
+      m_replyTo = reader.ReadShortstr();
+      m_contentType = reader.ReadShortstr();
+      m_contentEncoding = reader.ReadShortstr();
+      m_userId = reader.ReadShortstr();
+      m_appId = reader.ReadShortstr();
+      m_transactionId = reader.ReadShortstr();
+      m_securityToken = reader.ReadLongstr();
+      m_applicationHeaders = reader.ReadTable();
+      m_body = reader.ReadContent();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_destination);
+      writer.WriteBit(m_redelivered);
+      writer.WriteBit(m_immediate);
+      writer.WriteLonglong(m_ttl);
+      writer.WriteOctet(m_priority);
+      writer.WriteTimestamp(m_timestamp);
+      writer.WriteOctet(m_deliveryMode);
+      writer.WriteTimestamp(m_expiration);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteShortstr(m_messageId);
+      writer.WriteShortstr(m_correlationId);
+      writer.WriteShortstr(m_replyTo);
+      writer.WriteShortstr(m_contentType);
+      writer.WriteShortstr(m_contentEncoding);
+      writer.WriteShortstr(m_userId);
+      writer.WriteShortstr(m_appId);
+      writer.WriteShortstr(m_transactionId);
+      writer.WriteLongstr(m_securityToken);
+      writer.WriteTable(m_applicationHeaders);
+      writer.WriteContent(m_body);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_destination); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_immediate); sb.Append(",");
+      sb.Append(m_ttl); sb.Append(",");
+      sb.Append(m_priority); sb.Append(",");
+      sb.Append(m_timestamp); sb.Append(",");
+      sb.Append(m_deliveryMode); sb.Append(",");
+      sb.Append(m_expiration); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_messageId); sb.Append(",");
+      sb.Append(m_correlationId); sb.Append(",");
+      sb.Append(m_replyTo); sb.Append(",");
+      sb.Append(m_contentType); sb.Append(",");
+      sb.Append(m_contentEncoding); sb.Append(",");
+      sb.Append(m_userId); sb.Append(",");
+      sb.Append(m_appId); sb.Append(",");
+      sb.Append(m_transactionId); sb.Append(",");
+      sb.Append(m_securityToken); sb.Append(",");
+      sb.Append(m_applicationHeaders); sb.Append(",");
+      sb.Append(m_body);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageConsume: RabbitMQ.Client.Impl.MethodBase, IMessageConsume {
+    public const int ClassId = 120;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_destination;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public System.Collections.IDictionary m_filter;
+
+    ushort IMessageConsume.Ticket { get { return m_ticket; } }
+    string IMessageConsume.Queue { get { return m_queue; } }
+    string IMessageConsume.Destination { get { return m_destination; } }
+    bool IMessageConsume.NoLocal { get { return m_noLocal; } }
+    bool IMessageConsume.NoAck { get { return m_noAck; } }
+    bool IMessageConsume.Exclusive { get { return m_exclusive; } }
+    System.Collections.IDictionary IMessageConsume.Filter { get { return m_filter; } }
+
+    public MessageConsume() {}
+    public MessageConsume(
+      ushort initTicket,
+      string initQueue,
+      string initDestination,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      System.Collections.IDictionary initFilter)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_destination = initDestination;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_filter = initFilter;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "message.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_destination = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_filter = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_destination);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteTable(m_filter);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_destination); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_filter);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageCancel: RabbitMQ.Client.Impl.MethodBase, IMessageCancel {
+    public const int ClassId = 120;
+    public const int MethodId = 30;
+
+    public string m_destination;
+
+    string IMessageCancel.Destination { get { return m_destination; } }
+
+    public MessageCancel() {}
+    public MessageCancel(
+      string initDestination)
+    {
+      m_destination = initDestination;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "message.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_destination = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_destination);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_destination);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageGet: RabbitMQ.Client.Impl.MethodBase, IMessageGet {
+    public const int ClassId = 120;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_destination;
+    public bool m_noAck;
+
+    ushort IMessageGet.Ticket { get { return m_ticket; } }
+    string IMessageGet.Queue { get { return m_queue; } }
+    string IMessageGet.Destination { get { return m_destination; } }
+    bool IMessageGet.NoAck { get { return m_noAck; } }
+
+    public MessageGet() {}
+    public MessageGet(
+      ushort initTicket,
+      string initQueue,
+      string initDestination,
+      bool initNoAck)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_destination = initDestination;
+      m_noAck = initNoAck;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "message.get"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_destination = reader.ReadShortstr();
+      m_noAck = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_destination);
+      writer.WriteBit(m_noAck);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_destination); sb.Append(",");
+      sb.Append(m_noAck);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageRecover: RabbitMQ.Client.Impl.MethodBase, IMessageRecover {
+    public const int ClassId = 120;
+    public const int MethodId = 50;
+
+    public bool m_requeue;
+
+    bool IMessageRecover.Requeue { get { return m_requeue; } }
+
+    public MessageRecover() {}
+    public MessageRecover(
+      bool initRequeue)
+    {
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "message.recover"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageOpen: RabbitMQ.Client.Impl.MethodBase, IMessageOpen {
+    public const int ClassId = 120;
+    public const int MethodId = 60;
+
+    public byte[] m_reference;
+
+    byte[] IMessageOpen.Reference { get { return m_reference; } }
+
+    public MessageOpen() {}
+    public MessageOpen(
+      byte[] initReference)
+    {
+      m_reference = initReference;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "message.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_reference = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_reference);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_reference);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageClose: RabbitMQ.Client.Impl.MethodBase, IMessageClose {
+    public const int ClassId = 120;
+    public const int MethodId = 70;
+
+    public byte[] m_reference;
+
+    byte[] IMessageClose.Reference { get { return m_reference; } }
+
+    public MessageClose() {}
+    public MessageClose(
+      byte[] initReference)
+    {
+      m_reference = initReference;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "message.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_reference = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_reference);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_reference);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageAppend: RabbitMQ.Client.Impl.MethodBase, IMessageAppend {
+    public const int ClassId = 120;
+    public const int MethodId = 80;
+
+    public byte[] m_reference;
+    public byte[] m_bytes;
+
+    byte[] IMessageAppend.Reference { get { return m_reference; } }
+    byte[] IMessageAppend.Bytes { get { return m_bytes; } }
+
+    public MessageAppend() {}
+    public MessageAppend(
+      byte[] initReference,
+      byte[] initBytes)
+    {
+      m_reference = initReference;
+      m_bytes = initBytes;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "message.append"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_reference = reader.ReadLongstr();
+      m_bytes = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_reference);
+      writer.WriteLongstr(m_bytes);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_reference); sb.Append(",");
+      sb.Append(m_bytes);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageCheckpoint: RabbitMQ.Client.Impl.MethodBase, IMessageCheckpoint {
+    public const int ClassId = 120;
+    public const int MethodId = 90;
+
+    public byte[] m_reference;
+    public string m_identifier;
+
+    byte[] IMessageCheckpoint.Reference { get { return m_reference; } }
+    string IMessageCheckpoint.Identifier { get { return m_identifier; } }
+
+    public MessageCheckpoint() {}
+    public MessageCheckpoint(
+      byte[] initReference,
+      string initIdentifier)
+    {
+      m_reference = initReference;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "message.checkpoint"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_reference = reader.ReadLongstr();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_reference);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_reference); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageResume: RabbitMQ.Client.Impl.MethodBase, IMessageResume {
+    public const int ClassId = 120;
+    public const int MethodId = 100;
+
+    public byte[] m_reference;
+    public string m_identifier;
+
+    byte[] IMessageResume.Reference { get { return m_reference; } }
+    string IMessageResume.Identifier { get { return m_identifier; } }
+
+    public MessageResume() {}
+    public MessageResume(
+      byte[] initReference,
+      string initIdentifier)
+    {
+      m_reference = initReference;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "message.resume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_reference = reader.ReadLongstr();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_reference);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_reference); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageQos: RabbitMQ.Client.Impl.MethodBase, IMessageQos {
+    public const int ClassId = 120;
+    public const int MethodId = 110;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IMessageQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IMessageQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IMessageQos.Global { get { return m_global; } }
+
+    public MessageQos() {}
+    public MessageQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 110; } }
+    public override string ProtocolMethodName { get { return "message.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageOk: RabbitMQ.Client.Impl.MethodBase, IMessageOk {
+    public const int ClassId = 120;
+    public const int MethodId = 500;
+
+
+
+    public MessageOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 500; } }
+    public override string ProtocolMethodName { get { return "message.ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageEmpty: RabbitMQ.Client.Impl.MethodBase, IMessageEmpty {
+    public const int ClassId = 120;
+    public const int MethodId = 510;
+
+
+
+    public MessageEmpty(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 510; } }
+    public override string ProtocolMethodName { get { return "message.empty"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageReject: RabbitMQ.Client.Impl.MethodBase, IMessageReject {
+    public const int ClassId = 120;
+    public const int MethodId = 520;
+
+    public ushort m_code;
+    public string m_text;
+
+    ushort IMessageReject.Code { get { return m_code; } }
+    string IMessageReject.Text { get { return m_text; } }
+
+    public MessageReject() {}
+    public MessageReject(
+      ushort initCode,
+      string initText)
+    {
+      m_code = initCode;
+      m_text = initText;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 520; } }
+    public override string ProtocolMethodName { get { return "message.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_code = reader.ReadShort();
+      m_text = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_code);
+      writer.WriteShortstr(m_text);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_code); sb.Append(",");
+      sb.Append(m_text);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class MessageOffset: RabbitMQ.Client.Impl.MethodBase, IMessageOffset {
+    public const int ClassId = 120;
+    public const int MethodId = 530;
+
+    public ulong m_value;
+
+    ulong IMessageOffset.Value { get { return m_value; } }
+
+    public MessageOffset() {}
+    public MessageOffset(
+      ulong initValue)
+    {
+      m_value = initValue;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 530; } }
+    public override string ProtocolMethodName { get { return "message.offset"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_value = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_value);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_value);
+      sb.Append(")");
+    }
+  }
+
+  public class Model: RabbitMQ.Client.Impl.ModelBase {
+    public Model(RabbitMQ.Client.Impl.ISession session): base(session) {}
+    public override System.UInt16 _Private_AccessRequest(
+      System.String @realm,
+      System.Boolean @exclusive,
+      System.Boolean @passive,
+      System.Boolean @active,
+      System.Boolean @write,
+      System.Boolean @read)
+    {
+      AccessRequest __req = new AccessRequest();
+      __req.m_realm = @realm;
+      __req.m_exclusive = @exclusive;
+      __req.m_passive = @passive;
+      __req.m_active = @active;
+      __req.m_write = @write;
+      __req.m_read = @read;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      AccessRequestOk __rep = __repBase as AccessRequestOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_ticket;
+    }
+    public override void _Private_BasicPublish(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @mandatory,
+      System.Boolean @immediate,
+      RabbitMQ.Client.IBasicProperties @basicProperties,
+      System.Byte[] @body)
+    {
+      BasicPublish __req = new BasicPublish();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_mandatory = @mandatory;
+      __req.m_immediate = @immediate;
+      ModelSend(__req, (BasicProperties) basicProperties,body);
+    }
+    public override void _Private_BasicConsume(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @consumerTag,
+      System.Boolean @noLocal,
+      System.Boolean @noAck,
+      System.Boolean @exclusive,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @filter)
+    {
+      BasicConsume __req = new BasicConsume();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_consumerTag = @consumerTag;
+      __req.m_noLocal = @noLocal;
+      __req.m_noAck = @noAck;
+      __req.m_exclusive = @exclusive;
+      __req.m_nowait = @nowait;
+      __req.m_filter = @filter;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicCancel(
+      System.String @consumerTag,
+      System.Boolean @nowait)
+    {
+      BasicCancel __req = new BasicCancel();
+      __req.m_consumerTag = @consumerTag;
+      __req.m_nowait = @nowait;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelOpen(
+      System.String @outOfBand)
+    {
+      ChannelOpen __req = new ChannelOpen();
+      __req.m_outOfBand = @outOfBand;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelOpenOk __rep = __repBase as ChannelOpenOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ChannelCloseOk()
+    {
+      ChannelCloseOk __req = new ChannelCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ChannelClose __req = new ChannelClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicGet(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @noAck)
+    {
+      BasicGet __req = new BasicGet();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_noAck = @noAck;
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.Impl.ConnectionTuneDetails ConnectionStartOk(
+      System.Collections.IDictionary @clientProperties,
+      System.String @mechanism,
+      System.Byte[] @response,
+      System.String @locale)
+    {
+      ConnectionStartOk __req = new ConnectionStartOk();
+      __req.m_clientProperties = @clientProperties;
+      __req.m_mechanism = @mechanism;
+      __req.m_response = @response;
+      __req.m_locale = @locale;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionTune __rep = __repBase as ConnectionTune;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      RabbitMQ.Client.Impl.ConnectionTuneDetails __result = new RabbitMQ.Client.Impl.ConnectionTuneDetails();
+      __result.channelMax = __rep.m_channelMax;
+      __result.frameMax = __rep.m_frameMax;
+      __result.heartbeat = __rep.m_heartbeat;
+      return __result;
+    }
+    public override void ConnectionTuneOk(
+      System.UInt16 @channelMax,
+      System.UInt32 @frameMax,
+      System.UInt16 @heartbeat)
+    {
+      ConnectionTuneOk __req = new ConnectionTuneOk();
+      __req.m_channelMax = @channelMax;
+      __req.m_frameMax = @frameMax;
+      __req.m_heartbeat = @heartbeat;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionOpen(
+      System.String @virtualHost,
+      System.String @capabilities,
+      System.Boolean @insist)
+    {
+      ConnectionOpen __req = new ConnectionOpen();
+      __req.m_virtualHost = @virtualHost;
+      __req.m_capabilities = @capabilities;
+      __req.m_insist = @insist;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ConnectionClose __req = new ConnectionClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionCloseOk __rep = __repBase as ConnectionCloseOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ConnectionCloseOk()
+    {
+      ConnectionCloseOk __req = new ConnectionCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.IBasicProperties CreateBasicProperties()
+    {
+      return new BasicProperties();
+    }
+    public override RabbitMQ.Client.IFileProperties CreateFileProperties()
+    {
+      return new FileProperties();
+    }
+    public override RabbitMQ.Client.IStreamProperties CreateStreamProperties()
+    {
+      return new StreamProperties();
+    }
+    public override void ChannelFlow(
+      System.Boolean @active)
+    {
+      ChannelFlow __req = new ChannelFlow();
+      __req.m_active = @active;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelFlowOk __rep = __repBase as ChannelFlowOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDeclare(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @type,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @autoDelete,
+      System.Boolean @internal,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      ExchangeDeclare __req = new ExchangeDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_type = @type;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_internal = @internal;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeclareOk __rep = __repBase as ExchangeDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDelete(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.Boolean @ifUnused,
+      System.Boolean @nowait)
+    {
+      ExchangeDelete __req = new ExchangeDelete();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeleteOk __rep = __repBase as ExchangeDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override System.String QueueDeclare(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @exclusive,
+      System.Boolean @autoDelete,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueDeclare __req = new QueueDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_exclusive = @exclusive;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return null;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeclareOk __rep = __repBase as QueueDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_queue;
+    }
+    public override void QueueBind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueBind __req = new QueueBind();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueBindOk __rep = __repBase as QueueBindOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void QueueUnbind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueUnbind __req = new QueueUnbind();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_arguments = @arguments;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueUnbindOk __rep = __repBase as QueueUnbindOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override System.UInt32 QueuePurge(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @nowait)
+    {
+      QueuePurge __req = new QueuePurge();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueuePurgeOk __rep = __repBase as QueuePurgeOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override System.UInt32 QueueDelete(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @ifUnused,
+      System.Boolean @ifEmpty,
+      System.Boolean @nowait)
+    {
+      QueueDelete __req = new QueueDelete();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_ifEmpty = @ifEmpty;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeleteOk __rep = __repBase as QueueDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override void BasicQos(
+      System.UInt32 @prefetchSize,
+      System.UInt16 @prefetchCount,
+      System.Boolean @global)
+    {
+      BasicQos __req = new BasicQos();
+      __req.m_prefetchSize = @prefetchSize;
+      __req.m_prefetchCount = @prefetchCount;
+      __req.m_global = @global;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      BasicQosOk __rep = __repBase as BasicQosOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void BasicAck(
+      System.UInt64 @deliveryTag,
+      System.Boolean @multiple)
+    {
+      BasicAck __req = new BasicAck();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_multiple = @multiple;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicReject(
+      System.UInt64 @deliveryTag,
+      System.Boolean @requeue)
+    {
+      BasicReject __req = new BasicReject();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_requeue = @requeue;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicRecover(
+      System.Boolean @requeue)
+    {
+      BasicRecover __req = new BasicRecover();
+      __req.m_requeue = @requeue;
+      ModelSend(__req,null,null);
+    }
+    public override void TxSelect()
+    {
+      TxSelect __req = new TxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxSelectOk __rep = __repBase as TxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxCommit()
+    {
+      TxCommit __req = new TxCommit();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxCommitOk __rep = __repBase as TxCommitOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxRollback()
+    {
+      TxRollback __req = new TxRollback();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxRollbackOk __rep = __repBase as TxRollbackOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxSelect()
+    {
+      DtxSelect __req = new DtxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxSelectOk __rep = __repBase as DtxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxStart(
+      System.String @dtxIdentifier)
+    {
+      DtxStart __req = new DtxStart();
+      __req.m_dtxIdentifier = @dtxIdentifier;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxStartOk __rep = __repBase as DtxStartOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override bool DispatchAsynchronous(RabbitMQ.Client.Impl.Command cmd) {
+      RabbitMQ.Client.Impl.MethodBase __method = (RabbitMQ.Client.Impl.MethodBase) cmd.Method;
+      switch ((__method.ProtocolClassId << 16) | __method.ProtocolMethodId) {
+        case 3932181: {
+          BasicConsumeOk __impl = (BasicConsumeOk) __method;
+          HandleBasicConsumeOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932191: {
+          BasicCancelOk __impl = (BasicCancelOk) __method;
+          HandleBasicCancelOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932231: {
+          BasicGetOk __impl = (BasicGetOk) __method;
+          HandleBasicGetOk(
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            __impl.m_messageCount,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932232: {
+          HandleBasicGetEmpty();
+          return true;
+        }
+        case 3932220: {
+          BasicDeliver __impl = (BasicDeliver) __method;
+          HandleBasicDeliver(
+            __impl.m_consumerTag,
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932210: {
+          BasicReturn __impl = (BasicReturn) __method;
+          HandleBasicReturn(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 1310760: {
+          ChannelClose __impl = (ChannelClose) __method;
+          HandleChannelClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        case 1310761: {
+          HandleChannelCloseOk();
+          return true;
+        }
+        case 655370: {
+          ConnectionStart __impl = (ConnectionStart) __method;
+          HandleConnectionStart(
+            __impl.m_versionMajor,
+            __impl.m_versionMinor,
+            __impl.m_serverProperties,
+            __impl.m_mechanisms,
+            __impl.m_locales);
+          return true;
+        }
+        case 655401: {
+          ConnectionOpenOk __impl = (ConnectionOpenOk) __method;
+          HandleConnectionOpenOk(
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655402: {
+          ConnectionRedirect __impl = (ConnectionRedirect) __method;
+          HandleConnectionRedirect(
+            __impl.m_host,
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655410: {
+          ConnectionClose __impl = (ConnectionClose) __method;
+          HandleConnectionClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        default: return false;
+      }
+    }
+  }
+}
diff --git a/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-qpid-0-8.cs b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-qpid-0-8.cs
new file mode 100644
index 00000000000..d02cdbcc000
--- /dev/null
+++ b/mcs/class/RabbitMQ.Client/docs/specs/autogenerated-api-qpid-0-8.cs
@@ -0,0 +1,8254 @@
+// Autogenerated code. Do not edit.
+
+using RabbitMQ.Client;
+using RabbitMQ.Client.Exceptions;
+
+namespace RabbitMQ.Client.Framing.v0_8qpid {
+  public class Protocol: RabbitMQ.Client.Framing.Impl.v0_8qpid.ProtocolBase {
+    ///<summary>Protocol major version (= 8)</summary>
+    public override int MajorVersion { get { return 8; } }
+    ///<summary>Protocol minor version (= 0)</summary>
+    public override int MinorVersion { get { return 0; } }
+    ///<summary>Protocol API name (= AMQP_0_8_QPID)</summary>
+    public override string ApiName { get { return "AMQP_0_8_QPID"; } }
+    ///<summary>Default TCP port (= 5672)</summary>
+    public override int DefaultPort { get { return 5672; } }
+
+    public override RabbitMQ.Client.Impl.MethodBase DecodeMethodFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+      ushort methodId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 10: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStart result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecure result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecure();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecureOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecureOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTune result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTune();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTuneOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTuneOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionRedirect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionRedirect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionClose result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 61: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 20: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlow result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlow();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlowOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlowOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelAlert result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelAlert();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelClose result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelClose();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelCloseOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 30: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequest result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequestOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequestOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 40: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDelete result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 22: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBound result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBound();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 23: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBoundOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBoundOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 50: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclare();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclareOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBind result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBind();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBindOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBindOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurge result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurge();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurgeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurgeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDelete result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDelete();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeleteOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 60: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicPublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGet result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGet();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 71: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 72: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetEmpty result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetEmpty();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicAck result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReject result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecover result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecover();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 101: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecoverOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecoverOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 70: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpen();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpenOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileStage result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileStage();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FilePublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FilePublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 70: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 80: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 90: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileAck result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileAck();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 100: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReject result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReject();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 80: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQos();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQosOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsume();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsumeOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancel();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancelOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamPublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamPublish();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 50: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamReturn();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 60: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamDeliver();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 90: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommit result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommit();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommitOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommitOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollback result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollback();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollbackOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollbackOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 100: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelect();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelectOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStart result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStart();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStartOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 110: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TunnelRequest result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TunnelRequest();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        case 120: {
+          switch (methodId) {
+            case 10: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestInteger result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestInteger();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 11: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestIntegerOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestIntegerOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 20: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestString result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestString();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 21: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestStringOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestStringOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 30: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTable result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTable();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 31: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTableOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTableOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 40: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContent result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContent();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            case 41: {
+              RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContentOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContentOk();
+              result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
+              return result;
+            }
+            default: break;
+          }
+          break;
+        }
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, methodId);
+    }
+
+    public override RabbitMQ.Client.Impl.ContentHeaderBase DecodeContentHeaderFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
+      ushort classId = reader.ReadUInt16();
+
+      switch (classId) {
+        case 60: return new BasicProperties();
+        case 70: return new FileProperties();
+        case 80: return new StreamProperties();
+        case 110: return new TunnelProperties();
+        case 120: return new TestProperties();
+        default: break;
+      }
+      throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, 0);
+    }
+  }
+  public class Constants {
+    ///<summary>(= 1)</summary>
+    public const int FrameMethod = 1;
+    ///<summary>(= 2)</summary>
+    public const int FrameHeader = 2;
+    ///<summary>(= 3)</summary>
+    public const int FrameBody = 3;
+    ///<summary>(= 4)</summary>
+    public const int FrameOobMethod = 4;
+    ///<summary>(= 5)</summary>
+    public const int FrameOobHeader = 5;
+    ///<summary>(= 6)</summary>
+    public const int FrameOobBody = 6;
+    ///<summary>(= 7)</summary>
+    public const int FrameTrace = 7;
+    ///<summary>(= 8)</summary>
+    public const int FrameHeartbeat = 8;
+    ///<summary>(= 4096)</summary>
+    public const int FrameMinSize = 4096;
+    ///<summary>(= 206)</summary>
+    public const int FrameEnd = 206;
+    ///<summary>(= 200)</summary>
+    public const int ReplySuccess = 200;
+    ///<summary>(= 310)</summary>
+    public const int NotDelivered = 310;
+    ///<summary>(= 311)</summary>
+    public const int ContentTooLarge = 311;
+    ///<summary>(= 320)</summary>
+    public const int ConnectionForced = 320;
+    ///<summary>(= 402)</summary>
+    public const int InvalidPath = 402;
+    ///<summary>(= 403)</summary>
+    public const int AccessRefused = 403;
+    ///<summary>(= 404)</summary>
+    public const int NotFound = 404;
+    ///<summary>(= 405)</summary>
+    public const int ResourceLocked = 405;
+    ///<summary>(= 501)</summary>
+    public const int FrameError = 501;
+    ///<summary>(= 502)</summary>
+    public const int SyntaxError = 502;
+    ///<summary>(= 503)</summary>
+    public const int CommandInvalid = 503;
+    ///<summary>(= 504)</summary>
+    public const int ChannelError = 504;
+    ///<summary>(= 506)</summary>
+    public const int ResourceError = 506;
+    ///<summary>(= 530)</summary>
+    public const int NotAllowed = 530;
+    ///<summary>(= 540)</summary>
+    public const int NotImplemented = 540;
+    ///<summary>(= 541)</summary>
+    public const int InternalError = 541;
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start".</summary>
+  /// <remarks>
+  /// 
+  ///     This method starts the connection negotiation process by telling
+  ///     the client the protocol version that the server proposes, along
+  ///     with a list of security mechanisms which the client can use for
+  ///     authentication.
+  ///   
+  /// </remarks>
+  public interface IConnectionStart: IMethod {
+    /// <summary>
+    /// 
+    ///       The protocol major version that the server agrees to use, which
+    ///       cannot be higher than the client's major version.
+    ///     
+    /// </summary>
+    byte VersionMajor { get; }
+    /// <summary>
+    /// 
+    ///       The protocol minor version that the server agrees to use, which
+    ///       cannot be higher than the client's minor version.
+    ///     
+    /// </summary>
+    byte VersionMinor { get; }
+    // (no documentation)
+    System.Collections.IDictionary ServerProperties { get; }
+    /// <summary>
+    /// 
+    ///       A list of the security mechanisms that the server supports, delimited
+    ///       by spaces.  Currently ASL supports these mechanisms: PLAIN.
+    ///     
+    /// </summary>
+    byte[] Mechanisms { get; }
+    /// <summary>
+    /// 
+    ///       A list of the message locales that the server supports, delimited
+    ///       by spaces.  The locale defines the language in which the server
+    ///       will send reply texts.
+    ///     
+    /// </summary>
+    byte[] Locales { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method selects a SASL security mechanism. ASL uses SASL
+  ///     (RFC2222) to negotiate authentication and encryption.
+  ///   
+  /// </remarks>
+  public interface IConnectionStartOk: IMethod {
+    // (no documentation)
+    System.Collections.IDictionary ClientProperties { get; }
+    /// <summary>
+    /// 
+    ///       A single security mechanisms selected by the client, which must be
+    ///       one of those specified by the server.
+    ///     
+    /// </summary>
+    string Mechanism { get; }
+    /// <summary>
+    /// 
+    ///       A block of opaque data passed to the security mechanism. The contents
+    ///       of this data are defined by the SASL security mechanism.  For the
+    ///       PLAIN security mechanism this is defined as a field table holding
+    ///       two fields, LOGIN and PASSWORD.
+    ///     
+    /// </summary>
+    byte[] Response { get; }
+    /// <summary>
+    /// 
+    ///       A single message local selected by the client, which must be one
+    ///       of those specified by the server.
+    ///     
+    /// </summary>
+    string Locale { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure".</summary>
+  /// <remarks>
+  /// 
+  ///     The SASL protocol works by exchanging challenges and responses until
+  ///     both peers have received sufficient information to authenticate each
+  ///     other.  This method challenges the client to provide more information.
+  ///   
+  /// </remarks>
+  public interface IConnectionSecure: IMethod {
+    /// <summary>
+    /// 
+    ///       Challenge information, a block of opaque binary data passed to
+    ///       the security mechanism.
+    ///     
+    /// </summary>
+    byte[] Challenge { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.secure-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method attempts to authenticate, passing a block of SASL data
+  ///     for the security mechanism at the server side.
+  ///   
+  /// </remarks>
+  public interface IConnectionSecureOk: IMethod {
+    /// <summary>
+    /// 
+    ///       A block of opaque data passed to the security mechanism.  The contents
+    ///       of this data are defined by the SASL security mechanism.
+    ///     
+    /// </summary>
+    byte[] Response { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune".</summary>
+  /// <remarks>
+  /// 
+  ///     This method proposes a set of connection configuration values
+  ///     to the client.  The client can accept and/or adjust these.
+  ///   
+  /// </remarks>
+  public interface IConnectionTune: IMethod {
+    /// <summary>
+    /// 
+    ///       The maximum total number of channels that the server allows
+    ///       per connection. Zero means that the server does not impose a
+    ///       fixed limit, but the number of allowed channels may be limited
+    ///       by available server resources.
+    ///     
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///       The largest frame size that the server proposes for the
+    ///       connection. The client can negotiate a lower value.  Zero means
+    ///       that the server does not impose any specific limit but may reject
+    ///       very large frames if it cannot allocate resources for them.
+    ///     
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///       The delay, in seconds, of the connection heartbeat that the server
+    ///       wants.  Zero means the server does not want a heartbeat.
+    ///     
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.tune-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sends the client's connection tuning parameters to the
+  ///     server. Certain fields are negotiated, others provide capability
+  ///     information.
+  ///   
+  /// </remarks>
+  public interface IConnectionTuneOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The maximum total number of channels that the client will use
+    ///       per connection.  May not be higher than the value specified by
+    ///       the server.
+    ///     
+    /// </summary>
+    ushort ChannelMax { get; }
+    /// <summary>
+    /// 
+    ///       The largest frame size that the client and server will use for
+    ///       the connection.  Zero means that the client does not impose any
+    ///       specific limit but may reject very large frames if it cannot
+    ///       allocate resources for them.  Note that the frame-max limit
+    ///       applies principally to content frames, where large contents
+    ///       can be broken into frames of arbitrary size.
+    ///     
+    /// </summary>
+    uint FrameMax { get; }
+    /// <summary>
+    /// 
+    ///       The delay, in seconds, of the connection heartbeat that the client
+    ///       wants. Zero means the client does not want a heartbeat.
+    ///     
+    /// </summary>
+    ushort Heartbeat { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method opens a connection to a virtual host, which is a
+  ///     collection of resources, and acts to separate multiple application
+  ///     domains within a server.
+  ///   
+  /// </remarks>
+  public interface IConnectionOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       The name of the virtual host to work with.
+    ///     
+    /// </summary>
+    string VirtualHost { get; }
+    /// <summary>
+    /// 
+    ///       The client may specify a number of capability names, delimited by
+    ///       spaces.  The server can use this string to how to process the
+    ///       client's connection request.
+    ///     
+    /// </summary>
+    string Capabilities { get; }
+    /// <summary>
+    /// 
+    ///       In a configuration with multiple load-sharing servers, the server
+    ///       may respond to a Connection.Open method with a Connection.Redirect.
+    ///       The insist option tells the server that the client is insisting on
+    ///       a connection to the specified server.
+    ///     
+    /// </summary>
+    bool Insist { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method signals to the client that the connection is ready for
+  ///     use.
+  ///   
+  /// </remarks>
+  public interface IConnectionOpenOk: IMethod {
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.redirect".</summary>
+  /// <remarks>
+  /// 
+  ///     This method redirects the client to another server, based on the
+  ///     requested virtual host and/or capabilities.
+  ///   
+  /// </remarks>
+  public interface IConnectionRedirect: IMethod {
+    /// <summary>
+    /// 
+    ///       Specifies the server to connect to.  This is an IP address or a
+    ///       DNS name, optionally followed by a colon and a port number. If
+    ///       no port number is specified, the client should use the default
+    ///       port number for the protocol.
+    ///     
+    /// </summary>
+    string Host { get; }
+    // (no documentation)
+    string KnownHosts { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close".</summary>
+  /// <remarks>
+  /// 
+  ///     This method indicates that the sender wants to close the connection.
+  ///     This may be due to internal conditions (e.g. a forced shut-down) or
+  ///     due to an error handling a specific method, i.e. an exception.  When
+  ///     a close is due to an exception, the sender provides the class and
+  ///     method id of the method which caused the exception.
+  ///   
+  /// </remarks>
+  public interface IConnectionClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       class of the method.
+    ///     
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       ID of the method.
+    ///     
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "connection.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Connection.Close method and tells the
+  ///     recipient that it is safe to release resources for the connection
+  ///     and close the socket.
+  ///   
+  /// </remarks>
+  public interface IConnectionCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method opens a virtual connection (a channel).
+  ///   
+  /// </remarks>
+  public interface IChannelOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       Configures out-of-band transfers on this channel.  The syntax and
+    ///       meaning of this field will be formally defined at a later date.
+    ///     
+    /// </summary>
+    string OutOfBand { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method signals to the client that the channel is ready for use.
+  ///   
+  /// </remarks>
+  public interface IChannelOpenOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the peer to pause or restart the flow of content
+  ///     data. This is a simple flow-control mechanism that a peer can use
+  ///     to avoid oveflowing its queues or otherwise finding itself receiving
+  ///     more messages than it can process.  Note that this method is not
+  ///     intended for window control.  The peer that receives a request to
+  ///     stop sending content should finish sending the current content, if
+  ///     any, and then wait until it receives a Flow restart method.
+  ///   
+  /// </remarks>
+  public interface IChannelFlow: IMethod {
+    /// <summary>
+    /// 
+    ///       If 1, the peer starts sending content frames.  If 0, the peer
+    ///       stops sending content frames.
+    ///     
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.flow-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     Confirms to the peer that a flow command was received and processed.
+  ///   
+  /// </remarks>
+  public interface IChannelFlowOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Confirms the setting of the processed flow method: 1 means the
+    ///       peer will start sending or continue to send content frames; 0
+    ///       means it will not.
+    ///     
+    /// </summary>
+    bool Active { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.alert".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows the server to send a non-fatal warning to the
+  ///     client.  This is used for methods that are normally asynchronous
+  ///     and thus do not have confirmations, and for which the server may
+  ///     detect errors that need to be reported.  Fatal errors are handled
+  ///     as channel or connection exceptions; non-fatal errors are sent
+  ///     through this method.
+  ///   
+  /// </remarks>
+  public interface IChannelAlert: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       A set of fields that provide more information about the
+    ///       problem.  The meaning of these fields are defined on a
+    ///       per-reply-code basis (TO BE DEFINED).
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Details { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close".</summary>
+  /// <remarks>
+  /// 
+  ///     This method indicates that the sender wants to close the channel.
+  ///     This may be due to internal conditions (e.g. a forced shut-down) or
+  ///     due to an error handling a specific method, i.e. an exception.  When
+  ///     a close is due to an exception, the sender provides the class and
+  ///     method id of the method which caused the exception.
+  ///   
+  /// </remarks>
+  public interface IChannelClose: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       class of the method.
+    ///     
+    /// </summary>
+    ushort ClassId { get; }
+    /// <summary>
+    /// 
+    ///       When the close is provoked by a method exception, this is the
+    ///       ID of the method.
+    ///     
+    /// </summary>
+    ushort MethodId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "channel.close-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Channel.Close method and tells the recipient
+  ///     that it is safe to release resources for the channel and close the
+  ///     socket.
+  ///   
+  /// </remarks>
+  public interface IChannelCloseOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests an access ticket for an access realm.
+  ///     The server responds by granting the access ticket.  If the
+  ///     client does not have access rights to the requested realm
+  ///     this causes a connection exception.  Access tickets are a
+  ///     per-channel resource.
+  ///   
+  /// </remarks>
+  public interface IAccessRequest: IMethod {
+    // (no documentation)
+    string Realm { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive access to the realm. If the server cannot grant
+    ///       this - because there are other active tickets for the realm - it
+    ///       raises a channel exception.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///       Request message passive access to the specified access realm.
+    ///       Passive access lets a client get information about resources in
+    ///       the realm but not to make any changes to them.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       Request message active access to the specified access realm.
+    ///       Acvtive access lets a client get create and delete resources in
+    ///       the realm.
+    ///     
+    /// </summary>
+    bool Active { get; }
+    /// <summary>
+    /// 
+    ///       Request write access to the specified access realm.  Write access
+    ///       lets a client publish messages to all exchanges in the realm.
+    ///     
+    /// </summary>
+    bool Write { get; }
+    /// <summary>
+    /// 
+    ///       Request read access to the specified access realm.  Read access
+    ///       lets a client consume messages from queues in the realm.
+    ///     
+    /// </summary>
+    bool Read { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "access.request-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with an access ticket. The access
+  ///     ticket is valid within the current channel and for the lifespan of
+  ///     the channel.
+  ///   
+  /// </remarks>
+  public interface IAccessRequestOk: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare".</summary>
+  /// <remarks>
+  /// 
+  ///     This method creates an exchange if it does not already exist, and if the
+  ///     exchange exists, verifies that it is of the correct and expected class.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///       When a client defines a new exchange, this belongs to the access realm
+    ///       of the ticket used.  All further work done with that exchange must be
+    ///       done with an access ticket for the same realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Each exchange belongs to one of a set of exchange types implemented
+    ///       by the server.  The exchange types define the functionality of the
+    ///       exchange - i.e. how messages are routed through it.  It is not valid
+    ///       or meaningful to attempt to change the type of an existing exchange.
+    ///     
+    /// </summary>
+    string Type { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not create the exchange.  The client can use
+    ///     this to check whether an exchange exists without modifying the server
+    ///     state.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       If set when creating a new exchange, the exchange will be marked as
+    ///       durable.  Durable exchanges remain active when a server restarts.
+    ///       Non-durable exchanges (transient exchanges) are purged if/when a
+    ///       server restarts.
+    ///     
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///       If set, the exchange is deleted when all queues have finished
+    ///       using it.
+    ///     
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///       If set, the exchange may not be used directly by publishers, but
+    ///       only when bound to other exchanges. Internal exchanges are used to
+    ///       construct wiring that is not visible to applications.
+    ///     
+    /// </summary>
+    bool Internal { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the declaration. The syntax and semantics
+    ///       of these arguments depends on the server implementation.  This
+    ///       field is ignored if passive is 1.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Declare method and confirms the name of the
+  ///     exchange, essential for automatically-named exchanges.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeclareOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete".</summary>
+  /// <remarks>
+  /// 
+  ///     This method deletes an exchange.  When an exchange is deleted all queue
+  ///     bindings on the exchange are cancelled.
+  ///   
+  /// </remarks>
+  public interface IExchangeDelete: IMethod {
+    // (no documentation)
+    ushort Ticket { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the exchange if it has no queue
+    ///       bindings. If the exchange has queue bindings the server does not
+    ///       delete it but raises a channel exception instead.
+    ///     
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.delete-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the deletion of an exchange.
+  ///   
+  /// </remarks>
+  public interface IExchangeDeleteOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.bound".</summary>
+  // (no documentation)
+  public interface IExchangeBound: IMethod {
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///               Specifies the routing key for the message.  The routing key is
+    ///               used for routing messages depending on the exchange configuration.
+    ///             
+    /// </summary>
+    string RoutingKey { get; }
+    // (no documentation)
+    string Queue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "exchange.bound-ok".</summary>
+  // (no documentation)
+  public interface IExchangeBoundOk: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare".</summary>
+  /// <remarks>
+  /// 
+  ///     This method creates or checks a queue.  When creating a new queue
+  ///     the client can specify various properties that control the durability
+  ///     of the queue and its contents, and the level of sharing for the queue.
+  ///   
+  /// </remarks>
+  public interface IQueueDeclare: IMethod {
+    /// <summary>
+    /// 
+    ///       When a client defines a new queue, this belongs to the access realm
+    ///       of the ticket used.  All further work done with that queue must be
+    ///       done with an access ticket for the same realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    // (no documentation)
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not create the queue.  The client can use
+    ///     this to check whether a queue exists without modifying the server
+    ///     state.
+    ///     
+    /// </summary>
+    bool Passive { get; }
+    /// <summary>
+    /// 
+    ///       If set when creating a new queue, the queue will be marked as
+    ///       durable.  Durable queues remain active when a server restarts.
+    ///       Non-durable queues (transient queues) are purged if/when a
+    ///       server restarts.  Note that durable queues do not necessarily
+    ///       hold persistent messages, although it does not make sense to
+    ///       send persistent messages to a transient queue.
+    ///     
+    /// </summary>
+    bool Durable { get; }
+    /// <summary>
+    /// 
+    ///       Exclusive queues may only be consumed from by the current connection.
+    ///       Setting the 'exclusive' flag always implies 'auto-delete'.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///       If set, the queue is deleted when all consumers have finished
+    ///       using it. Last consumer can be cancelled either explicitly or because
+    ///       its channel is closed. If there was no consumer ever on the queue, it
+    ///       won't be deleted.
+    ///     
+    /// </summary>
+    bool AutoDelete { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the declaration. The syntax and semantics
+    ///       of these arguments depends on the server implementation.  This
+    ///       field is ignored if passive is 1.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.declare-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms a Declare method and confirms the name of the
+  ///     queue, essential for automatically-named queues.
+  ///   
+  /// </remarks>
+  public interface IQueueDeclareOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the name of the queue. If the server generated a queue
+    ///       name, this field contains that name.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Reports the number of messages in the queue, which will be zero
+    ///       for newly-created queues.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+    /// <summary>
+    /// 
+    ///       Reports the number of active consumers for the queue. Note that
+    ///       consumers can suspend activity (Channel.Flow) in which case they
+    ///       do not appear in this count.
+    ///     
+    /// </summary>
+    uint ConsumerCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind".</summary>
+  /// <remarks>
+  /// 
+  ///     This method binds a queue to an exchange.  Until a queue is
+  ///     bound it will not receive any messages.  In a classic messaging
+  ///     model, store-and-forward queues are bound to a dest exchange
+  ///     and subscription queues are bound to a dest_wild exchange.
+  ///   
+  /// </remarks>
+  public interface IQueueBind: IMethod {
+    /// <summary>
+    /// 
+    ///       The client provides a valid access ticket giving "active"
+    ///       access rights to the queue's access realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to bind.  If the queue name is
+    ///       empty, refers to the current queue for the channel, which is
+    ///       the last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the binding.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///       Not all exchanges use a routing key - refer to the specific
+    ///       exchange documentation.  If the routing key is empty and the queue
+    ///       name is empty, the routing key will be the current queue for the
+    ///       channel, which is the last declared queue.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///       A set of arguments for the binding.  The syntax and semantics of
+    ///       these arguments depends on the exchange class.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.bind-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the bind was successful.
+  ///   
+  /// </remarks>
+  public interface IQueueBindOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge".</summary>
+  /// <remarks>
+  /// 
+  ///     This method removes all messages from a queue.  It does not cancel
+  ///     consumers.  Purged messages are deleted without any formal "undo"
+  ///     mechanism.
+  ///   
+  /// </remarks>
+  public interface IQueuePurge: IMethod {
+    /// <summary>
+    /// 
+    ///       The access ticket must be for the access realm that holds the
+    ///       queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to purge.  If the queue name is
+    ///       empty, refers to the current queue for the channel, which is
+    ///       the last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.purge-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the purge of a queue.
+  ///   
+  /// </remarks>
+  public interface IQueuePurgeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the number of messages purged.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete".</summary>
+  /// <remarks>
+  /// 
+  ///     This method deletes a queue.  When a queue is deleted any pending
+  ///     messages are sent to a dead-letter queue if this is defined in the
+  ///     server configuration, and all consumers on the queue are cancelled.
+  ///   
+  /// </remarks>
+  public interface IQueueDelete: IMethod {
+    /// <summary>
+    /// 
+    ///       The client provides a valid access ticket giving "active"
+    ///       access rights to the queue's access realm.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to delete. If the queue name is
+    ///       empty, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the queue if it has no
+    ///       consumers. If the queue has consumers the server does does not
+    ///       delete it but raises a channel exception instead.
+    ///     
+    /// </summary>
+    bool IfUnused { get; }
+    /// <summary>
+    /// 
+    ///       If set, the server will only delete the queue if it has no
+    ///       messages. If the queue is not empty the server raises a channel
+    ///       exception.
+    ///     
+    /// </summary>
+    bool IfEmpty { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "queue.delete-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms the deletion of a queue.
+  ///   
+  /// </remarks>
+  public interface IQueueDeleteOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Reports the number of messages purged.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IBasicQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets.  The
+    ///       server will send a message in advance if it is equal to or
+    ///       smaller in size than the available prefetch size (and also falls
+    ///       into other prefetch limits). May be set to zero, meaning "no
+    ///       specific limit", although other prefetch limits may still apply.
+    ///       The prefetch-size is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       field may be used in combination with the prefetch-size field;
+    ///       a message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///       The prefetch-count is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IBasicQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IBasicConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+    /// <summary>
+    /// 
+    ///     A set of arguments for the consume. The syntax and semantics
+    ///     of these arguments depends on the server implementation.  This
+    ///     field is ignored if passive is 1.
+    ///   
+    /// </summary>
+    System.Collections.IDictionary Arguments { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     The server provides the client with a consumer tag, which is used
+  ///     by the client for methods called on the consumer at a later stage.
+  ///   
+  /// </remarks>
+  public interface IBasicConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer. This does not affect already
+  ///     delivered messages, but it does mean the server will not send any
+  ///     more messages for that consumer.  The client may receive an
+  ///     abitrary number of messages in between sending the cancel method
+  ///     and receiving the cancel-ok reply.
+  ///   
+  /// </remarks>
+  public interface IBasicCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IBasicCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a message to a specific exchange. The message
+  ///     will be routed to queues as defined by the exchange configuration
+  ///     and distributed to any active consumers when the transaction, if any,
+  ///     is committed.
+  ///   
+  /// </remarks>
+  public interface IBasicPublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IBasicReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client, via a consumer.  In
+  ///     the asynchronous message delivery model, the client starts a
+  ///     consumer using the Consume method, then the server responds with
+  ///     Deliver methods as and when messages arrive for that consumer.
+  ///   
+  /// </remarks>
+  public interface IBasicDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides a direct access to the messages in a queue
+  ///     using a synchronous dialogue that is designed for specific types of
+  ///     application where synchronous functionality is more important than
+  ///     performance.
+  ///   
+  /// </remarks>
+  public interface IBasicGet: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read"
+    ///       access rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    // (no documentation)
+    bool NoAck { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client following a get
+  ///     method.  A message delivered by 'get-ok' must be acknowledged
+  ///     unless the no-ack option was set in the get method.
+  ///   
+  /// </remarks>
+  public interface IBasicGetOk: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.  If empty, the message was published to the default
+    ///       exchange.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This field reports the number of messages pending on the queue,
+    ///       excluding the message being delivered.  Note that this figure is
+    ///       indicative, not reliable, and can change arbitrarily as messages
+    ///       are added to the queue and removed by other clients.
+    ///     
+    /// </summary>
+    uint MessageCount { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.get-empty".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the queue has no messages
+  ///     available for the client.
+  ///   
+  /// </remarks>
+  public interface IBasicGetEmpty: IMethod {
+    /// <summary>
+    /// 
+    ///       For use by cluster applications, should not be used by
+    ///       client applications.
+    ///     
+    /// </summary>
+    string ClusterId { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.ack".</summary>
+  /// <remarks>
+  /// 
+  ///     This method acknowledges one or more messages delivered via the
+  ///     Deliver or Get-Ok methods.  The client can ask to confirm a
+  ///     single message or a set of messages up to and including a specific
+  ///     message.
+  ///   
+  /// </remarks>
+  public interface IBasicAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If set to 1, the delivery tag is treated as "up to and including",
+    ///       so that the client can acknowledge multiple messages with a single
+    ///       method.  If set to zero, the delivery tag refers to a single
+    ///       message.  If the multiple field is 1, and the delivery tag is zero,
+    ///       tells the server to acknowledge all outstanding mesages.
+    ///     
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.reject".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows a client to reject a message.  It can be used to
+  ///     interrupt and cancel large incoming messages, or return untreatable
+  ///     messages to their original queue.
+  ///   
+  /// </remarks>
+  public interface IBasicReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be discarded.  If this bit
+    ///       is 1, the server will attempt to requeue the message.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.recover".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the broker to redeliver all unacknowledged messages on a
+  ///     specified channel. Zero or more messages may be redelivered.  This method
+  ///     is only allowed on non-transacted channels.
+  ///   
+  /// </remarks>
+  public interface IBasicRecover: IMethod {
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be redelivered to the original
+    ///       recipient.  If this bit is 1, the server will attempt to requeue the
+    ///       message, potentially then delivering it to an alternative subscriber.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "basic.recover-ok".</summary>
+  /// <remarks>
+  /// 
+  /// 	  This method confirms to the client that the recover succeeded.
+  ///   	  Note that if an recover fails, the server raises a channel exception.
+  ///     
+  /// </remarks>
+  public interface IBasicRecoverOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IFileQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets. May be
+    ///       set to zero, meaning "no specific limit".  Note that other
+    ///       prefetch limits may still apply. The prefetch-size is ignored
+    ///       if the no-ack option is set.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       is compatible with some file API implementations.  This field
+    ///       may be used in combination with the prefetch-size field; a
+    ///       message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///       The prefetch-count is ignored if the no-ack option is set.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IFileQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IFileConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    // (no documentation)
+    bool NoAck { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with a consumer tag which it MUST
+  ///     use in methods that work with the consumer.
+  ///   
+  /// </remarks>
+  public interface IFileConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer. This does not affect already
+  ///     delivered messages, but it does mean the server will not send any
+  ///     more messages for that consumer.
+  ///   
+  /// </remarks>
+  public interface IFileCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IFileCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests permission to start staging a message.  Staging
+  ///     means sending the message into a temporary area at the recipient end
+  ///     and then delivering the message by referring to this temporary area.
+  ///     Staging is how the protocol handles partial file transfers - if a
+  ///     message is partially staged and the connection breaks, the next time
+  ///     the sender starts to stage it, it can restart from where it left off.
+  ///   
+  /// </remarks>
+  public interface IFileOpen: IMethod {
+    /// <summary>
+    /// 
+    ///       This is the staging identifier. This is an arbitrary string chosen
+    ///       by the sender.  For staging to work correctly the sender must use
+    ///       the same staging identifier when staging the same message a second
+    ///       time after recovery from a failure.  A good choice for the staging
+    ///       identifier would be the SHA1 hash of the message properties data
+    ///       (including the original filename, revised time, etc.).
+    ///     
+    /// </summary>
+    string Identifier { get; }
+    /// <summary>
+    /// 
+    ///       The size of the content in octets.  The recipient may use this
+    ///       information to allocate or check available space in advance, to
+    ///       avoid "disk full" errors during staging of very large messages.
+    ///     
+    /// </summary>
+    ulong ContentSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.open-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the recipient is ready to accept staged
+  ///     data.  If the message was already partially-staged at a previous
+  ///     time the recipient will report the number of octets already staged.
+  ///   
+  /// </remarks>
+  public interface IFileOpenOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The amount of previously-staged content in octets.  For a new
+    ///       message this will be zero.
+    ///     
+    /// </summary>
+    ulong StagedSize { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.stage".</summary>
+  /// <remarks>
+  /// 
+  ///     This method stages the message, sending the message content to the
+  ///     recipient from the octet offset specified in the Open-Ok method.
+  ///   
+  /// </remarks>
+  public interface IFileStage: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a staged file message to a specific exchange.
+  ///     The file message will be routed to queues as defined by the exchange
+  ///     configuration and distributed to any active consumers when the
+  ///     transaction, if any, is committed.
+  ///   
+  /// </remarks>
+  public interface IFilePublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+    /// <summary>
+    /// 
+    ///       This is the staging identifier of the message to publish.  The
+    ///       message must have been staged.  Note that a client can send the
+    ///       Publish method asynchronously without waiting for staging to
+    ///       finish.
+    ///     
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IFileReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a staged file message to the client, via a
+  ///     consumer. In the asynchronous message delivery model, the client
+  ///     starts a consumer using the Consume method, then the server
+  ///     responds with Deliver methods as and when messages arrive for
+  ///     that consumer.
+  ///   
+  /// </remarks>
+  public interface IFileDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    // (no documentation)
+    bool Redelivered { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This is the staging identifier of the message to deliver.  The
+    ///       message must have been staged.  Note that a server can send the
+    ///       Deliver method asynchronously without waiting for staging to
+    ///       finish.
+    ///     
+    /// </summary>
+    string Identifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.ack".</summary>
+  /// <remarks>
+  /// 
+  ///     This method acknowledges one or more messages delivered via the
+  ///     Deliver method.  The client can ask to confirm a single message or
+  ///     a set of messages up to and including a specific message.
+  ///   
+  /// </remarks>
+  public interface IFileAck: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If set to 1, the delivery tag is treated as "up to and including",
+    ///       so that the client can acknowledge multiple messages with a single
+    ///       method.  If set to zero, the delivery tag refers to a single
+    ///       message.  If the multiple field is 1, and the delivery tag is zero,
+    ///       tells the server to acknowledge all outstanding mesages.
+    ///     
+    /// </summary>
+    bool Multiple { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "file.reject".</summary>
+  /// <remarks>
+  /// 
+  ///     This method allows a client to reject a message.  It can be used to
+  ///     return untreatable messages to their original queue.  Note that file
+  ///     content is staged before delivery, so the client will not use this
+  ///     method to interrupt delivery of a large message.
+  ///   
+  /// </remarks>
+  public interface IFileReject: IMethod {
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       If this field is zero, the message will be discarded.  If this bit
+    ///       is 1, the server will attempt to requeue the message.
+    ///     
+    /// </summary>
+    bool Requeue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos".</summary>
+  /// <remarks>
+  /// 
+  ///     This method requests a specific quality of service.  The QoS can
+  ///     be specified for the current channel or for all channels on the
+  ///     connection.  The particular properties and semantics of a qos method
+  ///     always depend on the content class semantics.  Though the qos method
+  ///     could in principle apply to both peers, it is currently meaningful
+  ///     only for the server.
+  ///   
+  /// </remarks>
+  public interface IStreamQos: IMethod {
+    /// <summary>
+    /// 
+    ///       The client can request that messages be sent in advance so that
+    ///       when the client finishes processing a message, the following
+    ///       message is already held locally, rather than needing to be sent
+    ///       down the channel.  Prefetching gives a performance improvement.
+    ///       This field specifies the prefetch window size in octets. May be
+    ///       set to zero, meaning "no specific limit".  Note that other
+    ///       prefetch limits may still apply.
+    ///     
+    /// </summary>
+    uint PrefetchSize { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a prefetch window in terms of whole messages.  This
+    ///       field may be used in combination with the prefetch-size field;
+    ///       a message will only be sent in advance if both prefetch windows
+    ///       (and those at the channel and connection level) allow it.
+    ///     
+    /// </summary>
+    ushort PrefetchCount { get; }
+    /// <summary>
+    /// 
+    ///       Specifies a desired transfer rate in octets per second. This is
+    ///       usually determined by the application that uses the streaming
+    ///       data.  A value of zero means "no limit", i.e. as rapidly as
+    ///       possible.
+    ///     
+    /// </summary>
+    uint ConsumeRate { get; }
+    /// <summary>
+    /// 
+    ///       By default the QoS settings apply to the current channel only.  If
+    ///       this field is set, they are applied to the entire connection.
+    ///     
+    /// </summary>
+    bool Global { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.qos-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tells the client that the requested QoS levels could
+  ///     be handled by the server.  The requested QoS applies to all active
+  ///     consumers until a new QoS is defined.
+  ///   
+  /// </remarks>
+  public interface IStreamQosOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume".</summary>
+  /// <remarks>
+  /// 
+  ///     This method asks the server to start a "consumer", which is a
+  ///     transient request for messages from a specific queue. Consumers
+  ///     last as long as the channel they were created on, or until the
+  ///     client cancels them.
+  ///   
+  /// </remarks>
+  public interface IStreamConsume: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "read" access
+    ///       rights to the realm for the queue.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue to consume from.  If the queue name
+    ///       is null, refers to the current queue for the channel, which is the
+    ///       last declared queue.
+    ///     
+    /// </summary>
+    string Queue { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the identifier for the consumer. The consumer tag is
+    ///       local to a connection, so two clients can use the same consumer
+    ///       tags. If this field is empty the server will generate a unique
+    ///       tag.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+    // (no documentation)
+    bool NoLocal { get; }
+    /// <summary>
+    /// 
+    ///       Request exclusive consumer access, meaning only this consumer can
+    ///       access the queue.
+    ///     
+    /// </summary>
+    bool Exclusive { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.consume-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method provides the client with a consumer tag which it may
+  ///     use in methods that work with the consumer.
+  ///   
+  /// </remarks>
+  public interface IStreamConsumeOk: IMethod {
+    /// <summary>
+    /// 
+    ///       Holds the consumer tag specified by the client or provided by
+    ///       the server.
+    ///     
+    /// </summary>
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel".</summary>
+  /// <remarks>
+  /// 
+  ///     This method cancels a consumer.  Since message delivery is
+  ///     asynchronous the client may continue to receive messages for
+  ///     a short while after canceling a consumer.  It may process or
+  ///     discard these as appropriate.
+  ///   
+  /// </remarks>
+  public interface IStreamCancel: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    /// <summary>
+    /// 
+    ///     If set, the server will not respond to the method. The client should
+    ///     not wait for a reply method.  If the server could not complete the
+    ///     method it will raise a channel or connection exception.
+    ///     
+    /// </summary>
+    bool Nowait { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.cancel-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms that the cancellation was completed.
+  ///   
+  /// </remarks>
+  public interface IStreamCancelOk: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.publish".</summary>
+  /// <remarks>
+  /// 
+  ///     This method publishes a message to a specific exchange. The message
+  ///     will be routed to queues as defined by the exchange configuration
+  ///     and distributed to any active consumers as appropriate.
+  ///   
+  /// </remarks>
+  public interface IStreamPublish: IMethod {
+    /// <summary>
+    /// 
+    ///       The client MUST provide a valid access ticket giving "write"
+    ///       access rights to the access realm for the exchange.
+    ///     
+    /// </summary>
+    ushort Ticket { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange to publish to.  The exchange
+    ///       name can be empty, meaning the default exchange.  If the exchange
+    ///       name is specified, and that exchange does not exist, the server
+    ///       will raise a channel exception.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key for the message.  The routing key is
+    ///       used for routing messages depending on the exchange configuration.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue.  If this flag is set, the server will return an
+    ///       unroutable message with a Return method.  If this flag is zero, the
+    ///       server silently drops the message.
+    ///     
+    /// </summary>
+    bool Mandatory { get; }
+    /// <summary>
+    /// 
+    ///       This flag tells the server how to react if the message cannot be
+    ///       routed to a queue consumer immediately.  If this flag is set, the
+    ///       server will return an undeliverable message with a Return method.
+    ///       If this flag is zero, the server will queue the message, but with
+    ///       no guarantee that it will ever be consumed.
+    ///     
+    /// </summary>
+    bool Immediate { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.return".</summary>
+  /// <remarks>
+  /// 
+  ///     This method returns an undeliverable message that was published
+  ///     with the "immediate" flag set, or an unroutable message published
+  ///     with the "mandatory" flag set. The reply code and text provide
+  ///     information about the reason that the message was undeliverable.
+  ///   
+  /// </remarks>
+  public interface IStreamReturn: IMethod {
+    // (no documentation)
+    ushort ReplyCode { get; }
+    // (no documentation)
+    string ReplyText { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was
+    ///       originally published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the routing key name specified when the message was
+    ///       published.
+    ///     
+    /// </summary>
+    string RoutingKey { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "stream.deliver".</summary>
+  /// <remarks>
+  /// 
+  ///     This method delivers a message to the client, via a consumer.  In
+  ///     the asynchronous message delivery model, the client starts a
+  ///     consumer using the Consume method, then the server responds with
+  ///     Deliver methods as and when messages arrive for that consumer.
+  ///   
+  /// </remarks>
+  public interface IStreamDeliver: IMethod {
+    // (no documentation)
+    string ConsumerTag { get; }
+    // (no documentation)
+    ulong DeliveryTag { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the exchange that the message was originally
+    ///       published to.
+    ///     
+    /// </summary>
+    string Exchange { get; }
+    /// <summary>
+    /// 
+    ///       Specifies the name of the queue that the message came from. Note
+    ///       that a single channel can start many consumers on different
+    ///       queues.
+    ///     
+    /// </summary>
+    string Queue { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sets the channel to use standard transactions.  The
+  ///     client must use this method at least once on a channel before
+  ///     using the Commit or Rollback methods.
+  ///   
+  /// </remarks>
+  public interface ITxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the channel was successfully
+  ///     set to use standard transactions.
+  ///   
+  /// </remarks>
+  public interface ITxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit".</summary>
+  /// <remarks>
+  /// 
+  ///     This method commits all messages published and acknowledged in
+  ///     the current transaction.  A new transaction starts immediately
+  ///     after a commit.
+  ///   
+  /// </remarks>
+  public interface ITxCommit: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.commit-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the commit succeeded.
+  ///     Note that if a commit fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface ITxCommitOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback".</summary>
+  /// <remarks>
+  /// 
+  ///     This method abandons all messages published and acknowledged in
+  ///     the current transaction.  A new transaction starts immediately
+  ///     after a rollback.
+  ///   
+  /// </remarks>
+  public interface ITxRollback: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tx.rollback-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the rollback succeeded.
+  ///     Note that if an rollback fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface ITxRollbackOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select".</summary>
+  /// <remarks>
+  /// 
+  ///     This method sets the channel to use distributed transactions.  The
+  ///     client must use this method at least once on a channel before
+  ///     using the Start method.
+  ///   
+  /// </remarks>
+  public interface IDtxSelect: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.select-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the channel was successfully
+  ///     set to use distributed transactions.
+  ///   
+  /// </remarks>
+  public interface IDtxSelectOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start".</summary>
+  /// <remarks>
+  /// 
+  ///     This method starts a new distributed transaction.  This must be
+  ///     the first method on a new channel that uses the distributed
+  ///     transaction mode, before any methods that publish or consume
+  ///     messages.
+  ///   
+  /// </remarks>
+  public interface IDtxStart: IMethod {
+    /// <summary>
+    /// 
+    ///       The distributed transaction key. This identifies the transaction
+    ///       so that the AMQP server can coordinate with the distributed
+    ///       transaction coordinator.
+    ///     
+    /// </summary>
+    string DtxIdentifier { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "dtx.start-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method confirms to the client that the transaction started.
+  ///     Note that if a start fails, the server raises a channel exception.
+  ///   
+  /// </remarks>
+  public interface IDtxStartOk: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "tunnel.request".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tunnels a block of binary data, which can be an
+  ///     encoded AMQP method or other data.  The binary data is sent
+  ///     as the content for the Tunnel.Request method.
+  ///   
+  /// </remarks>
+  public interface ITunnelRequest: IMethod {
+    /// <summary>
+    /// 
+    ///     This field table holds arbitrary meta-data that the sender needs
+    ///     to pass to the recipient.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary MetaData { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.integer".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal integer
+  ///     data.
+  ///   
+  /// </remarks>
+  public interface ITestInteger: IMethod {
+    /// <summary>
+    /// 
+    ///       An octet integer test value.
+    ///     
+    /// </summary>
+    byte Integer1 { get; }
+    /// <summary>
+    /// 
+    ///       A short integer test value.
+    ///     
+    /// </summary>
+    ushort Integer2 { get; }
+    /// <summary>
+    /// 
+    ///       A long integer test value.
+    ///     
+    /// </summary>
+    uint Integer3 { get; }
+    /// <summary>
+    /// 
+    ///       A long long integer test value.
+    ///     
+    /// </summary>
+    ulong Integer4 { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided integer
+    ///       test fields and return the result.
+    ///     
+    /// </summary>
+    byte Operation { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.integer-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of an Integer method.
+  ///   
+  /// </remarks>
+  public interface ITestIntegerOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested operation.
+    ///     
+    /// </summary>
+    ulong Result { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.string".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal string
+  ///     data.
+  ///   
+  /// </remarks>
+  public interface ITestString: IMethod {
+    /// <summary>
+    /// 
+    ///       An short string test value.
+    ///     
+    /// </summary>
+    string String1 { get; }
+    /// <summary>
+    /// 
+    ///       A long string test value.
+    ///     
+    /// </summary>
+    byte[] String2 { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided string
+    ///       test fields and return the result.
+    ///     
+    /// </summary>
+    byte Operation { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.string-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a String method.
+  ///   
+  /// </remarks>
+  public interface ITestStringOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested operation.
+    ///     
+    /// </summary>
+    byte[] Result { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.table".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal field
+  ///     table data.
+  ///   
+  /// </remarks>
+  public interface ITestTable: IMethod {
+    /// <summary>
+    /// 
+    ///       A field table of test values.
+    ///     
+    /// </summary>
+    System.Collections.IDictionary Table { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided field
+    ///       table integer values and return the result.
+    ///     
+    /// </summary>
+    byte IntegerOp { get; }
+    /// <summary>
+    /// 
+    ///       The client must execute this operation on the provided field
+    ///       table string values and return the result.
+    ///     
+    /// </summary>
+    byte StringOp { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.table-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a Table method.
+  ///   
+  /// </remarks>
+  public interface ITestTableOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The result of the tested integer operation.
+    ///     
+    /// </summary>
+    ulong IntegerResult { get; }
+    /// <summary>
+    /// 
+    ///       The result of the tested string operation.
+    ///     
+    /// </summary>
+    byte[] StringResult { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.content".</summary>
+  /// <remarks>
+  /// 
+  ///     This method tests the peer's capability to correctly marshal content.
+  ///   
+  /// </remarks>
+  public interface ITestContent: IMethod {
+  }
+  /// <summary>Autogenerated type. AMQP specification method "test.content-ok".</summary>
+  /// <remarks>
+  /// 
+  ///     This method reports the result of a Content method.  It contains the
+  ///     content checksum and echoes the original content as provided.
+  ///   
+  /// </remarks>
+  public interface ITestContentOk: IMethod {
+    /// <summary>
+    /// 
+    ///       The 32-bit checksum of the content, calculated by adding the
+    ///       content into a 32-bit accumulator.
+    ///     
+    /// </summary>
+    uint ContentChecksum { get; }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "basic"</summary>
+  /// <remarks>
+  /// 
+  ///   The Basic class provides methods that support an industry-standard
+  ///   messaging model.
+  /// 
+  /// </remarks>
+  public class BasicProperties: RabbitMQ.Client.Impl.BasicProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_deliveryMode;
+    private byte m_priority;
+    private string m_correlationId;
+    private string m_replyTo;
+    private string m_expiration;
+    private string m_messageId;
+    private AmqpTimestamp m_timestamp;
+    private string m_type;
+    private string m_userId;
+    private string m_appId;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool deliveryMode_present = false;
+    private bool priority_present = false;
+    private bool correlationId_present = false;
+    private bool replyTo_present = false;
+    private bool expiration_present = false;
+    private bool messageId_present = false;
+    private bool timestamp_present = false;
+    private bool type_present = false;
+    private bool userId_present = false;
+    private bool appId_present = false;
+    private bool clusterId_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte DeliveryMode {
+      get {
+        return m_deliveryMode;
+      }
+      set {
+        deliveryMode_present = true;
+        m_deliveryMode = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override string CorrelationId {
+      get {
+        return m_correlationId;
+      }
+      set {
+        correlationId_present = true;
+        m_correlationId = value;
+      }
+    }
+    // (no documentation)
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    // (no documentation)
+    public override string Expiration {
+      get {
+        return m_expiration;
+      }
+      set {
+        expiration_present = true;
+        m_expiration = value;
+      }
+    }
+    // (no documentation)
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    // (no documentation)
+    public override string Type {
+      get {
+        return m_type;
+      }
+      set {
+        type_present = true;
+        m_type = value;
+      }
+    }
+    // (no documentation)
+    public override string UserId {
+      get {
+        return m_userId;
+      }
+      set {
+        userId_present = true;
+        m_userId = value;
+      }
+    }
+    // (no documentation)
+    public override string AppId {
+      get {
+        return m_appId;
+      }
+      set {
+        appId_present = true;
+        m_appId = value;
+      }
+    }
+    // (no documentation)
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearDeliveryMode() { deliveryMode_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearCorrelationId() { correlationId_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearExpiration() { expiration_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearType() { type_present = false; }
+    public override void ClearUserId() { userId_present = false; }
+    public override void ClearAppId() { appId_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public BasicProperties() {}
+    public override int ProtocolClassId { get { return 60; } }
+    public override string ProtocolClassName { get { return "basic"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      deliveryMode_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      correlationId_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      expiration_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      type_present = reader.ReadPresence();
+      userId_present = reader.ReadPresence();
+      appId_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (deliveryMode_present) { m_deliveryMode = reader.ReadOctet(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (correlationId_present) { m_correlationId = reader.ReadShortstr(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (expiration_present) { m_expiration = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (type_present) { m_type = reader.ReadShortstr(); }
+      if (userId_present) { m_userId = reader.ReadShortstr(); }
+      if (appId_present) { m_appId = reader.ReadShortstr(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(deliveryMode_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(correlationId_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(expiration_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(type_present);
+      writer.WritePresence(userId_present);
+      writer.WritePresence(appId_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (deliveryMode_present) { writer.WriteOctet(m_deliveryMode); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (correlationId_present) { writer.WriteShortstr(m_correlationId); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (expiration_present) { writer.WriteShortstr(m_expiration); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (type_present) { writer.WriteShortstr(m_type); }
+      if (userId_present) { writer.WriteShortstr(m_userId); }
+      if (appId_present) { writer.WriteShortstr(m_appId); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("delivery mode="); sb.Append(deliveryMode_present ? m_deliveryMode.ToString() : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("correlation id="); sb.Append(correlationId_present ? (m_correlationId == null ? "(null)" : m_correlationId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("expiration="); sb.Append(expiration_present ? (m_expiration == null ? "(null)" : m_expiration.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("type="); sb.Append(type_present ? (m_type == null ? "(null)" : m_type.ToString()) : "_"); sb.Append(", ");
+      sb.Append("user id="); sb.Append(userId_present ? (m_userId == null ? "(null)" : m_userId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("app id="); sb.Append(appId_present ? (m_appId == null ? "(null)" : m_appId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "file"</summary>
+  /// <remarks>
+  /// 
+  ///   The file class provides methods that support reliable file transfer.
+  ///   File messages have a specific set of properties that are required for
+  ///   interoperability with file transfer applications. File messages and
+  ///   acknowledgements are subject to channel transactions.  Note that the
+  ///   file class does not provide message browsing methods; these are not
+  ///   compatible with the staging model.  Applications that need browsable
+  ///   file transfer should use Basic content and the Basic class.
+  /// 
+  /// </remarks>
+  public class FileProperties: RabbitMQ.Client.Impl.FileProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private string m_replyTo;
+    private string m_messageId;
+    private string m_filename;
+    private AmqpTimestamp m_timestamp;
+    private string m_clusterId;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool replyTo_present = false;
+    private bool messageId_present = false;
+    private bool filename_present = false;
+    private bool timestamp_present = false;
+    private bool clusterId_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override string ReplyTo {
+      get {
+        return m_replyTo;
+      }
+      set {
+        replyTo_present = true;
+        m_replyTo = value;
+      }
+    }
+    // (no documentation)
+    public override string MessageId {
+      get {
+        return m_messageId;
+      }
+      set {
+        messageId_present = true;
+        m_messageId = value;
+      }
+    }
+    // (no documentation)
+    public override string Filename {
+      get {
+        return m_filename;
+      }
+      set {
+        filename_present = true;
+        m_filename = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+    // (no documentation)
+    public override string ClusterId {
+      get {
+        return m_clusterId;
+      }
+      set {
+        clusterId_present = true;
+        m_clusterId = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearReplyTo() { replyTo_present = false; }
+    public override void ClearMessageId() { messageId_present = false; }
+    public override void ClearFilename() { filename_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+    public override void ClearClusterId() { clusterId_present = false; }
+
+    public FileProperties() {}
+    public override int ProtocolClassId { get { return 70; } }
+    public override string ProtocolClassName { get { return "file"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      replyTo_present = reader.ReadPresence();
+      messageId_present = reader.ReadPresence();
+      filename_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      clusterId_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
+      if (messageId_present) { m_messageId = reader.ReadShortstr(); }
+      if (filename_present) { m_filename = reader.ReadShortstr(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+      if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(replyTo_present);
+      writer.WritePresence(messageId_present);
+      writer.WritePresence(filename_present);
+      writer.WritePresence(timestamp_present);
+      writer.WritePresence(clusterId_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
+      if (messageId_present) { writer.WriteShortstr(m_messageId); }
+      if (filename_present) { writer.WriteShortstr(m_filename); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+      if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
+      sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
+      sb.Append("filename="); sb.Append(filename_present ? (m_filename == null ? "(null)" : m_filename.ToString()) : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
+      sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "stream"</summary>
+  /// <remarks>
+  /// 
+  ///   The stream class provides methods that support multimedia streaming.
+  ///   The stream class uses the following semantics: one message is one
+  ///   packet of data; delivery is unacknowleged and unreliable; the consumer
+  ///   can specify quality of service parameters that the server can try to
+  ///   adhere to; lower-priority messages may be discarded in favour of high
+  ///   priority messages.
+  /// 
+  /// </remarks>
+  public class StreamProperties: RabbitMQ.Client.Impl.StreamProperties {
+    private string m_contentType;
+    private string m_contentEncoding;
+    private System.Collections.IDictionary m_headers;
+    private byte m_priority;
+    private AmqpTimestamp m_timestamp;
+
+    private bool contentType_present = false;
+    private bool contentEncoding_present = false;
+    private bool headers_present = false;
+    private bool priority_present = false;
+    private bool timestamp_present = false;
+
+    // (no documentation)
+    public override string ContentType {
+      get {
+        return m_contentType;
+      }
+      set {
+        contentType_present = true;
+        m_contentType = value;
+      }
+    }
+    // (no documentation)
+    public override string ContentEncoding {
+      get {
+        return m_contentEncoding;
+      }
+      set {
+        contentEncoding_present = true;
+        m_contentEncoding = value;
+      }
+    }
+    // (no documentation)
+    public override System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public override byte Priority {
+      get {
+        return m_priority;
+      }
+      set {
+        priority_present = true;
+        m_priority = value;
+      }
+    }
+    // (no documentation)
+    public override AmqpTimestamp Timestamp {
+      get {
+        return m_timestamp;
+      }
+      set {
+        timestamp_present = true;
+        m_timestamp = value;
+      }
+    }
+
+    public override void ClearContentType() { contentType_present = false; }
+    public override void ClearContentEncoding() { contentEncoding_present = false; }
+    public override void ClearHeaders() { headers_present = false; }
+    public override void ClearPriority() { priority_present = false; }
+    public override void ClearTimestamp() { timestamp_present = false; }
+
+    public StreamProperties() {}
+    public override int ProtocolClassId { get { return 80; } }
+    public override string ProtocolClassName { get { return "stream"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      contentType_present = reader.ReadPresence();
+      contentEncoding_present = reader.ReadPresence();
+      headers_present = reader.ReadPresence();
+      priority_present = reader.ReadPresence();
+      timestamp_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (contentType_present) { m_contentType = reader.ReadShortstr(); }
+      if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (priority_present) { m_priority = reader.ReadOctet(); }
+      if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(contentType_present);
+      writer.WritePresence(contentEncoding_present);
+      writer.WritePresence(headers_present);
+      writer.WritePresence(priority_present);
+      writer.WritePresence(timestamp_present);
+      writer.FinishPresence();
+      if (contentType_present) { writer.WriteShortstr(m_contentType); }
+      if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (priority_present) { writer.WriteOctet(m_priority); }
+      if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
+      sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
+      sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "tunnel"</summary>
+  /// <remarks>
+  /// 
+  ///   The tunnel methods are used to send blocks of binary data - which
+  ///   can be serialised AMQP methods or other protocol frames - between
+  ///   AMQP peers.
+  /// 
+  /// </remarks>
+  public class TunnelProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
+    private System.Collections.IDictionary m_headers;
+    private string m_proxyName;
+    private string m_dataName;
+    private byte m_durable;
+    private byte m_broadcast;
+
+    private bool headers_present = false;
+    private bool proxyName_present = false;
+    private bool dataName_present = false;
+    private bool durable_present = false;
+    private bool broadcast_present = false;
+
+    // (no documentation)
+    public System.Collections.IDictionary Headers {
+      get {
+        return m_headers;
+      }
+      set {
+        headers_present = true;
+        m_headers = value;
+      }
+    }
+    // (no documentation)
+    public string ProxyName {
+      get {
+        return m_proxyName;
+      }
+      set {
+        proxyName_present = true;
+        m_proxyName = value;
+      }
+    }
+    // (no documentation)
+    public string DataName {
+      get {
+        return m_dataName;
+      }
+      set {
+        dataName_present = true;
+        m_dataName = value;
+      }
+    }
+    // (no documentation)
+    public byte Durable {
+      get {
+        return m_durable;
+      }
+      set {
+        durable_present = true;
+        m_durable = value;
+      }
+    }
+    // (no documentation)
+    public byte Broadcast {
+      get {
+        return m_broadcast;
+      }
+      set {
+        broadcast_present = true;
+        m_broadcast = value;
+      }
+    }
+
+    public void ClearHeaders() { headers_present = false; }
+    public void ClearProxyName() { proxyName_present = false; }
+    public void ClearDataName() { dataName_present = false; }
+    public void ClearDurable() { durable_present = false; }
+    public void ClearBroadcast() { broadcast_present = false; }
+
+    public TunnelProperties() {}
+    public override int ProtocolClassId { get { return 110; } }
+    public override string ProtocolClassName { get { return "tunnel"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      headers_present = reader.ReadPresence();
+      proxyName_present = reader.ReadPresence();
+      dataName_present = reader.ReadPresence();
+      durable_present = reader.ReadPresence();
+      broadcast_present = reader.ReadPresence();
+      reader.FinishPresence();
+      if (headers_present) { m_headers = reader.ReadTable(); }
+      if (proxyName_present) { m_proxyName = reader.ReadShortstr(); }
+      if (dataName_present) { m_dataName = reader.ReadShortstr(); }
+      if (durable_present) { m_durable = reader.ReadOctet(); }
+      if (broadcast_present) { m_broadcast = reader.ReadOctet(); }
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.WritePresence(headers_present);
+      writer.WritePresence(proxyName_present);
+      writer.WritePresence(dataName_present);
+      writer.WritePresence(durable_present);
+      writer.WritePresence(broadcast_present);
+      writer.FinishPresence();
+      if (headers_present) { writer.WriteTable(m_headers); }
+      if (proxyName_present) { writer.WriteShortstr(m_proxyName); }
+      if (dataName_present) { writer.WriteShortstr(m_dataName); }
+      if (durable_present) { writer.WriteOctet(m_durable); }
+      if (broadcast_present) { writer.WriteOctet(m_broadcast); }
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
+      sb.Append("proxy name="); sb.Append(proxyName_present ? (m_proxyName == null ? "(null)" : m_proxyName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("data name="); sb.Append(dataName_present ? (m_dataName == null ? "(null)" : m_dataName.ToString()) : "_"); sb.Append(", ");
+      sb.Append("durable="); sb.Append(durable_present ? m_durable.ToString() : "_"); sb.Append(", ");
+      sb.Append("broadcast="); sb.Append(broadcast_present ? m_broadcast.ToString() : "_");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. AMQP specification content header properties for content class "test"</summary>
+  /// <remarks>
+  /// 
+  ///   The test class provides methods for a peer to test the basic
+  ///   operational correctness of another peer. The test methods are
+  ///   intended to ensure that all peers respect at least the basic
+  ///   elements of the protocol, such as frame and content organisation
+  ///   and field types. We assume that a specially-designed peer, a
+  ///   "monitor client" would perform such tests.
+  /// 
+  /// </remarks>
+  public class TestProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
+
+
+
+
+    public TestProperties() {}
+    public override int ProtocolClassId { get { return 120; } }
+    public override string ProtocolClassName { get { return "test"; } }
+
+    public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
+      reader.FinishPresence();
+    }
+
+    public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
+      writer.FinishPresence();
+    }
+
+    public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+}
+namespace RabbitMQ.Client.Framing.Impl.v0_8qpid {
+  using RabbitMQ.Client.Framing.v0_8qpid;
+  public enum ClassId {
+    Connection = 10,
+    Channel = 20,
+    Access = 30,
+    Exchange = 40,
+    Queue = 50,
+    Basic = 60,
+    File = 70,
+    Stream = 80,
+    Tx = 90,
+    Dtx = 100,
+    Tunnel = 110,
+    Test = 120,
+    Invalid = -1
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStart: RabbitMQ.Client.Impl.MethodBase, IConnectionStart {
+    public const int ClassId = 10;
+    public const int MethodId = 10;
+
+    public byte m_versionMajor;
+    public byte m_versionMinor;
+    public System.Collections.IDictionary m_serverProperties;
+    public byte[] m_mechanisms;
+    public byte[] m_locales;
+
+    byte IConnectionStart.VersionMajor { get { return m_versionMajor; } }
+    byte IConnectionStart.VersionMinor { get { return m_versionMinor; } }
+    System.Collections.IDictionary IConnectionStart.ServerProperties { get { return m_serverProperties; } }
+    byte[] IConnectionStart.Mechanisms { get { return m_mechanisms; } }
+    byte[] IConnectionStart.Locales { get { return m_locales; } }
+
+    public ConnectionStart() {}
+    public ConnectionStart(
+      byte initVersionMajor,
+      byte initVersionMinor,
+      System.Collections.IDictionary initServerProperties,
+      byte[] initMechanisms,
+      byte[] initLocales)
+    {
+      m_versionMajor = initVersionMajor;
+      m_versionMinor = initVersionMinor;
+      m_serverProperties = initServerProperties;
+      m_mechanisms = initMechanisms;
+      m_locales = initLocales;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "connection.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_versionMajor = reader.ReadOctet();
+      m_versionMinor = reader.ReadOctet();
+      m_serverProperties = reader.ReadTable();
+      m_mechanisms = reader.ReadLongstr();
+      m_locales = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteOctet(m_versionMajor);
+      writer.WriteOctet(m_versionMinor);
+      writer.WriteTable(m_serverProperties);
+      writer.WriteLongstr(m_mechanisms);
+      writer.WriteLongstr(m_locales);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_versionMajor); sb.Append(",");
+      sb.Append(m_versionMinor); sb.Append(",");
+      sb.Append(m_serverProperties); sb.Append(",");
+      sb.Append(m_mechanisms); sb.Append(",");
+      sb.Append(m_locales);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionStartOk: RabbitMQ.Client.Impl.MethodBase, IConnectionStartOk {
+    public const int ClassId = 10;
+    public const int MethodId = 11;
+
+    public System.Collections.IDictionary m_clientProperties;
+    public string m_mechanism;
+    public byte[] m_response;
+    public string m_locale;
+
+    System.Collections.IDictionary IConnectionStartOk.ClientProperties { get { return m_clientProperties; } }
+    string IConnectionStartOk.Mechanism { get { return m_mechanism; } }
+    byte[] IConnectionStartOk.Response { get { return m_response; } }
+    string IConnectionStartOk.Locale { get { return m_locale; } }
+
+    public ConnectionStartOk() {}
+    public ConnectionStartOk(
+      System.Collections.IDictionary initClientProperties,
+      string initMechanism,
+      byte[] initResponse,
+      string initLocale)
+    {
+      m_clientProperties = initClientProperties;
+      m_mechanism = initMechanism;
+      m_response = initResponse;
+      m_locale = initLocale;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "connection.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clientProperties = reader.ReadTable();
+      m_mechanism = reader.ReadShortstr();
+      m_response = reader.ReadLongstr();
+      m_locale = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_clientProperties);
+      writer.WriteShortstr(m_mechanism);
+      writer.WriteLongstr(m_response);
+      writer.WriteShortstr(m_locale);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clientProperties); sb.Append(",");
+      sb.Append(m_mechanism); sb.Append(",");
+      sb.Append(m_response); sb.Append(",");
+      sb.Append(m_locale);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecure: RabbitMQ.Client.Impl.MethodBase, IConnectionSecure {
+    public const int ClassId = 10;
+    public const int MethodId = 20;
+
+    public byte[] m_challenge;
+
+    byte[] IConnectionSecure.Challenge { get { return m_challenge; } }
+
+    public ConnectionSecure() {}
+    public ConnectionSecure(
+      byte[] initChallenge)
+    {
+      m_challenge = initChallenge;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "connection.secure"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_challenge = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_challenge);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_challenge);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionSecureOk: RabbitMQ.Client.Impl.MethodBase, IConnectionSecureOk {
+    public const int ClassId = 10;
+    public const int MethodId = 21;
+
+    public byte[] m_response;
+
+    byte[] IConnectionSecureOk.Response { get { return m_response; } }
+
+    public ConnectionSecureOk() {}
+    public ConnectionSecureOk(
+      byte[] initResponse)
+    {
+      m_response = initResponse;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "connection.secure-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_response = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_response);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_response);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTune: RabbitMQ.Client.Impl.MethodBase, IConnectionTune {
+    public const int ClassId = 10;
+    public const int MethodId = 30;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTune.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTune.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTune.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTune() {}
+    public ConnectionTune(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "connection.tune"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionTuneOk: RabbitMQ.Client.Impl.MethodBase, IConnectionTuneOk {
+    public const int ClassId = 10;
+    public const int MethodId = 31;
+
+    public ushort m_channelMax;
+    public uint m_frameMax;
+    public ushort m_heartbeat;
+
+    ushort IConnectionTuneOk.ChannelMax { get { return m_channelMax; } }
+    uint IConnectionTuneOk.FrameMax { get { return m_frameMax; } }
+    ushort IConnectionTuneOk.Heartbeat { get { return m_heartbeat; } }
+
+    public ConnectionTuneOk() {}
+    public ConnectionTuneOk(
+      ushort initChannelMax,
+      uint initFrameMax,
+      ushort initHeartbeat)
+    {
+      m_channelMax = initChannelMax;
+      m_frameMax = initFrameMax;
+      m_heartbeat = initHeartbeat;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "connection.tune-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_channelMax = reader.ReadShort();
+      m_frameMax = reader.ReadLong();
+      m_heartbeat = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_channelMax);
+      writer.WriteLong(m_frameMax);
+      writer.WriteShort(m_heartbeat);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_channelMax); sb.Append(",");
+      sb.Append(m_frameMax); sb.Append(",");
+      sb.Append(m_heartbeat);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpen: RabbitMQ.Client.Impl.MethodBase, IConnectionOpen {
+    public const int ClassId = 10;
+    public const int MethodId = 40;
+
+    public string m_virtualHost;
+    public string m_capabilities;
+    public bool m_insist;
+
+    string IConnectionOpen.VirtualHost { get { return m_virtualHost; } }
+    string IConnectionOpen.Capabilities { get { return m_capabilities; } }
+    bool IConnectionOpen.Insist { get { return m_insist; } }
+
+    public ConnectionOpen() {}
+    public ConnectionOpen(
+      string initVirtualHost,
+      string initCapabilities,
+      bool initInsist)
+    {
+      m_virtualHost = initVirtualHost;
+      m_capabilities = initCapabilities;
+      m_insist = initInsist;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "connection.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_virtualHost = reader.ReadShortstr();
+      m_capabilities = reader.ReadShortstr();
+      m_insist = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_virtualHost);
+      writer.WriteShortstr(m_capabilities);
+      writer.WriteBit(m_insist);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_virtualHost); sb.Append(",");
+      sb.Append(m_capabilities); sb.Append(",");
+      sb.Append(m_insist);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionOpenOk: RabbitMQ.Client.Impl.MethodBase, IConnectionOpenOk {
+    public const int ClassId = 10;
+    public const int MethodId = 41;
+
+    public string m_knownHosts;
+
+    string IConnectionOpenOk.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionOpenOk() {}
+    public ConnectionOpenOk(
+      string initKnownHosts)
+    {
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "connection.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionRedirect: RabbitMQ.Client.Impl.MethodBase, IConnectionRedirect {
+    public const int ClassId = 10;
+    public const int MethodId = 50;
+
+    public string m_host;
+    public string m_knownHosts;
+
+    string IConnectionRedirect.Host { get { return m_host; } }
+    string IConnectionRedirect.KnownHosts { get { return m_knownHosts; } }
+
+    public ConnectionRedirect() {}
+    public ConnectionRedirect(
+      string initHost,
+      string initKnownHosts)
+    {
+      m_host = initHost;
+      m_knownHosts = initKnownHosts;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "connection.redirect"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_host = reader.ReadShortstr();
+      m_knownHosts = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_host);
+      writer.WriteShortstr(m_knownHosts);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_host); sb.Append(",");
+      sb.Append(m_knownHosts);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionClose: RabbitMQ.Client.Impl.MethodBase, IConnectionClose {
+    public const int ClassId = 10;
+    public const int MethodId = 60;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IConnectionClose.ReplyCode { get { return m_replyCode; } }
+    string IConnectionClose.ReplyText { get { return m_replyText; } }
+    ushort IConnectionClose.ClassId { get { return m_classId; } }
+    ushort IConnectionClose.MethodId { get { return m_methodId; } }
+
+    public ConnectionClose() {}
+    public ConnectionClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "connection.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ConnectionCloseOk: RabbitMQ.Client.Impl.MethodBase, IConnectionCloseOk {
+    public const int ClassId = 10;
+    public const int MethodId = 61;
+
+
+
+    public ConnectionCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 10; } }
+    public override int ProtocolMethodId { get { return 61; } }
+    public override string ProtocolMethodName { get { return "connection.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpen: RabbitMQ.Client.Impl.MethodBase, IChannelOpen {
+    public const int ClassId = 20;
+    public const int MethodId = 10;
+
+    public string m_outOfBand;
+
+    string IChannelOpen.OutOfBand { get { return m_outOfBand; } }
+
+    public ChannelOpen() {}
+    public ChannelOpen(
+      string initOutOfBand)
+    {
+      m_outOfBand = initOutOfBand;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "channel.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_outOfBand = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_outOfBand);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_outOfBand);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelOpenOk: RabbitMQ.Client.Impl.MethodBase, IChannelOpenOk {
+    public const int ClassId = 20;
+    public const int MethodId = 11;
+
+
+
+    public ChannelOpenOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "channel.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlow: RabbitMQ.Client.Impl.MethodBase, IChannelFlow {
+    public const int ClassId = 20;
+    public const int MethodId = 20;
+
+    public bool m_active;
+
+    bool IChannelFlow.Active { get { return m_active; } }
+
+    public ChannelFlow() {}
+    public ChannelFlow(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "channel.flow"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelFlowOk: RabbitMQ.Client.Impl.MethodBase, IChannelFlowOk {
+    public const int ClassId = 20;
+    public const int MethodId = 21;
+
+    public bool m_active;
+
+    bool IChannelFlowOk.Active { get { return m_active; } }
+
+    public ChannelFlowOk() {}
+    public ChannelFlowOk(
+      bool initActive)
+    {
+      m_active = initActive;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "channel.flow-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_active = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_active);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_active);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelAlert: RabbitMQ.Client.Impl.MethodBase, IChannelAlert {
+    public const int ClassId = 20;
+    public const int MethodId = 30;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public System.Collections.IDictionary m_details;
+
+    ushort IChannelAlert.ReplyCode { get { return m_replyCode; } }
+    string IChannelAlert.ReplyText { get { return m_replyText; } }
+    System.Collections.IDictionary IChannelAlert.Details { get { return m_details; } }
+
+    public ChannelAlert() {}
+    public ChannelAlert(
+      ushort initReplyCode,
+      string initReplyText,
+      System.Collections.IDictionary initDetails)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_details = initDetails;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "channel.alert"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_details = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteTable(m_details);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_details);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelClose: RabbitMQ.Client.Impl.MethodBase, IChannelClose {
+    public const int ClassId = 20;
+    public const int MethodId = 40;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public ushort m_classId;
+    public ushort m_methodId;
+
+    ushort IChannelClose.ReplyCode { get { return m_replyCode; } }
+    string IChannelClose.ReplyText { get { return m_replyText; } }
+    ushort IChannelClose.ClassId { get { return m_classId; } }
+    ushort IChannelClose.MethodId { get { return m_methodId; } }
+
+    public ChannelClose() {}
+    public ChannelClose(
+      ushort initReplyCode,
+      string initReplyText,
+      ushort initClassId,
+      ushort initMethodId)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_classId = initClassId;
+      m_methodId = initMethodId;
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "channel.close"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_classId = reader.ReadShort();
+      m_methodId = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShort(m_classId);
+      writer.WriteShort(m_methodId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_classId); sb.Append(",");
+      sb.Append(m_methodId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ChannelCloseOk: RabbitMQ.Client.Impl.MethodBase, IChannelCloseOk {
+    public const int ClassId = 20;
+    public const int MethodId = 41;
+
+
+
+    public ChannelCloseOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 20; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "channel.close-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequest: RabbitMQ.Client.Impl.MethodBase, IAccessRequest {
+    public const int ClassId = 30;
+    public const int MethodId = 10;
+
+    public string m_realm;
+    public bool m_exclusive;
+    public bool m_passive;
+    public bool m_active;
+    public bool m_write;
+    public bool m_read;
+
+    string IAccessRequest.Realm { get { return m_realm; } }
+    bool IAccessRequest.Exclusive { get { return m_exclusive; } }
+    bool IAccessRequest.Passive { get { return m_passive; } }
+    bool IAccessRequest.Active { get { return m_active; } }
+    bool IAccessRequest.Write { get { return m_write; } }
+    bool IAccessRequest.Read { get { return m_read; } }
+
+    public AccessRequest() {}
+    public AccessRequest(
+      string initRealm,
+      bool initExclusive,
+      bool initPassive,
+      bool initActive,
+      bool initWrite,
+      bool initRead)
+    {
+      m_realm = initRealm;
+      m_exclusive = initExclusive;
+      m_passive = initPassive;
+      m_active = initActive;
+      m_write = initWrite;
+      m_read = initRead;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "access.request"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_realm = reader.ReadShortstr();
+      m_exclusive = reader.ReadBit();
+      m_passive = reader.ReadBit();
+      m_active = reader.ReadBit();
+      m_write = reader.ReadBit();
+      m_read = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_realm);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_active);
+      writer.WriteBit(m_write);
+      writer.WriteBit(m_read);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_realm); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_active); sb.Append(",");
+      sb.Append(m_write); sb.Append(",");
+      sb.Append(m_read);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class AccessRequestOk: RabbitMQ.Client.Impl.MethodBase, IAccessRequestOk {
+    public const int ClassId = 30;
+    public const int MethodId = 11;
+
+    public ushort m_ticket;
+
+    ushort IAccessRequestOk.Ticket { get { return m_ticket; } }
+
+    public AccessRequestOk() {}
+    public AccessRequestOk(
+      ushort initTicket)
+    {
+      m_ticket = initTicket;
+    }
+
+    public override int ProtocolClassId { get { return 30; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "access.request-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclare: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclare {
+    public const int ClassId = 40;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_type;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_autoDelete;
+    public bool m_internal;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IExchangeDeclare.Ticket { get { return m_ticket; } }
+    string IExchangeDeclare.Exchange { get { return m_exchange; } }
+    string IExchangeDeclare.Type { get { return m_type; } }
+    bool IExchangeDeclare.Passive { get { return m_passive; } }
+    bool IExchangeDeclare.Durable { get { return m_durable; } }
+    bool IExchangeDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IExchangeDeclare.Internal { get { return m_internal; } }
+    bool IExchangeDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IExchangeDeclare.Arguments { get { return m_arguments; } }
+
+    public ExchangeDeclare() {}
+    public ExchangeDeclare(
+      ushort initTicket,
+      string initExchange,
+      string initType,
+      bool initPassive,
+      bool initDurable,
+      bool initAutoDelete,
+      bool initInternal,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_type = initType;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_autoDelete = initAutoDelete;
+      m_internal = initInternal;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "exchange.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_type = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_internal = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_type);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_internal);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_type); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_internal); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeclareOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclareOk {
+    public const int ClassId = 40;
+    public const int MethodId = 11;
+
+
+
+    public ExchangeDeclareOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "exchange.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDelete: RabbitMQ.Client.Impl.MethodBase, IExchangeDelete {
+    public const int ClassId = 40;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public bool m_ifUnused;
+    public bool m_nowait;
+
+    ushort IExchangeDelete.Ticket { get { return m_ticket; } }
+    string IExchangeDelete.Exchange { get { return m_exchange; } }
+    bool IExchangeDelete.IfUnused { get { return m_ifUnused; } }
+    bool IExchangeDelete.Nowait { get { return m_nowait; } }
+
+    public ExchangeDelete() {}
+    public ExchangeDelete(
+      ushort initTicket,
+      string initExchange,
+      bool initIfUnused,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_ifUnused = initIfUnused;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "exchange.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeDeleteOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeleteOk {
+    public const int ClassId = 40;
+    public const int MethodId = 21;
+
+
+
+    public ExchangeDeleteOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "exchange.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeBound: RabbitMQ.Client.Impl.MethodBase, IExchangeBound {
+    public const int ClassId = 40;
+    public const int MethodId = 22;
+
+    public string m_exchange;
+    public string m_routingKey;
+    public string m_queue;
+
+    string IExchangeBound.Exchange { get { return m_exchange; } }
+    string IExchangeBound.RoutingKey { get { return m_routingKey; } }
+    string IExchangeBound.Queue { get { return m_queue; } }
+
+    public ExchangeBound() {}
+    public ExchangeBound(
+      string initExchange,
+      string initRoutingKey,
+      string initQueue)
+    {
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_queue = initQueue;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 22; } }
+    public override string ProtocolMethodName { get { return "exchange.bound"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_queue = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteShortstr(m_queue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_queue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class ExchangeBoundOk: RabbitMQ.Client.Impl.MethodBase, IExchangeBoundOk {
+    public const int ClassId = 40;
+    public const int MethodId = 23;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+
+    ushort IExchangeBoundOk.ReplyCode { get { return m_replyCode; } }
+    string IExchangeBoundOk.ReplyText { get { return m_replyText; } }
+
+    public ExchangeBoundOk() {}
+    public ExchangeBoundOk(
+      ushort initReplyCode,
+      string initReplyText)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+    }
+
+    public override int ProtocolClassId { get { return 40; } }
+    public override int ProtocolMethodId { get { return 23; } }
+    public override string ProtocolMethodName { get { return "exchange.bound-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclare: RabbitMQ.Client.Impl.MethodBase, IQueueDeclare {
+    public const int ClassId = 50;
+    public const int MethodId = 10;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_passive;
+    public bool m_durable;
+    public bool m_exclusive;
+    public bool m_autoDelete;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueDeclare.Ticket { get { return m_ticket; } }
+    string IQueueDeclare.Queue { get { return m_queue; } }
+    bool IQueueDeclare.Passive { get { return m_passive; } }
+    bool IQueueDeclare.Durable { get { return m_durable; } }
+    bool IQueueDeclare.Exclusive { get { return m_exclusive; } }
+    bool IQueueDeclare.AutoDelete { get { return m_autoDelete; } }
+    bool IQueueDeclare.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueDeclare.Arguments { get { return m_arguments; } }
+
+    public QueueDeclare() {}
+    public QueueDeclare(
+      ushort initTicket,
+      string initQueue,
+      bool initPassive,
+      bool initDurable,
+      bool initExclusive,
+      bool initAutoDelete,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_passive = initPassive;
+      m_durable = initDurable;
+      m_exclusive = initExclusive;
+      m_autoDelete = initAutoDelete;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "queue.declare"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_passive = reader.ReadBit();
+      m_durable = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_autoDelete = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_passive);
+      writer.WriteBit(m_durable);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_autoDelete);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_passive); sb.Append(",");
+      sb.Append(m_durable); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_autoDelete); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeclareOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeclareOk {
+    public const int ClassId = 50;
+    public const int MethodId = 11;
+
+    public string m_queue;
+    public uint m_messageCount;
+    public uint m_consumerCount;
+
+    string IQueueDeclareOk.Queue { get { return m_queue; } }
+    uint IQueueDeclareOk.MessageCount { get { return m_messageCount; } }
+    uint IQueueDeclareOk.ConsumerCount { get { return m_consumerCount; } }
+
+    public QueueDeclareOk() {}
+    public QueueDeclareOk(
+      string initQueue,
+      uint initMessageCount,
+      uint initConsumerCount)
+    {
+      m_queue = initQueue;
+      m_messageCount = initMessageCount;
+      m_consumerCount = initConsumerCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "queue.declare-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_queue = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+      m_consumerCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_queue);
+      writer.WriteLong(m_messageCount);
+      writer.WriteLong(m_consumerCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_messageCount); sb.Append(",");
+      sb.Append(m_consumerCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBind: RabbitMQ.Client.Impl.MethodBase, IQueueBind {
+    public const int ClassId = 50;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IQueueBind.Ticket { get { return m_ticket; } }
+    string IQueueBind.Queue { get { return m_queue; } }
+    string IQueueBind.Exchange { get { return m_exchange; } }
+    string IQueueBind.RoutingKey { get { return m_routingKey; } }
+    bool IQueueBind.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IQueueBind.Arguments { get { return m_arguments; } }
+
+    public QueueBind() {}
+    public QueueBind(
+      ushort initTicket,
+      string initQueue,
+      string initExchange,
+      string initRoutingKey,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "queue.bind"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueBindOk: RabbitMQ.Client.Impl.MethodBase, IQueueBindOk {
+    public const int ClassId = 50;
+    public const int MethodId = 21;
+
+
+
+    public QueueBindOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "queue.bind-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurge: RabbitMQ.Client.Impl.MethodBase, IQueuePurge {
+    public const int ClassId = 50;
+    public const int MethodId = 30;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_nowait;
+
+    ushort IQueuePurge.Ticket { get { return m_ticket; } }
+    string IQueuePurge.Queue { get { return m_queue; } }
+    bool IQueuePurge.Nowait { get { return m_nowait; } }
+
+    public QueuePurge() {}
+    public QueuePurge(
+      ushort initTicket,
+      string initQueue,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "queue.purge"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueuePurgeOk: RabbitMQ.Client.Impl.MethodBase, IQueuePurgeOk {
+    public const int ClassId = 50;
+    public const int MethodId = 31;
+
+    public uint m_messageCount;
+
+    uint IQueuePurgeOk.MessageCount { get { return m_messageCount; } }
+
+    public QueuePurgeOk() {}
+    public QueuePurgeOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "queue.purge-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDelete: RabbitMQ.Client.Impl.MethodBase, IQueueDelete {
+    public const int ClassId = 50;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_ifUnused;
+    public bool m_ifEmpty;
+    public bool m_nowait;
+
+    ushort IQueueDelete.Ticket { get { return m_ticket; } }
+    string IQueueDelete.Queue { get { return m_queue; } }
+    bool IQueueDelete.IfUnused { get { return m_ifUnused; } }
+    bool IQueueDelete.IfEmpty { get { return m_ifEmpty; } }
+    bool IQueueDelete.Nowait { get { return m_nowait; } }
+
+    public QueueDelete() {}
+    public QueueDelete(
+      ushort initTicket,
+      string initQueue,
+      bool initIfUnused,
+      bool initIfEmpty,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_ifUnused = initIfUnused;
+      m_ifEmpty = initIfEmpty;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "queue.delete"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_ifUnused = reader.ReadBit();
+      m_ifEmpty = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_ifUnused);
+      writer.WriteBit(m_ifEmpty);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_ifUnused); sb.Append(",");
+      sb.Append(m_ifEmpty); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class QueueDeleteOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeleteOk {
+    public const int ClassId = 50;
+    public const int MethodId = 41;
+
+    public uint m_messageCount;
+
+    uint IQueueDeleteOk.MessageCount { get { return m_messageCount; } }
+
+    public QueueDeleteOk() {}
+    public QueueDeleteOk(
+      uint initMessageCount)
+    {
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 50; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "queue.delete-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQos: RabbitMQ.Client.Impl.MethodBase, IBasicQos {
+    public const int ClassId = 60;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IBasicQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IBasicQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IBasicQos.Global { get { return m_global; } }
+
+    public BasicQos() {}
+    public BasicQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "basic.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicQosOk: RabbitMQ.Client.Impl.MethodBase, IBasicQosOk {
+    public const int ClassId = 60;
+    public const int MethodId = 11;
+
+
+
+    public BasicQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "basic.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsume: RabbitMQ.Client.Impl.MethodBase, IBasicConsume {
+    public const int ClassId = 60;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+    public System.Collections.IDictionary m_arguments;
+
+    ushort IBasicConsume.Ticket { get { return m_ticket; } }
+    string IBasicConsume.Queue { get { return m_queue; } }
+    string IBasicConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicConsume.NoLocal { get { return m_noLocal; } }
+    bool IBasicConsume.NoAck { get { return m_noAck; } }
+    bool IBasicConsume.Exclusive { get { return m_exclusive; } }
+    bool IBasicConsume.Nowait { get { return m_nowait; } }
+    System.Collections.IDictionary IBasicConsume.Arguments { get { return m_arguments; } }
+
+    public BasicConsume() {}
+    public BasicConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait,
+      System.Collections.IDictionary initArguments)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+      m_arguments = initArguments;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "basic.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+      m_arguments = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+      writer.WriteTable(m_arguments);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait); sb.Append(",");
+      sb.Append(m_arguments);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicConsumeOk: RabbitMQ.Client.Impl.MethodBase, IBasicConsumeOk {
+    public const int ClassId = 60;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IBasicConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicConsumeOk() {}
+    public BasicConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "basic.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancel: RabbitMQ.Client.Impl.MethodBase, IBasicCancel {
+    public const int ClassId = 60;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IBasicCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IBasicCancel.Nowait { get { return m_nowait; } }
+
+    public BasicCancel() {}
+    public BasicCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "basic.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicCancelOk: RabbitMQ.Client.Impl.MethodBase, IBasicCancelOk {
+    public const int ClassId = 60;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IBasicCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public BasicCancelOk() {}
+    public BasicCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "basic.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicPublish: RabbitMQ.Client.Impl.MethodBase, IBasicPublish {
+    public const int ClassId = 60;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IBasicPublish.Ticket { get { return m_ticket; } }
+    string IBasicPublish.Exchange { get { return m_exchange; } }
+    string IBasicPublish.RoutingKey { get { return m_routingKey; } }
+    bool IBasicPublish.Mandatory { get { return m_mandatory; } }
+    bool IBasicPublish.Immediate { get { return m_immediate; } }
+
+    public BasicPublish() {}
+    public BasicPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "basic.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReturn: RabbitMQ.Client.Impl.MethodBase, IBasicReturn {
+    public const int ClassId = 60;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IBasicReturn.ReplyCode { get { return m_replyCode; } }
+    string IBasicReturn.ReplyText { get { return m_replyText; } }
+    string IBasicReturn.Exchange { get { return m_exchange; } }
+    string IBasicReturn.RoutingKey { get { return m_routingKey; } }
+
+    public BasicReturn() {}
+    public BasicReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "basic.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicDeliver: RabbitMQ.Client.Impl.MethodBase, IBasicDeliver {
+    public const int ClassId = 60;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+
+    string IBasicDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IBasicDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicDeliver.Redelivered { get { return m_redelivered; } }
+    string IBasicDeliver.Exchange { get { return m_exchange; } }
+    string IBasicDeliver.RoutingKey { get { return m_routingKey; } }
+
+    public BasicDeliver() {}
+    public BasicDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "basic.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGet: RabbitMQ.Client.Impl.MethodBase, IBasicGet {
+    public const int ClassId = 60;
+    public const int MethodId = 70;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public bool m_noAck;
+
+    ushort IBasicGet.Ticket { get { return m_ticket; } }
+    string IBasicGet.Queue { get { return m_queue; } }
+    bool IBasicGet.NoAck { get { return m_noAck; } }
+
+    public BasicGet() {}
+    public BasicGet(
+      ushort initTicket,
+      string initQueue,
+      bool initNoAck)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_noAck = initNoAck;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "basic.get"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_noAck = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteBit(m_noAck);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_noAck);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetOk: RabbitMQ.Client.Impl.MethodBase, IBasicGetOk {
+    public const int ClassId = 60;
+    public const int MethodId = 71;
+
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public uint m_messageCount;
+
+    ulong IBasicGetOk.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicGetOk.Redelivered { get { return m_redelivered; } }
+    string IBasicGetOk.Exchange { get { return m_exchange; } }
+    string IBasicGetOk.RoutingKey { get { return m_routingKey; } }
+    uint IBasicGetOk.MessageCount { get { return m_messageCount; } }
+
+    public BasicGetOk() {}
+    public BasicGetOk(
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      uint initMessageCount)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_messageCount = initMessageCount;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 71; } }
+    public override string ProtocolMethodName { get { return "basic.get-ok"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_messageCount = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteLong(m_messageCount);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_messageCount);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicGetEmpty: RabbitMQ.Client.Impl.MethodBase, IBasicGetEmpty {
+    public const int ClassId = 60;
+    public const int MethodId = 72;
+
+    public string m_clusterId;
+
+    string IBasicGetEmpty.ClusterId { get { return m_clusterId; } }
+
+    public BasicGetEmpty() {}
+    public BasicGetEmpty(
+      string initClusterId)
+    {
+      m_clusterId = initClusterId;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 72; } }
+    public override string ProtocolMethodName { get { return "basic.get-empty"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_clusterId = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_clusterId);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_clusterId);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicAck: RabbitMQ.Client.Impl.MethodBase, IBasicAck {
+    public const int ClassId = 60;
+    public const int MethodId = 80;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IBasicAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicAck.Multiple { get { return m_multiple; } }
+
+    public BasicAck() {}
+    public BasicAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "basic.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicReject: RabbitMQ.Client.Impl.MethodBase, IBasicReject {
+    public const int ClassId = 60;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IBasicReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IBasicReject.Requeue { get { return m_requeue; } }
+
+    public BasicReject() {}
+    public BasicReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "basic.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicRecover: RabbitMQ.Client.Impl.MethodBase, IBasicRecover {
+    public const int ClassId = 60;
+    public const int MethodId = 100;
+
+    public bool m_requeue;
+
+    bool IBasicRecover.Requeue { get { return m_requeue; } }
+
+    public BasicRecover() {}
+    public BasicRecover(
+      bool initRequeue)
+    {
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "basic.recover"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class BasicRecoverOk: RabbitMQ.Client.Impl.MethodBase, IBasicRecoverOk {
+    public const int ClassId = 60;
+    public const int MethodId = 101;
+
+
+
+    public BasicRecoverOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 60; } }
+    public override int ProtocolMethodId { get { return 101; } }
+    public override string ProtocolMethodName { get { return "basic.recover-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQos: RabbitMQ.Client.Impl.MethodBase, IFileQos {
+    public const int ClassId = 70;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public bool m_global;
+
+    uint IFileQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IFileQos.PrefetchCount { get { return m_prefetchCount; } }
+    bool IFileQos.Global { get { return m_global; } }
+
+    public FileQos() {}
+    public FileQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "file.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileQosOk: RabbitMQ.Client.Impl.MethodBase, IFileQosOk {
+    public const int ClassId = 70;
+    public const int MethodId = 11;
+
+
+
+    public FileQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "file.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsume: RabbitMQ.Client.Impl.MethodBase, IFileConsume {
+    public const int ClassId = 70;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_noAck;
+    public bool m_exclusive;
+    public bool m_nowait;
+
+    ushort IFileConsume.Ticket { get { return m_ticket; } }
+    string IFileConsume.Queue { get { return m_queue; } }
+    string IFileConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileConsume.NoLocal { get { return m_noLocal; } }
+    bool IFileConsume.NoAck { get { return m_noAck; } }
+    bool IFileConsume.Exclusive { get { return m_exclusive; } }
+    bool IFileConsume.Nowait { get { return m_nowait; } }
+
+    public FileConsume() {}
+    public FileConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initNoAck,
+      bool initExclusive,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_noAck = initNoAck;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "file.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_noAck = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_noAck);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_noAck); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileConsumeOk: RabbitMQ.Client.Impl.MethodBase, IFileConsumeOk {
+    public const int ClassId = 70;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IFileConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileConsumeOk() {}
+    public FileConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "file.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancel: RabbitMQ.Client.Impl.MethodBase, IFileCancel {
+    public const int ClassId = 70;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IFileCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IFileCancel.Nowait { get { return m_nowait; } }
+
+    public FileCancel() {}
+    public FileCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "file.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileCancelOk: RabbitMQ.Client.Impl.MethodBase, IFileCancelOk {
+    public const int ClassId = 70;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IFileCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public FileCancelOk() {}
+    public FileCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "file.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpen: RabbitMQ.Client.Impl.MethodBase, IFileOpen {
+    public const int ClassId = 70;
+    public const int MethodId = 40;
+
+    public string m_identifier;
+    public ulong m_contentSize;
+
+    string IFileOpen.Identifier { get { return m_identifier; } }
+    ulong IFileOpen.ContentSize { get { return m_contentSize; } }
+
+    public FileOpen() {}
+    public FileOpen(
+      string initIdentifier,
+      ulong initContentSize)
+    {
+      m_identifier = initIdentifier;
+      m_contentSize = initContentSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "file.open"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_identifier = reader.ReadShortstr();
+      m_contentSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_identifier);
+      writer.WriteLonglong(m_contentSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_identifier); sb.Append(",");
+      sb.Append(m_contentSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileOpenOk: RabbitMQ.Client.Impl.MethodBase, IFileOpenOk {
+    public const int ClassId = 70;
+    public const int MethodId = 41;
+
+    public ulong m_stagedSize;
+
+    ulong IFileOpenOk.StagedSize { get { return m_stagedSize; } }
+
+    public FileOpenOk() {}
+    public FileOpenOk(
+      ulong initStagedSize)
+    {
+      m_stagedSize = initStagedSize;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "file.open-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_stagedSize = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_stagedSize);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_stagedSize);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileStage: RabbitMQ.Client.Impl.MethodBase, IFileStage {
+    public const int ClassId = 70;
+    public const int MethodId = 50;
+
+
+
+    public FileStage(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "file.stage"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FilePublish: RabbitMQ.Client.Impl.MethodBase, IFilePublish {
+    public const int ClassId = 70;
+    public const int MethodId = 60;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+    public string m_identifier;
+
+    ushort IFilePublish.Ticket { get { return m_ticket; } }
+    string IFilePublish.Exchange { get { return m_exchange; } }
+    string IFilePublish.RoutingKey { get { return m_routingKey; } }
+    bool IFilePublish.Mandatory { get { return m_mandatory; } }
+    bool IFilePublish.Immediate { get { return m_immediate; } }
+    string IFilePublish.Identifier { get { return m_identifier; } }
+
+    public FilePublish() {}
+    public FilePublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate,
+      string initIdentifier)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "file.publish"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReturn: RabbitMQ.Client.Impl.MethodBase, IFileReturn {
+    public const int ClassId = 70;
+    public const int MethodId = 70;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IFileReturn.ReplyCode { get { return m_replyCode; } }
+    string IFileReturn.ReplyText { get { return m_replyText; } }
+    string IFileReturn.Exchange { get { return m_exchange; } }
+    string IFileReturn.RoutingKey { get { return m_routingKey; } }
+
+    public FileReturn() {}
+    public FileReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 70; } }
+    public override string ProtocolMethodName { get { return "file.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileDeliver: RabbitMQ.Client.Impl.MethodBase, IFileDeliver {
+    public const int ClassId = 70;
+    public const int MethodId = 80;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public bool m_redelivered;
+    public string m_exchange;
+    public string m_routingKey;
+    public string m_identifier;
+
+    string IFileDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IFileDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileDeliver.Redelivered { get { return m_redelivered; } }
+    string IFileDeliver.Exchange { get { return m_exchange; } }
+    string IFileDeliver.RoutingKey { get { return m_routingKey; } }
+    string IFileDeliver.Identifier { get { return m_identifier; } }
+
+    public FileDeliver() {}
+    public FileDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      bool initRedelivered,
+      string initExchange,
+      string initRoutingKey,
+      string initIdentifier)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_redelivered = initRedelivered;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_identifier = initIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 80; } }
+    public override string ProtocolMethodName { get { return "file.deliver"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_redelivered = reader.ReadBit();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_identifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_redelivered);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteShortstr(m_identifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_redelivered); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_identifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileAck: RabbitMQ.Client.Impl.MethodBase, IFileAck {
+    public const int ClassId = 70;
+    public const int MethodId = 90;
+
+    public ulong m_deliveryTag;
+    public bool m_multiple;
+
+    ulong IFileAck.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileAck.Multiple { get { return m_multiple; } }
+
+    public FileAck() {}
+    public FileAck(
+      ulong initDeliveryTag,
+      bool initMultiple)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_multiple = initMultiple;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 90; } }
+    public override string ProtocolMethodName { get { return "file.ack"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_multiple = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_multiple);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_multiple);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class FileReject: RabbitMQ.Client.Impl.MethodBase, IFileReject {
+    public const int ClassId = 70;
+    public const int MethodId = 100;
+
+    public ulong m_deliveryTag;
+    public bool m_requeue;
+
+    ulong IFileReject.DeliveryTag { get { return m_deliveryTag; } }
+    bool IFileReject.Requeue { get { return m_requeue; } }
+
+    public FileReject() {}
+    public FileReject(
+      ulong initDeliveryTag,
+      bool initRequeue)
+    {
+      m_deliveryTag = initDeliveryTag;
+      m_requeue = initRequeue;
+    }
+
+    public override int ProtocolClassId { get { return 70; } }
+    public override int ProtocolMethodId { get { return 100; } }
+    public override string ProtocolMethodName { get { return "file.reject"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_deliveryTag = reader.ReadLonglong();
+      m_requeue = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteBit(m_requeue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_requeue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQos: RabbitMQ.Client.Impl.MethodBase, IStreamQos {
+    public const int ClassId = 80;
+    public const int MethodId = 10;
+
+    public uint m_prefetchSize;
+    public ushort m_prefetchCount;
+    public uint m_consumeRate;
+    public bool m_global;
+
+    uint IStreamQos.PrefetchSize { get { return m_prefetchSize; } }
+    ushort IStreamQos.PrefetchCount { get { return m_prefetchCount; } }
+    uint IStreamQos.ConsumeRate { get { return m_consumeRate; } }
+    bool IStreamQos.Global { get { return m_global; } }
+
+    public StreamQos() {}
+    public StreamQos(
+      uint initPrefetchSize,
+      ushort initPrefetchCount,
+      uint initConsumeRate,
+      bool initGlobal)
+    {
+      m_prefetchSize = initPrefetchSize;
+      m_prefetchCount = initPrefetchCount;
+      m_consumeRate = initConsumeRate;
+      m_global = initGlobal;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "stream.qos"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_prefetchSize = reader.ReadLong();
+      m_prefetchCount = reader.ReadShort();
+      m_consumeRate = reader.ReadLong();
+      m_global = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_prefetchSize);
+      writer.WriteShort(m_prefetchCount);
+      writer.WriteLong(m_consumeRate);
+      writer.WriteBit(m_global);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_prefetchSize); sb.Append(",");
+      sb.Append(m_prefetchCount); sb.Append(",");
+      sb.Append(m_consumeRate); sb.Append(",");
+      sb.Append(m_global);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamQosOk: RabbitMQ.Client.Impl.MethodBase, IStreamQosOk {
+    public const int ClassId = 80;
+    public const int MethodId = 11;
+
+
+
+    public StreamQosOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "stream.qos-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsume: RabbitMQ.Client.Impl.MethodBase, IStreamConsume {
+    public const int ClassId = 80;
+    public const int MethodId = 20;
+
+    public ushort m_ticket;
+    public string m_queue;
+    public string m_consumerTag;
+    public bool m_noLocal;
+    public bool m_exclusive;
+    public bool m_nowait;
+
+    ushort IStreamConsume.Ticket { get { return m_ticket; } }
+    string IStreamConsume.Queue { get { return m_queue; } }
+    string IStreamConsume.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamConsume.NoLocal { get { return m_noLocal; } }
+    bool IStreamConsume.Exclusive { get { return m_exclusive; } }
+    bool IStreamConsume.Nowait { get { return m_nowait; } }
+
+    public StreamConsume() {}
+    public StreamConsume(
+      ushort initTicket,
+      string initQueue,
+      string initConsumerTag,
+      bool initNoLocal,
+      bool initExclusive,
+      bool initNowait)
+    {
+      m_ticket = initTicket;
+      m_queue = initQueue;
+      m_consumerTag = initConsumerTag;
+      m_noLocal = initNoLocal;
+      m_exclusive = initExclusive;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "stream.consume"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_queue = reader.ReadShortstr();
+      m_consumerTag = reader.ReadShortstr();
+      m_noLocal = reader.ReadBit();
+      m_exclusive = reader.ReadBit();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_queue);
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_noLocal);
+      writer.WriteBit(m_exclusive);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_queue); sb.Append(",");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_noLocal); sb.Append(",");
+      sb.Append(m_exclusive); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamConsumeOk: RabbitMQ.Client.Impl.MethodBase, IStreamConsumeOk {
+    public const int ClassId = 80;
+    public const int MethodId = 21;
+
+    public string m_consumerTag;
+
+    string IStreamConsumeOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamConsumeOk() {}
+    public StreamConsumeOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "stream.consume-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancel: RabbitMQ.Client.Impl.MethodBase, IStreamCancel {
+    public const int ClassId = 80;
+    public const int MethodId = 30;
+
+    public string m_consumerTag;
+    public bool m_nowait;
+
+    string IStreamCancel.ConsumerTag { get { return m_consumerTag; } }
+    bool IStreamCancel.Nowait { get { return m_nowait; } }
+
+    public StreamCancel() {}
+    public StreamCancel(
+      string initConsumerTag,
+      bool initNowait)
+    {
+      m_consumerTag = initConsumerTag;
+      m_nowait = initNowait;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "stream.cancel"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_nowait = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteBit(m_nowait);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_nowait);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamCancelOk: RabbitMQ.Client.Impl.MethodBase, IStreamCancelOk {
+    public const int ClassId = 80;
+    public const int MethodId = 31;
+
+    public string m_consumerTag;
+
+    string IStreamCancelOk.ConsumerTag { get { return m_consumerTag; } }
+
+    public StreamCancelOk() {}
+    public StreamCancelOk(
+      string initConsumerTag)
+    {
+      m_consumerTag = initConsumerTag;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "stream.cancel-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamPublish: RabbitMQ.Client.Impl.MethodBase, IStreamPublish {
+    public const int ClassId = 80;
+    public const int MethodId = 40;
+
+    public ushort m_ticket;
+    public string m_exchange;
+    public string m_routingKey;
+    public bool m_mandatory;
+    public bool m_immediate;
+
+    ushort IStreamPublish.Ticket { get { return m_ticket; } }
+    string IStreamPublish.Exchange { get { return m_exchange; } }
+    string IStreamPublish.RoutingKey { get { return m_routingKey; } }
+    bool IStreamPublish.Mandatory { get { return m_mandatory; } }
+    bool IStreamPublish.Immediate { get { return m_immediate; } }
+
+    public StreamPublish() {}
+    public StreamPublish(
+      ushort initTicket,
+      string initExchange,
+      string initRoutingKey,
+      bool initMandatory,
+      bool initImmediate)
+    {
+      m_ticket = initTicket;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+      m_mandatory = initMandatory;
+      m_immediate = initImmediate;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "stream.publish"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_ticket = reader.ReadShort();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+      m_mandatory = reader.ReadBit();
+      m_immediate = reader.ReadBit();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_ticket);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+      writer.WriteBit(m_mandatory);
+      writer.WriteBit(m_immediate);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_ticket); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey); sb.Append(",");
+      sb.Append(m_mandatory); sb.Append(",");
+      sb.Append(m_immediate);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamReturn: RabbitMQ.Client.Impl.MethodBase, IStreamReturn {
+    public const int ClassId = 80;
+    public const int MethodId = 50;
+
+    public ushort m_replyCode;
+    public string m_replyText;
+    public string m_exchange;
+    public string m_routingKey;
+
+    ushort IStreamReturn.ReplyCode { get { return m_replyCode; } }
+    string IStreamReturn.ReplyText { get { return m_replyText; } }
+    string IStreamReturn.Exchange { get { return m_exchange; } }
+    string IStreamReturn.RoutingKey { get { return m_routingKey; } }
+
+    public StreamReturn() {}
+    public StreamReturn(
+      ushort initReplyCode,
+      string initReplyText,
+      string initExchange,
+      string initRoutingKey)
+    {
+      m_replyCode = initReplyCode;
+      m_replyText = initReplyText;
+      m_exchange = initExchange;
+      m_routingKey = initRoutingKey;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 50; } }
+    public override string ProtocolMethodName { get { return "stream.return"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_replyCode = reader.ReadShort();
+      m_replyText = reader.ReadShortstr();
+      m_exchange = reader.ReadShortstr();
+      m_routingKey = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShort(m_replyCode);
+      writer.WriteShortstr(m_replyText);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_routingKey);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_replyCode); sb.Append(",");
+      sb.Append(m_replyText); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_routingKey);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class StreamDeliver: RabbitMQ.Client.Impl.MethodBase, IStreamDeliver {
+    public const int ClassId = 80;
+    public const int MethodId = 60;
+
+    public string m_consumerTag;
+    public ulong m_deliveryTag;
+    public string m_exchange;
+    public string m_queue;
+
+    string IStreamDeliver.ConsumerTag { get { return m_consumerTag; } }
+    ulong IStreamDeliver.DeliveryTag { get { return m_deliveryTag; } }
+    string IStreamDeliver.Exchange { get { return m_exchange; } }
+    string IStreamDeliver.Queue { get { return m_queue; } }
+
+    public StreamDeliver() {}
+    public StreamDeliver(
+      string initConsumerTag,
+      ulong initDeliveryTag,
+      string initExchange,
+      string initQueue)
+    {
+      m_consumerTag = initConsumerTag;
+      m_deliveryTag = initDeliveryTag;
+      m_exchange = initExchange;
+      m_queue = initQueue;
+    }
+
+    public override int ProtocolClassId { get { return 80; } }
+    public override int ProtocolMethodId { get { return 60; } }
+    public override string ProtocolMethodName { get { return "stream.deliver"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_consumerTag = reader.ReadShortstr();
+      m_deliveryTag = reader.ReadLonglong();
+      m_exchange = reader.ReadShortstr();
+      m_queue = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_consumerTag);
+      writer.WriteLonglong(m_deliveryTag);
+      writer.WriteShortstr(m_exchange);
+      writer.WriteShortstr(m_queue);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_consumerTag); sb.Append(",");
+      sb.Append(m_deliveryTag); sb.Append(",");
+      sb.Append(m_exchange); sb.Append(",");
+      sb.Append(m_queue);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelect: RabbitMQ.Client.Impl.MethodBase, ITxSelect {
+    public const int ClassId = 90;
+    public const int MethodId = 10;
+
+
+
+    public TxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxSelectOk: RabbitMQ.Client.Impl.MethodBase, ITxSelectOk {
+    public const int ClassId = 90;
+    public const int MethodId = 11;
+
+
+
+    public TxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "tx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommit: RabbitMQ.Client.Impl.MethodBase, ITxCommit {
+    public const int ClassId = 90;
+    public const int MethodId = 20;
+
+
+
+    public TxCommit(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "tx.commit"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxCommitOk: RabbitMQ.Client.Impl.MethodBase, ITxCommitOk {
+    public const int ClassId = 90;
+    public const int MethodId = 21;
+
+
+
+    public TxCommitOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "tx.commit-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollback: RabbitMQ.Client.Impl.MethodBase, ITxRollback {
+    public const int ClassId = 90;
+    public const int MethodId = 30;
+
+
+
+    public TxRollback(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "tx.rollback"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TxRollbackOk: RabbitMQ.Client.Impl.MethodBase, ITxRollbackOk {
+    public const int ClassId = 90;
+    public const int MethodId = 31;
+
+
+
+    public TxRollbackOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 90; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "tx.rollback-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelect: RabbitMQ.Client.Impl.MethodBase, IDtxSelect {
+    public const int ClassId = 100;
+    public const int MethodId = 10;
+
+
+
+    public DtxSelect(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "dtx.select"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxSelectOk: RabbitMQ.Client.Impl.MethodBase, IDtxSelectOk {
+    public const int ClassId = 100;
+    public const int MethodId = 11;
+
+
+
+    public DtxSelectOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "dtx.select-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStart: RabbitMQ.Client.Impl.MethodBase, IDtxStart {
+    public const int ClassId = 100;
+    public const int MethodId = 20;
+
+    public string m_dtxIdentifier;
+
+    string IDtxStart.DtxIdentifier { get { return m_dtxIdentifier; } }
+
+    public DtxStart() {}
+    public DtxStart(
+      string initDtxIdentifier)
+    {
+      m_dtxIdentifier = initDtxIdentifier;
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "dtx.start"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_dtxIdentifier = reader.ReadShortstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_dtxIdentifier);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_dtxIdentifier);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class DtxStartOk: RabbitMQ.Client.Impl.MethodBase, IDtxStartOk {
+    public const int ClassId = 100;
+    public const int MethodId = 21;
+
+
+
+    public DtxStartOk(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 100; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "dtx.start-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TunnelRequest: RabbitMQ.Client.Impl.MethodBase, ITunnelRequest {
+    public const int ClassId = 110;
+    public const int MethodId = 10;
+
+    public System.Collections.IDictionary m_metaData;
+
+    System.Collections.IDictionary ITunnelRequest.MetaData { get { return m_metaData; } }
+
+    public TunnelRequest() {}
+    public TunnelRequest(
+      System.Collections.IDictionary initMetaData)
+    {
+      m_metaData = initMetaData;
+    }
+
+    public override int ProtocolClassId { get { return 110; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "tunnel.request"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_metaData = reader.ReadTable();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_metaData);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_metaData);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestInteger: RabbitMQ.Client.Impl.MethodBase, ITestInteger {
+    public const int ClassId = 120;
+    public const int MethodId = 10;
+
+    public byte m_integer1;
+    public ushort m_integer2;
+    public uint m_integer3;
+    public ulong m_integer4;
+    public byte m_operation;
+
+    byte ITestInteger.Integer1 { get { return m_integer1; } }
+    ushort ITestInteger.Integer2 { get { return m_integer2; } }
+    uint ITestInteger.Integer3 { get { return m_integer3; } }
+    ulong ITestInteger.Integer4 { get { return m_integer4; } }
+    byte ITestInteger.Operation { get { return m_operation; } }
+
+    public TestInteger() {}
+    public TestInteger(
+      byte initInteger1,
+      ushort initInteger2,
+      uint initInteger3,
+      ulong initInteger4,
+      byte initOperation)
+    {
+      m_integer1 = initInteger1;
+      m_integer2 = initInteger2;
+      m_integer3 = initInteger3;
+      m_integer4 = initInteger4;
+      m_operation = initOperation;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 10; } }
+    public override string ProtocolMethodName { get { return "test.integer"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_integer1 = reader.ReadOctet();
+      m_integer2 = reader.ReadShort();
+      m_integer3 = reader.ReadLong();
+      m_integer4 = reader.ReadLonglong();
+      m_operation = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteOctet(m_integer1);
+      writer.WriteShort(m_integer2);
+      writer.WriteLong(m_integer3);
+      writer.WriteLonglong(m_integer4);
+      writer.WriteOctet(m_operation);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_integer1); sb.Append(",");
+      sb.Append(m_integer2); sb.Append(",");
+      sb.Append(m_integer3); sb.Append(",");
+      sb.Append(m_integer4); sb.Append(",");
+      sb.Append(m_operation);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestIntegerOk: RabbitMQ.Client.Impl.MethodBase, ITestIntegerOk {
+    public const int ClassId = 120;
+    public const int MethodId = 11;
+
+    public ulong m_result;
+
+    ulong ITestIntegerOk.Result { get { return m_result; } }
+
+    public TestIntegerOk() {}
+    public TestIntegerOk(
+      ulong initResult)
+    {
+      m_result = initResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 11; } }
+    public override string ProtocolMethodName { get { return "test.integer-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_result = reader.ReadLonglong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_result);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_result);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestString: RabbitMQ.Client.Impl.MethodBase, ITestString {
+    public const int ClassId = 120;
+    public const int MethodId = 20;
+
+    public string m_string1;
+    public byte[] m_string2;
+    public byte m_operation;
+
+    string ITestString.String1 { get { return m_string1; } }
+    byte[] ITestString.String2 { get { return m_string2; } }
+    byte ITestString.Operation { get { return m_operation; } }
+
+    public TestString() {}
+    public TestString(
+      string initString1,
+      byte[] initString2,
+      byte initOperation)
+    {
+      m_string1 = initString1;
+      m_string2 = initString2;
+      m_operation = initOperation;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 20; } }
+    public override string ProtocolMethodName { get { return "test.string"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_string1 = reader.ReadShortstr();
+      m_string2 = reader.ReadLongstr();
+      m_operation = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteShortstr(m_string1);
+      writer.WriteLongstr(m_string2);
+      writer.WriteOctet(m_operation);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_string1); sb.Append(",");
+      sb.Append(m_string2); sb.Append(",");
+      sb.Append(m_operation);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestStringOk: RabbitMQ.Client.Impl.MethodBase, ITestStringOk {
+    public const int ClassId = 120;
+    public const int MethodId = 21;
+
+    public byte[] m_result;
+
+    byte[] ITestStringOk.Result { get { return m_result; } }
+
+    public TestStringOk() {}
+    public TestStringOk(
+      byte[] initResult)
+    {
+      m_result = initResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 21; } }
+    public override string ProtocolMethodName { get { return "test.string-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_result = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLongstr(m_result);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_result);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestTable: RabbitMQ.Client.Impl.MethodBase, ITestTable {
+    public const int ClassId = 120;
+    public const int MethodId = 30;
+
+    public System.Collections.IDictionary m_table;
+    public byte m_integerOp;
+    public byte m_stringOp;
+
+    System.Collections.IDictionary ITestTable.Table { get { return m_table; } }
+    byte ITestTable.IntegerOp { get { return m_integerOp; } }
+    byte ITestTable.StringOp { get { return m_stringOp; } }
+
+    public TestTable() {}
+    public TestTable(
+      System.Collections.IDictionary initTable,
+      byte initIntegerOp,
+      byte initStringOp)
+    {
+      m_table = initTable;
+      m_integerOp = initIntegerOp;
+      m_stringOp = initStringOp;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 30; } }
+    public override string ProtocolMethodName { get { return "test.table"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_table = reader.ReadTable();
+      m_integerOp = reader.ReadOctet();
+      m_stringOp = reader.ReadOctet();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteTable(m_table);
+      writer.WriteOctet(m_integerOp);
+      writer.WriteOctet(m_stringOp);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_table); sb.Append(",");
+      sb.Append(m_integerOp); sb.Append(",");
+      sb.Append(m_stringOp);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestTableOk: RabbitMQ.Client.Impl.MethodBase, ITestTableOk {
+    public const int ClassId = 120;
+    public const int MethodId = 31;
+
+    public ulong m_integerResult;
+    public byte[] m_stringResult;
+
+    ulong ITestTableOk.IntegerResult { get { return m_integerResult; } }
+    byte[] ITestTableOk.StringResult { get { return m_stringResult; } }
+
+    public TestTableOk() {}
+    public TestTableOk(
+      ulong initIntegerResult,
+      byte[] initStringResult)
+    {
+      m_integerResult = initIntegerResult;
+      m_stringResult = initStringResult;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 31; } }
+    public override string ProtocolMethodName { get { return "test.table-ok"; } }
+    public override bool HasContent { get { return false; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_integerResult = reader.ReadLonglong();
+      m_stringResult = reader.ReadLongstr();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLonglong(m_integerResult);
+      writer.WriteLongstr(m_stringResult);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_integerResult); sb.Append(",");
+      sb.Append(m_stringResult);
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestContent: RabbitMQ.Client.Impl.MethodBase, ITestContent {
+    public const int ClassId = 120;
+    public const int MethodId = 40;
+
+
+
+    public TestContent(
+)
+    {
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 40; } }
+    public override string ProtocolMethodName { get { return "test.content"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(")");
+    }
+  }
+  /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
+  public class TestContentOk: RabbitMQ.Client.Impl.MethodBase, ITestContentOk {
+    public const int ClassId = 120;
+    public const int MethodId = 41;
+
+    public uint m_contentChecksum;
+
+    uint ITestContentOk.ContentChecksum { get { return m_contentChecksum; } }
+
+    public TestContentOk() {}
+    public TestContentOk(
+      uint initContentChecksum)
+    {
+      m_contentChecksum = initContentChecksum;
+    }
+
+    public override int ProtocolClassId { get { return 120; } }
+    public override int ProtocolMethodId { get { return 41; } }
+    public override string ProtocolMethodName { get { return "test.content-ok"; } }
+    public override bool HasContent { get { return true; } }
+
+    public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
+      m_contentChecksum = reader.ReadLong();
+    }
+
+    public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
+      writer.WriteLong(m_contentChecksum);
+    }
+
+    public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
+      sb.Append("(");
+      sb.Append(m_contentChecksum);
+      sb.Append(")");
+    }
+  }
+
+  public class Model: RabbitMQ.Client.Impl.ModelBase {
+    public Model(RabbitMQ.Client.Impl.ISession session): base(session) {}
+    public override System.UInt16 _Private_AccessRequest(
+      System.String @realm,
+      System.Boolean @exclusive,
+      System.Boolean @passive,
+      System.Boolean @active,
+      System.Boolean @write,
+      System.Boolean @read)
+    {
+      AccessRequest __req = new AccessRequest();
+      __req.m_realm = @realm;
+      __req.m_exclusive = @exclusive;
+      __req.m_passive = @passive;
+      __req.m_active = @active;
+      __req.m_write = @write;
+      __req.m_read = @read;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      AccessRequestOk __rep = __repBase as AccessRequestOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_ticket;
+    }
+    public override void _Private_BasicPublish(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @mandatory,
+      System.Boolean @immediate,
+      RabbitMQ.Client.IBasicProperties @basicProperties,
+      System.Byte[] @body)
+    {
+      BasicPublish __req = new BasicPublish();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_mandatory = @mandatory;
+      __req.m_immediate = @immediate;
+      ModelSend(__req, (BasicProperties) basicProperties,body);
+    }
+    public override void _Private_BasicConsume(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @consumerTag,
+      System.Boolean @noLocal,
+      System.Boolean @noAck,
+      System.Boolean @exclusive,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @filter)
+    {
+      BasicConsume __req = new BasicConsume();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_consumerTag = @consumerTag;
+      __req.m_noLocal = @noLocal;
+      __req.m_noAck = @noAck;
+      __req.m_exclusive = @exclusive;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @filter;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicCancel(
+      System.String @consumerTag,
+      System.Boolean @nowait)
+    {
+      BasicCancel __req = new BasicCancel();
+      __req.m_consumerTag = @consumerTag;
+      __req.m_nowait = @nowait;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelOpen(
+      System.String @outOfBand)
+    {
+      ChannelOpen __req = new ChannelOpen();
+      __req.m_outOfBand = @outOfBand;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelOpenOk __rep = __repBase as ChannelOpenOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ChannelCloseOk()
+    {
+      ChannelCloseOk __req = new ChannelCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ChannelClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ChannelClose __req = new ChannelClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_BasicGet(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @noAck)
+    {
+      BasicGet __req = new BasicGet();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_noAck = @noAck;
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.Impl.ConnectionTuneDetails ConnectionStartOk(
+      System.Collections.IDictionary @clientProperties,
+      System.String @mechanism,
+      System.Byte[] @response,
+      System.String @locale)
+    {
+      ConnectionStartOk __req = new ConnectionStartOk();
+      __req.m_clientProperties = @clientProperties;
+      __req.m_mechanism = @mechanism;
+      __req.m_response = @response;
+      __req.m_locale = @locale;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionTune __rep = __repBase as ConnectionTune;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      RabbitMQ.Client.Impl.ConnectionTuneDetails __result = new RabbitMQ.Client.Impl.ConnectionTuneDetails();
+      __result.channelMax = __rep.m_channelMax;
+      __result.frameMax = __rep.m_frameMax;
+      __result.heartbeat = __rep.m_heartbeat;
+      return __result;
+    }
+    public override void ConnectionTuneOk(
+      System.UInt16 @channelMax,
+      System.UInt32 @frameMax,
+      System.UInt16 @heartbeat)
+    {
+      ConnectionTuneOk __req = new ConnectionTuneOk();
+      __req.m_channelMax = @channelMax;
+      __req.m_frameMax = @frameMax;
+      __req.m_heartbeat = @heartbeat;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionOpen(
+      System.String @virtualHost,
+      System.String @capabilities,
+      System.Boolean @insist)
+    {
+      ConnectionOpen __req = new ConnectionOpen();
+      __req.m_virtualHost = @virtualHost;
+      __req.m_capabilities = @capabilities;
+      __req.m_insist = @insist;
+      ModelSend(__req,null,null);
+    }
+    public override void _Private_ConnectionClose(
+      System.UInt16 @replyCode,
+      System.String @replyText,
+      System.UInt16 @classId,
+      System.UInt16 @methodId)
+    {
+      ConnectionClose __req = new ConnectionClose();
+      __req.m_replyCode = @replyCode;
+      __req.m_replyText = @replyText;
+      __req.m_classId = @classId;
+      __req.m_methodId = @methodId;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ConnectionCloseOk __rep = __repBase as ConnectionCloseOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void _Private_ConnectionCloseOk()
+    {
+      ConnectionCloseOk __req = new ConnectionCloseOk();
+      ModelSend(__req,null,null);
+    }
+    public override RabbitMQ.Client.IBasicProperties CreateBasicProperties()
+    {
+      return new BasicProperties();
+    }
+    public override RabbitMQ.Client.IFileProperties CreateFileProperties()
+    {
+      return new FileProperties();
+    }
+    public override RabbitMQ.Client.IStreamProperties CreateStreamProperties()
+    {
+      return new StreamProperties();
+    }
+    public override void ChannelFlow(
+      System.Boolean @active)
+    {
+      ChannelFlow __req = new ChannelFlow();
+      __req.m_active = @active;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ChannelFlowOk __rep = __repBase as ChannelFlowOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDeclare(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.String @type,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @autoDelete,
+      System.Boolean @internal,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      ExchangeDeclare __req = new ExchangeDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_type = @type;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_internal = @internal;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeclareOk __rep = __repBase as ExchangeDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void ExchangeDelete(
+      System.UInt16 @ticket,
+      System.String @exchange,
+      System.Boolean @ifUnused,
+      System.Boolean @nowait)
+    {
+      ExchangeDelete __req = new ExchangeDelete();
+      __req.m_ticket = @ticket;
+      __req.m_exchange = @exchange;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      ExchangeDeleteOk __rep = __repBase as ExchangeDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override System.String QueueDeclare(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @passive,
+      System.Boolean @durable,
+      System.Boolean @exclusive,
+      System.Boolean @autoDelete,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueDeclare __req = new QueueDeclare();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_passive = @passive;
+      __req.m_durable = @durable;
+      __req.m_exclusive = @exclusive;
+      __req.m_autoDelete = @autoDelete;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return null;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeclareOk __rep = __repBase as QueueDeclareOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_queue;
+    }
+    public override void QueueBind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Boolean @nowait,
+      System.Collections.IDictionary @arguments)
+    {
+      QueueBind __req = new QueueBind();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_exchange = @exchange;
+      __req.m_routingKey = @routingKey;
+      __req.m_nowait = @nowait;
+      __req.m_arguments = @arguments;
+      if (nowait) {
+        ModelSend(__req,null,null);
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueBindOk __rep = __repBase as QueueBindOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void QueueUnbind(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.String @exchange,
+      System.String @routingKey,
+      System.Collections.IDictionary @arguments)
+    {
+      throw new UnsupportedMethodException("QueueUnbind");
+    }
+    public override System.UInt32 QueuePurge(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @nowait)
+    {
+      QueuePurge __req = new QueuePurge();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueuePurgeOk __rep = __repBase as QueuePurgeOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override System.UInt32 QueueDelete(
+      System.UInt16 @ticket,
+      System.String @queue,
+      System.Boolean @ifUnused,
+      System.Boolean @ifEmpty,
+      System.Boolean @nowait)
+    {
+      QueueDelete __req = new QueueDelete();
+      __req.m_ticket = @ticket;
+      __req.m_queue = @queue;
+      __req.m_ifUnused = @ifUnused;
+      __req.m_ifEmpty = @ifEmpty;
+      __req.m_nowait = @nowait;
+      if (nowait) {
+        ModelSend(__req,null,null);
+        return 0xFFFFFFFF;
+      }
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      QueueDeleteOk __rep = __repBase as QueueDeleteOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+      return __rep.m_messageCount;
+    }
+    public override void BasicQos(
+      System.UInt32 @prefetchSize,
+      System.UInt16 @prefetchCount,
+      System.Boolean @global)
+    {
+      BasicQos __req = new BasicQos();
+      __req.m_prefetchSize = @prefetchSize;
+      __req.m_prefetchCount = @prefetchCount;
+      __req.m_global = @global;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      BasicQosOk __rep = __repBase as BasicQosOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void BasicAck(
+      System.UInt64 @deliveryTag,
+      System.Boolean @multiple)
+    {
+      BasicAck __req = new BasicAck();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_multiple = @multiple;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicReject(
+      System.UInt64 @deliveryTag,
+      System.Boolean @requeue)
+    {
+      BasicReject __req = new BasicReject();
+      __req.m_deliveryTag = @deliveryTag;
+      __req.m_requeue = @requeue;
+      ModelSend(__req,null,null);
+    }
+    public override void BasicRecover(
+      System.Boolean @requeue)
+    {
+      BasicRecover __req = new BasicRecover();
+      __req.m_requeue = @requeue;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      BasicRecoverOk __rep = __repBase as BasicRecoverOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxSelect()
+    {
+      TxSelect __req = new TxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxSelectOk __rep = __repBase as TxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxCommit()
+    {
+      TxCommit __req = new TxCommit();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxCommitOk __rep = __repBase as TxCommitOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void TxRollback()
+    {
+      TxRollback __req = new TxRollback();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      TxRollbackOk __rep = __repBase as TxRollbackOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxSelect()
+    {
+      DtxSelect __req = new DtxSelect();
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxSelectOk __rep = __repBase as DtxSelectOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override void DtxStart(
+      System.String @dtxIdentifier)
+    {
+      DtxStart __req = new DtxStart();
+      __req.m_dtxIdentifier = @dtxIdentifier;
+      RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
+      DtxStartOk __rep = __repBase as DtxStartOk;
+      if (__rep == null) throw new UnexpectedMethodException(__repBase);
+    }
+    public override bool DispatchAsynchronous(RabbitMQ.Client.Impl.Command cmd) {
+      RabbitMQ.Client.Impl.MethodBase __method = (RabbitMQ.Client.Impl.MethodBase) cmd.Method;
+      switch ((__method.ProtocolClassId << 16) | __method.ProtocolMethodId) {
+        case 3932181: {
+          BasicConsumeOk __impl = (BasicConsumeOk) __method;
+          HandleBasicConsumeOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932191: {
+          BasicCancelOk __impl = (BasicCancelOk) __method;
+          HandleBasicCancelOk(
+            __impl.m_consumerTag);
+          return true;
+        }
+        case 3932231: {
+          BasicGetOk __impl = (BasicGetOk) __method;
+          HandleBasicGetOk(
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            __impl.m_messageCount,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932232: {
+          HandleBasicGetEmpty();
+          return true;
+        }
+        case 3932220: {
+          BasicDeliver __impl = (BasicDeliver) __method;
+          HandleBasicDeliver(
+            __impl.m_consumerTag,
+            __impl.m_deliveryTag,
+            __impl.m_redelivered,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 3932210: {
+          BasicReturn __impl = (BasicReturn) __method;
+          HandleBasicReturn(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_exchange,
+            __impl.m_routingKey,
+            (RabbitMQ.Client.IBasicProperties) cmd.Header,
+            cmd.Body);
+          return true;
+        }
+        case 1310760: {
+          ChannelClose __impl = (ChannelClose) __method;
+          HandleChannelClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        case 1310761: {
+          HandleChannelCloseOk();
+          return true;
+        }
+        case 655370: {
+          ConnectionStart __impl = (ConnectionStart) __method;
+          HandleConnectionStart(
+            __impl.m_versionMajor,
+            __impl.m_versionMinor,
+            __impl.m_serverProperties,
+            __impl.m_mechanisms,
+            __impl.m_locales);
+          return true;
+        }
+        case 655401: {
+          ConnectionOpenOk __impl = (ConnectionOpenOk) __method;
+          HandleConnectionOpenOk(
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655410: {
+          ConnectionRedirect __impl = (ConnectionRedirect) __method;
+          HandleConnectionRedirect(
+            __impl.m_host,
+            __impl.m_knownHosts);
+          return true;
+        }
+        case 655420: {
+          ConnectionClose __impl = (ConnectionClose) __method;
+          HandleConnectionClose(
+            __impl.m_replyCode,
+            __impl.m_replyText,
+            __impl.m_classId,
+            __impl.m_methodId);
+          return true;
+        }
+        default: return false;
+      }
+    }
+  }
+}
diff --git a/mcs/class/RabbitMQ.Client/src/apigen/RabbitMQ.Client.Apigen.exe.sources b/mcs/class/RabbitMQ.Client/src/apigen/RabbitMQ.Client.Apigen.exe.sources
index 94608fff5c3..a71720a1ede 100644
--- a/mcs/class/RabbitMQ.Client/src/apigen/RabbitMQ.Client.Apigen.exe.sources
+++ b/mcs/class/RabbitMQ.Client/src/apigen/RabbitMQ.Client.Apigen.exe.sources
@@ -3,3 +3,18 @@ AmqpClass.cs
 AmqpEntity.cs
 AmqpField.cs
 AmqpMethod.cs
+../client/api/IModel.cs
+../client/api/IContentHeader.cs
+../client/api/IBasicProperties.cs
+../client/api/IFileProperties.cs
+../client/api/IStreamProperties.cs
+../client/api/AmqpTimestamp.cs
+../client/api/IBasicConsumer.cs
+../client/api/ShutdownEventArgs.cs
+../client/api/ShutdownInitiator.cs
+../client/api/PublicationAddress.cs
+../client/events/BasicReturnEventArgs.cs
+../client/events/BasicReturnEventHandler.cs
+../client/events/CallbackExceptionEventArgs.cs
+../client/events/CallbackExceptionEventHandler.cs
+../client/events/ModelShutdownEventHandler.cs