mcs/class/RabbitMQ.Client/docs/specs/net_4_0-api-qpid-0-8.cs

   1 // Autogenerated code. Do not edit.
   2
   3 // This source code is dual-licensed under the Apache License, version
   4 // 2.0, and the Mozilla Public License, version 1.1.
   5 //
   6 // The APL v2.0:
   7 //
   8 //---------------------------------------------------------------------------
   9 //   Copyright (C) 2007-2010 LShift Ltd., Cohesive Financial
  10 //   Technologies LLC., and Rabbit Technologies Ltd.
  11 //
  12 //   Licensed under the Apache License, Version 2.0 (the "License");
  13 //   you may not use this file except in compliance with the License.
  14 //   You may obtain a copy of the License at
  15 //
  16 //       http://www.apache.org/licenses/LICENSE-2.0
  17 //
  18 //   Unless required by applicable law or agreed to in writing, software
  19 //   distributed under the License is distributed on an "AS IS" BASIS,
  20 //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21 //   See the License for the specific language governing permissions and
  22 //   limitations under the License.
  23 //---------------------------------------------------------------------------
  24 //
  25 // The MPL v1.1:
  26 //
  27 //---------------------------------------------------------------------------
  28 //   The contents of this file are subject to the Mozilla Public License
  29 //   Version 1.1 (the "License"); you may not use this file except in
  30 //   compliance with the License. You may obtain a copy of the License at
  31 //   http://www.rabbitmq.com/mpl.html
  32 //
  33 //   Software distributed under the License is distributed on an "AS IS"
  34 //   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  35 //   License for the specific language governing rights and limitations
  36 //   under the License.
  37 //
  38 //   The Original Code is The RabbitMQ .NET Client.
  39 //
  40 //   The Initial Developers of the Original Code are LShift Ltd,
  41 //   Cohesive Financial Technologies LLC, and Rabbit Technologies Ltd.
  42 //
  43 //   Portions created before 22-Nov-2008 00:00:00 GMT by LShift Ltd,
  44 //   Cohesive Financial Technologies LLC, or Rabbit Technologies Ltd
  45 //   are Copyright (C) 2007-2008 LShift Ltd, Cohesive Financial
  46 //   Technologies LLC, and Rabbit Technologies Ltd.
  47 //
  48 //   Portions created by LShift Ltd are Copyright (C) 2007-2010 LShift
  49 //   Ltd. Portions created by Cohesive Financial Technologies LLC are
  50 //   Copyright (C) 2007-2010 Cohesive Financial Technologies
  51 //   LLC. Portions created by Rabbit Technologies Ltd are Copyright
  52 //   (C) 2007-2010 Rabbit Technologies Ltd.
  53 //
  54 //   All Rights Reserved.
  55 //
  56 //   Contributor(s): ______________________________________.
  57 //
  58 //---------------------------------------------------------------------------
  59
  60 using RabbitMQ.Client;
  61 using RabbitMQ.Client.Exceptions;
  62
  63 namespace RabbitMQ.Client.Framing.v0_8qpid {
  64   public class Protocol: RabbitMQ.Client.Framing.Impl.v0_8qpid.ProtocolBase {
  65     ///<summary>Protocol major version (= 8)</summary>
  66     public override int MajorVersion { get { return 8; } }
  67     ///<summary>Protocol minor version (= 0)</summary>
  68     public override int MinorVersion { get { return 0; } }
  69     ///<summary>Protocol API name (= AMQP_0_8_QPID)</summary>
  70     public override string ApiName { get { return "AMQP_0_8_QPID"; } }
  71     ///<summary>Default TCP port (= 5672)</summary>
  72     public override int DefaultPort { get { return 5672; } }
  73
  74     public override RabbitMQ.Client.Impl.MethodBase DecodeMethodFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
  75       ushort classId = reader.ReadUInt16();
  76       ushort methodId = reader.ReadUInt16();
  77
  78       switch (classId) {
  79         case 10: {
  80           switch (methodId) {
  81             case 10: {
  82               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStart result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStart();
  83               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
  84               return result;
  85             }
  86             case 11: {
  87               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionStartOk();
  88               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
  89               return result;
  90             }
  91             case 20: {
  92               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecure result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecure();
  93               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
  94               return result;
  95             }
  96             case 21: {
  97               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecureOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionSecureOk();
  98               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
  99               return result;
 100             }
 101             case 30: {
 102               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTune result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTune();
 103               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 104               return result;
 105             }
 106             case 31: {
 107               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTuneOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionTuneOk();
 108               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 109               return result;
 110             }
 111             case 40: {
 112               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpen();
 113               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 114               return result;
 115             }
 116             case 41: {
 117               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionOpenOk();
 118               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 119               return result;
 120             }
 121             case 50: {
 122               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionRedirect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionRedirect();
 123               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 124               return result;
 125             }
 126             case 60: {
 127               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionClose result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionClose();
 128               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 129               return result;
 130             }
 131             case 61: {
 132               RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ConnectionCloseOk();
 133               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 134               return result;
 135             }
 136             default: break;
 137           }
 138           break;
 139         }
 140         case 20: {
 141           switch (methodId) {
 142             case 10: {
 143               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpen();
 144               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 145               return result;
 146             }
 147             case 11: {
 148               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelOpenOk();
 149               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 150               return result;
 151             }
 152             case 20: {
 153               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlow result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlow();
 154               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 155               return result;
 156             }
 157             case 21: {
 158               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlowOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelFlowOk();
 159               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 160               return result;
 161             }
 162             case 30: {
 163               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelAlert result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelAlert();
 164               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 165               return result;
 166             }
 167             case 40: {
 168               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelClose result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelClose();
 169               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 170               return result;
 171             }
 172             case 41: {
 173               RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelCloseOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ChannelCloseOk();
 174               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 175               return result;
 176             }
 177             default: break;
 178           }
 179           break;
 180         }
 181         case 30: {
 182           switch (methodId) {
 183             case 10: {
 184               RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequest result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequest();
 185               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 186               return result;
 187             }
 188             case 11: {
 189               RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequestOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.AccessRequestOk();
 190               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 191               return result;
 192             }
 193             default: break;
 194           }
 195           break;
 196         }
 197         case 40: {
 198           switch (methodId) {
 199             case 10: {
 200               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclare();
 201               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 202               return result;
 203             }
 204             case 11: {
 205               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeclareOk();
 206               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 207               return result;
 208             }
 209             case 20: {
 210               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDelete result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDelete();
 211               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 212               return result;
 213             }
 214             case 21: {
 215               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeDeleteOk();
 216               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 217               return result;
 218             }
 219             case 22: {
 220               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBound result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBound();
 221               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 222               return result;
 223             }
 224             case 23: {
 225               RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBoundOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.ExchangeBoundOk();
 226               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 227               return result;
 228             }
 229             default: break;
 230           }
 231           break;
 232         }
 233         case 50: {
 234           switch (methodId) {
 235             case 10: {
 236               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclare result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclare();
 237               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 238               return result;
 239             }
 240             case 11: {
 241               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclareOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeclareOk();
 242               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 243               return result;
 244             }
 245             case 20: {
 246               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBind result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBind();
 247               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 248               return result;
 249             }
 250             case 21: {
 251               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBindOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueBindOk();
 252               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 253               return result;
 254             }
 255             case 30: {
 256               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurge result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurge();
 257               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 258               return result;
 259             }
 260             case 31: {
 261               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurgeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueuePurgeOk();
 262               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 263               return result;
 264             }
 265             case 40: {
 266               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDelete result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDelete();
 267               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 268               return result;
 269             }
 270             case 41: {
 271               RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeleteOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.QueueDeleteOk();
 272               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 273               return result;
 274             }
 275             default: break;
 276           }
 277           break;
 278         }
 279         case 60: {
 280           switch (methodId) {
 281             case 10: {
 282               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQos();
 283               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 284               return result;
 285             }
 286             case 11: {
 287               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicQosOk();
 288               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 289               return result;
 290             }
 291             case 20: {
 292               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsume();
 293               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 294               return result;
 295             }
 296             case 21: {
 297               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicConsumeOk();
 298               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 299               return result;
 300             }
 301             case 30: {
 302               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancel();
 303               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 304               return result;
 305             }
 306             case 31: {
 307               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicCancelOk();
 308               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 309               return result;
 310             }
 311             case 40: {
 312               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicPublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicPublish();
 313               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 314               return result;
 315             }
 316             case 50: {
 317               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReturn();
 318               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 319               return result;
 320             }
 321             case 60: {
 322               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicDeliver();
 323               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 324               return result;
 325             }
 326             case 70: {
 327               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGet result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGet();
 328               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 329               return result;
 330             }
 331             case 71: {
 332               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetOk();
 333               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 334               return result;
 335             }
 336             case 72: {
 337               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetEmpty result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicGetEmpty();
 338               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 339               return result;
 340             }
 341             case 80: {
 342               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicAck result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicAck();
 343               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 344               return result;
 345             }
 346             case 90: {
 347               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReject result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicReject();
 348               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 349               return result;
 350             }
 351             case 100: {
 352               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecover result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecover();
 353               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 354               return result;
 355             }
 356             case 101: {
 357               RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecoverOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.BasicRecoverOk();
 358               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 359               return result;
 360             }
 361             default: break;
 362           }
 363           break;
 364         }
 365         case 70: {
 366           switch (methodId) {
 367             case 10: {
 368               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQos();
 369               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 370               return result;
 371             }
 372             case 11: {
 373               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileQosOk();
 374               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 375               return result;
 376             }
 377             case 20: {
 378               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsume();
 379               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 380               return result;
 381             }
 382             case 21: {
 383               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileConsumeOk();
 384               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 385               return result;
 386             }
 387             case 30: {
 388               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancel();
 389               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 390               return result;
 391             }
 392             case 31: {
 393               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileCancelOk();
 394               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 395               return result;
 396             }
 397             case 40: {
 398               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpen result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpen();
 399               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 400               return result;
 401             }
 402             case 41: {
 403               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpenOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileOpenOk();
 404               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 405               return result;
 406             }
 407             case 50: {
 408               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileStage result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileStage();
 409               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 410               return result;
 411             }
 412             case 60: {
 413               RabbitMQ.Client.Framing.Impl.v0_8qpid.FilePublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FilePublish();
 414               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 415               return result;
 416             }
 417             case 70: {
 418               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReturn();
 419               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 420               return result;
 421             }
 422             case 80: {
 423               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileDeliver();
 424               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 425               return result;
 426             }
 427             case 90: {
 428               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileAck result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileAck();
 429               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 430               return result;
 431             }
 432             case 100: {
 433               RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReject result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.FileReject();
 434               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 435               return result;
 436             }
 437             default: break;
 438           }
 439           break;
 440         }
 441         case 80: {
 442           switch (methodId) {
 443             case 10: {
 444               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQos result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQos();
 445               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 446               return result;
 447             }
 448             case 11: {
 449               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQosOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamQosOk();
 450               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 451               return result;
 452             }
 453             case 20: {
 454               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsume result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsume();
 455               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 456               return result;
 457             }
 458             case 21: {
 459               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsumeOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamConsumeOk();
 460               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 461               return result;
 462             }
 463             case 30: {
 464               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancel result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancel();
 465               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 466               return result;
 467             }
 468             case 31: {
 469               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancelOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamCancelOk();
 470               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 471               return result;
 472             }
 473             case 40: {
 474               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamPublish result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamPublish();
 475               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 476               return result;
 477             }
 478             case 50: {
 479               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamReturn result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamReturn();
 480               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 481               return result;
 482             }
 483             case 60: {
 484               RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamDeliver result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.StreamDeliver();
 485               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 486               return result;
 487             }
 488             default: break;
 489           }
 490           break;
 491         }
 492         case 90: {
 493           switch (methodId) {
 494             case 10: {
 495               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelect();
 496               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 497               return result;
 498             }
 499             case 11: {
 500               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxSelectOk();
 501               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 502               return result;
 503             }
 504             case 20: {
 505               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommit result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommit();
 506               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 507               return result;
 508             }
 509             case 21: {
 510               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommitOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxCommitOk();
 511               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 512               return result;
 513             }
 514             case 30: {
 515               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollback result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollback();
 516               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 517               return result;
 518             }
 519             case 31: {
 520               RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollbackOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TxRollbackOk();
 521               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 522               return result;
 523             }
 524             default: break;
 525           }
 526           break;
 527         }
 528         case 100: {
 529           switch (methodId) {
 530             case 10: {
 531               RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelect result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelect();
 532               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 533               return result;
 534             }
 535             case 11: {
 536               RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelectOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxSelectOk();
 537               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 538               return result;
 539             }
 540             case 20: {
 541               RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStart result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStart();
 542               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 543               return result;
 544             }
 545             case 21: {
 546               RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStartOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.DtxStartOk();
 547               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 548               return result;
 549             }
 550             default: break;
 551           }
 552           break;
 553         }
 554         case 110: {
 555           switch (methodId) {
 556             case 10: {
 557               RabbitMQ.Client.Framing.Impl.v0_8qpid.TunnelRequest result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TunnelRequest();
 558               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 559               return result;
 560             }
 561             default: break;
 562           }
 563           break;
 564         }
 565         case 120: {
 566           switch (methodId) {
 567             case 10: {
 568               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestInteger result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestInteger();
 569               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 570               return result;
 571             }
 572             case 11: {
 573               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestIntegerOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestIntegerOk();
 574               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 575               return result;
 576             }
 577             case 20: {
 578               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestString result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestString();
 579               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 580               return result;
 581             }
 582             case 21: {
 583               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestStringOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestStringOk();
 584               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 585               return result;
 586             }
 587             case 30: {
 588               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTable result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTable();
 589               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 590               return result;
 591             }
 592             case 31: {
 593               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTableOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestTableOk();
 594               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 595               return result;
 596             }
 597             case 40: {
 598               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContent result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContent();
 599               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 600               return result;
 601             }
 602             case 41: {
 603               RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContentOk result = new RabbitMQ.Client.Framing.Impl.v0_8qpid.TestContentOk();
 604               result.ReadArgumentsFrom(new RabbitMQ.Client.Impl.MethodArgumentReader(reader));
 605               return result;
 606             }
 607             default: break;
 608           }
 609           break;
 610         }
 611         default: break;
 612       }
 613       throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, methodId);
 614     }
 615
 616     public override RabbitMQ.Client.Impl.ContentHeaderBase DecodeContentHeaderFrom(RabbitMQ.Util.NetworkBinaryReader reader) {
 617       ushort classId = reader.ReadUInt16();
 618
 619       switch (classId) {
 620         case 60: return new BasicProperties();
 621         case 70: return new FileProperties();
 622         case 80: return new StreamProperties();
 623         case 110: return new TunnelProperties();
 624         case 120: return new TestProperties();
 625         default: break;
 626       }
 627       throw new RabbitMQ.Client.Impl.UnknownClassOrMethodException(classId, 0);
 628     }
 629   }
 630   public class Constants {
 631     ///<summary>(= 1)</summary>
 632     public const int FrameMethod = 1;
 633     ///<summary>(= 2)</summary>
 634     public const int FrameHeader = 2;
 635     ///<summary>(= 3)</summary>
 636     public const int FrameBody = 3;
 637     ///<summary>(= 4)</summary>
 638     public const int FrameOobMethod = 4;
 639     ///<summary>(= 5)</summary>
 640     public const int FrameOobHeader = 5;
 641     ///<summary>(= 6)</summary>
 642     public const int FrameOobBody = 6;
 643     ///<summary>(= 7)</summary>
 644     public const int FrameTrace = 7;
 645     ///<summary>(= 8)</summary>
 646     public const int FrameHeartbeat = 8;
 647     ///<summary>(= 4096)</summary>
 648     public const int FrameMinSize = 4096;
 649     ///<summary>(= 206)</summary>
 650     public const int FrameEnd = 206;
 651     ///<summary>(= 200)</summary>
 652     public const int ReplySuccess = 200;
 653     ///<summary>(= 310)</summary>
 654     public const int NotDelivered = 310;
 655     ///<summary>(= 311)</summary>
 656     public const int ContentTooLarge = 311;
 657     ///<summary>(= 320)</summary>
 658     public const int ConnectionForced = 320;
 659     ///<summary>(= 402)</summary>
 660     public const int InvalidPath = 402;
 661     ///<summary>(= 403)</summary>
 662     public const int AccessRefused = 403;
 663     ///<summary>(= 404)</summary>
 664     public const int NotFound = 404;
 665     ///<summary>(= 405)</summary>
 666     public const int ResourceLocked = 405;
 667     ///<summary>(= 501)</summary>
 668     public const int FrameError = 501;
 669     ///<summary>(= 502)</summary>
 670     public const int SyntaxError = 502;
 671     ///<summary>(= 503)</summary>
 672     public const int CommandInvalid = 503;
 673     ///<summary>(= 504)</summary>
 674     public const int ChannelError = 504;
 675     ///<summary>(= 506)</summary>
 676     public const int ResourceError = 506;
 677     ///<summary>(= 530)</summary>
 678     public const int NotAllowed = 530;
 679     ///<summary>(= 540)</summary>
 680     public const int NotImplemented = 540;
 681     ///<summary>(= 541)</summary>
 682     public const int InternalError = 541;
 683   }
 684   /// <summary>Autogenerated type. AMQP specification method "connection.start".</summary>
 685   public interface IConnectionStart: IMethod {
 686     byte VersionMajor { get; }
 687     byte VersionMinor { get; }
 688     System.Collections.IDictionary ServerProperties { get; }
 689     byte[] Mechanisms { get; }
 690     byte[] Locales { get; }
 691   }
 692   /// <summary>Autogenerated type. AMQP specification method "connection.start-ok".</summary>
 693   public interface IConnectionStartOk: IMethod {
 694     System.Collections.IDictionary ClientProperties { get; }
 695     string Mechanism { get; }
 696     byte[] Response { get; }
 697     string Locale { get; }
 698   }
 699   /// <summary>Autogenerated type. AMQP specification method "connection.secure".</summary>
 700   public interface IConnectionSecure: IMethod {
 701     byte[] Challenge { get; }
 702   }
 703   /// <summary>Autogenerated type. AMQP specification method "connection.secure-ok".</summary>
 704   public interface IConnectionSecureOk: IMethod {
 705     byte[] Response { get; }
 706   }
 707   /// <summary>Autogenerated type. AMQP specification method "connection.tune".</summary>
 708   public interface IConnectionTune: IMethod {
 709     ushort ChannelMax { get; }
 710     uint FrameMax { get; }
 711     ushort Heartbeat { get; }
 712   }
 713   /// <summary>Autogenerated type. AMQP specification method "connection.tune-ok".</summary>
 714   public interface IConnectionTuneOk: IMethod {
 715     ushort ChannelMax { get; }
 716     uint FrameMax { get; }
 717     ushort Heartbeat { get; }
 718   }
 719   /// <summary>Autogenerated type. AMQP specification method "connection.open".</summary>
 720   public interface IConnectionOpen: IMethod {
 721     string VirtualHost { get; }
 722     string Capabilities { get; }
 723     bool Insist { get; }
 724   }
 725   /// <summary>Autogenerated type. AMQP specification method "connection.open-ok".</summary>
 726   public interface IConnectionOpenOk: IMethod {
 727     string KnownHosts { get; }
 728   }
 729   /// <summary>Autogenerated type. AMQP specification method "connection.redirect".</summary>
 730   public interface IConnectionRedirect: IMethod {
 731     string Host { get; }
 732     string KnownHosts { get; }
 733   }
 734   /// <summary>Autogenerated type. AMQP specification method "connection.close".</summary>
 735   public interface IConnectionClose: IMethod {
 736     ushort ReplyCode { get; }
 737     string ReplyText { get; }
 738     ushort ClassId { get; }
 739     ushort MethodId { get; }
 740   }
 741   /// <summary>Autogenerated type. AMQP specification method "connection.close-ok".</summary>
 742   public interface IConnectionCloseOk: IMethod {
 743   }
 744   /// <summary>Autogenerated type. AMQP specification method "channel.open".</summary>
 745   public interface IChannelOpen: IMethod {
 746     string OutOfBand { get; }
 747   }
 748   /// <summary>Autogenerated type. AMQP specification method "channel.open-ok".</summary>
 749   public interface IChannelOpenOk: IMethod {
 750   }
 751   /// <summary>Autogenerated type. AMQP specification method "channel.flow".</summary>
 752   public interface IChannelFlow: IMethod {
 753     bool Active { get; }
 754   }
 755   /// <summary>Autogenerated type. AMQP specification method "channel.flow-ok".</summary>
 756   public interface IChannelFlowOk: IMethod {
 757     bool Active { get; }
 758   }
 759   /// <summary>Autogenerated type. AMQP specification method "channel.alert".</summary>
 760   public interface IChannelAlert: IMethod {
 761     ushort ReplyCode { get; }
 762     string ReplyText { get; }
 763     System.Collections.IDictionary Details { get; }
 764   }
 765   /// <summary>Autogenerated type. AMQP specification method "channel.close".</summary>
 766   public interface IChannelClose: IMethod {
 767     ushort ReplyCode { get; }
 768     string ReplyText { get; }
 769     ushort ClassId { get; }
 770     ushort MethodId { get; }
 771   }
 772   /// <summary>Autogenerated type. AMQP specification method "channel.close-ok".</summary>
 773   public interface IChannelCloseOk: IMethod {
 774   }
 775   /// <summary>Autogenerated type. AMQP specification method "access.request".</summary>
 776   public interface IAccessRequest: IMethod {
 777     string Realm { get; }
 778     bool Exclusive { get; }
 779     bool Passive { get; }
 780     bool Active { get; }
 781     bool Write { get; }
 782     bool Read { get; }
 783   }
 784   /// <summary>Autogenerated type. AMQP specification method "access.request-ok".</summary>
 785   public interface IAccessRequestOk: IMethod {
 786     ushort Ticket { get; }
 787   }
 788   /// <summary>Autogenerated type. AMQP specification method "exchange.declare".</summary>
 789   public interface IExchangeDeclare: IMethod {
 790     ushort Ticket { get; }
 791     string Exchange { get; }
 792     string Type { get; }
 793     bool Passive { get; }
 794     bool Durable { get; }
 795     bool AutoDelete { get; }
 796     bool Internal { get; }
 797     bool Nowait { get; }
 798     System.Collections.IDictionary Arguments { get; }
 799   }
 800   /// <summary>Autogenerated type. AMQP specification method "exchange.declare-ok".</summary>
 801   public interface IExchangeDeclareOk: IMethod {
 802   }
 803   /// <summary>Autogenerated type. AMQP specification method "exchange.delete".</summary>
 804   public interface IExchangeDelete: IMethod {
 805     ushort Ticket { get; }
 806     string Exchange { get; }
 807     bool IfUnused { get; }
 808     bool Nowait { get; }
 809   }
 810   /// <summary>Autogenerated type. AMQP specification method "exchange.delete-ok".</summary>
 811   public interface IExchangeDeleteOk: IMethod {
 812   }
 813   /// <summary>Autogenerated type. AMQP specification method "exchange.bound".</summary>
 814   public interface IExchangeBound: IMethod {
 815     string Exchange { get; }
 816     string RoutingKey { get; }
 817     string Queue { get; }
 818   }
 819   /// <summary>Autogenerated type. AMQP specification method "exchange.bound-ok".</summary>
 820   public interface IExchangeBoundOk: IMethod {
 821     ushort ReplyCode { get; }
 822     string ReplyText { get; }
 823   }
 824   /// <summary>Autogenerated type. AMQP specification method "queue.declare".</summary>
 825   public interface IQueueDeclare: IMethod {
 826     ushort Ticket { get; }
 827     string Queue { get; }
 828     bool Passive { get; }
 829     bool Durable { get; }
 830     bool Exclusive { get; }
 831     bool AutoDelete { get; }
 832     bool Nowait { get; }
 833     System.Collections.IDictionary Arguments { get; }
 834   }
 835   /// <summary>Autogenerated type. AMQP specification method "queue.declare-ok".</summary>
 836   public interface IQueueDeclareOk: IMethod {
 837     string Queue { get; }
 838     uint MessageCount { get; }
 839     uint ConsumerCount { get; }
 840   }
 841   /// <summary>Autogenerated type. AMQP specification method "queue.bind".</summary>
 842   public interface IQueueBind: IMethod {
 843     ushort Ticket { get; }
 844     string Queue { get; }
 845     string Exchange { get; }
 846     string RoutingKey { get; }
 847     bool Nowait { get; }
 848     System.Collections.IDictionary Arguments { get; }
 849   }
 850   /// <summary>Autogenerated type. AMQP specification method "queue.bind-ok".</summary>
 851   public interface IQueueBindOk: IMethod {
 852   }
 853   /// <summary>Autogenerated type. AMQP specification method "queue.purge".</summary>
 854   public interface IQueuePurge: IMethod {
 855     ushort Ticket { get; }
 856     string Queue { get; }
 857     bool Nowait { get; }
 858   }
 859   /// <summary>Autogenerated type. AMQP specification method "queue.purge-ok".</summary>
 860   public interface IQueuePurgeOk: IMethod {
 861     uint MessageCount { get; }
 862   }
 863   /// <summary>Autogenerated type. AMQP specification method "queue.delete".</summary>
 864   public interface IQueueDelete: IMethod {
 865     ushort Ticket { get; }
 866     string Queue { get; }
 867     bool IfUnused { get; }
 868     bool IfEmpty { get; }
 869     bool Nowait { get; }
 870   }
 871   /// <summary>Autogenerated type. AMQP specification method "queue.delete-ok".</summary>
 872   public interface IQueueDeleteOk: IMethod {
 873     uint MessageCount { get; }
 874   }
 875   /// <summary>Autogenerated type. AMQP specification method "basic.qos".</summary>
 876   public interface IBasicQos: IMethod {
 877     uint PrefetchSize { get; }
 878     ushort PrefetchCount { get; }
 879     bool Global { get; }
 880   }
 881   /// <summary>Autogenerated type. AMQP specification method "basic.qos-ok".</summary>
 882   public interface IBasicQosOk: IMethod {
 883   }
 884   /// <summary>Autogenerated type. AMQP specification method "basic.consume".</summary>
 885   public interface IBasicConsume: IMethod {
 886     ushort Ticket { get; }
 887     string Queue { get; }
 888     string ConsumerTag { get; }
 889     bool NoLocal { get; }
 890     bool NoAck { get; }
 891     bool Exclusive { get; }
 892     bool Nowait { get; }
 893     System.Collections.IDictionary Arguments { get; }
 894   }
 895   /// <summary>Autogenerated type. AMQP specification method "basic.consume-ok".</summary>
 896   public interface IBasicConsumeOk: IMethod {
 897     string ConsumerTag { get; }
 898   }
 899   /// <summary>Autogenerated type. AMQP specification method "basic.cancel".</summary>
 900   public interface IBasicCancel: IMethod {
 901     string ConsumerTag { get; }
 902     bool Nowait { get; }
 903   }
 904   /// <summary>Autogenerated type. AMQP specification method "basic.cancel-ok".</summary>
 905   public interface IBasicCancelOk: IMethod {
 906     string ConsumerTag { get; }
 907   }
 908   /// <summary>Autogenerated type. AMQP specification method "basic.publish".</summary>
 909   public interface IBasicPublish: IMethod {
 910     ushort Ticket { get; }
 911     string Exchange { get; }
 912     string RoutingKey { get; }
 913     bool Mandatory { get; }
 914     bool Immediate { get; }
 915   }
 916   /// <summary>Autogenerated type. AMQP specification method "basic.return".</summary>
 917   public interface IBasicReturn: IMethod {
 918     ushort ReplyCode { get; }
 919     string ReplyText { get; }
 920     string Exchange { get; }
 921     string RoutingKey { get; }
 922   }
 923   /// <summary>Autogenerated type. AMQP specification method "basic.deliver".</summary>
 924   public interface IBasicDeliver: IMethod {
 925     string ConsumerTag { get; }
 926     ulong DeliveryTag { get; }
 927     bool Redelivered { get; }
 928     string Exchange { get; }
 929     string RoutingKey { get; }
 930   }
 931   /// <summary>Autogenerated type. AMQP specification method "basic.get".</summary>
 932   public interface IBasicGet: IMethod {
 933     ushort Ticket { get; }
 934     string Queue { get; }
 935     bool NoAck { get; }
 936   }
 937   /// <summary>Autogenerated type. AMQP specification method "basic.get-ok".</summary>
 938   public interface IBasicGetOk: IMethod {
 939     ulong DeliveryTag { get; }
 940     bool Redelivered { get; }
 941     string Exchange { get; }
 942     string RoutingKey { get; }
 943     uint MessageCount { get; }
 944   }
 945   /// <summary>Autogenerated type. AMQP specification method "basic.get-empty".</summary>
 946   public interface IBasicGetEmpty: IMethod {
 947     string ClusterId { get; }
 948   }
 949   /// <summary>Autogenerated type. AMQP specification method "basic.ack".</summary>
 950   public interface IBasicAck: IMethod {
 951     ulong DeliveryTag { get; }
 952     bool Multiple { get; }
 953   }
 954   /// <summary>Autogenerated type. AMQP specification method "basic.reject".</summary>
 955   public interface IBasicReject: IMethod {
 956     ulong DeliveryTag { get; }
 957     bool Requeue { get; }
 958   }
 959   /// <summary>Autogenerated type. AMQP specification method "basic.recover".</summary>
 960   public interface IBasicRecover: IMethod {
 961     bool Requeue { get; }
 962   }
 963   /// <summary>Autogenerated type. AMQP specification method "basic.recover-ok".</summary>
 964   public interface IBasicRecoverOk: IMethod {
 965   }
 966   /// <summary>Autogenerated type. AMQP specification method "file.qos".</summary>
 967   public interface IFileQos: IMethod {
 968     uint PrefetchSize { get; }
 969     ushort PrefetchCount { get; }
 970     bool Global { get; }
 971   }
 972   /// <summary>Autogenerated type. AMQP specification method "file.qos-ok".</summary>
 973   public interface IFileQosOk: IMethod {
 974   }
 975   /// <summary>Autogenerated type. AMQP specification method "file.consume".</summary>
 976   public interface IFileConsume: IMethod {
 977     ushort Ticket { get; }
 978     string Queue { get; }
 979     string ConsumerTag { get; }
 980     bool NoLocal { get; }
 981     bool NoAck { get; }
 982     bool Exclusive { get; }
 983     bool Nowait { get; }
 984   }
 985   /// <summary>Autogenerated type. AMQP specification method "file.consume-ok".</summary>
 986   public interface IFileConsumeOk: IMethod {
 987     string ConsumerTag { get; }
 988   }
 989   /// <summary>Autogenerated type. AMQP specification method "file.cancel".</summary>
 990   public interface IFileCancel: IMethod {
 991     string ConsumerTag { get; }
 992     bool Nowait { get; }
 993   }
 994   /// <summary>Autogenerated type. AMQP specification method "file.cancel-ok".</summary>
 995   public interface IFileCancelOk: IMethod {
 996     string ConsumerTag { get; }
 997   }
 998   /// <summary>Autogenerated type. AMQP specification method "file.open".</summary>
 999   public interface IFileOpen: IMethod {
1000     string Identifier { get; }
1001     ulong ContentSize { get; }
1002   }
1003   /// <summary>Autogenerated type. AMQP specification method "file.open-ok".</summary>
1004   public interface IFileOpenOk: IMethod {
1005     ulong StagedSize { get; }
1006   }
1007   /// <summary>Autogenerated type. AMQP specification method "file.stage".</summary>
1008   public interface IFileStage: IMethod {
1009   }
1010   /// <summary>Autogenerated type. AMQP specification method "file.publish".</summary>
1011   public interface IFilePublish: IMethod {
1012     ushort Ticket { get; }
1013     string Exchange { get; }
1014     string RoutingKey { get; }
1015     bool Mandatory { get; }
1016     bool Immediate { get; }
1017     string Identifier { get; }
1018   }
1019   /// <summary>Autogenerated type. AMQP specification method "file.return".</summary>
1020   public interface IFileReturn: IMethod {
1021     ushort ReplyCode { get; }
1022     string ReplyText { get; }
1023     string Exchange { get; }
1024     string RoutingKey { get; }
1025   }
1026   /// <summary>Autogenerated type. AMQP specification method "file.deliver".</summary>
1027   public interface IFileDeliver: IMethod {
1028     string ConsumerTag { get; }
1029     ulong DeliveryTag { get; }
1030     bool Redelivered { get; }
1031     string Exchange { get; }
1032     string RoutingKey { get; }
1033     string Identifier { get; }
1034   }
1035   /// <summary>Autogenerated type. AMQP specification method "file.ack".</summary>
1036   public interface IFileAck: IMethod {
1037     ulong DeliveryTag { get; }
1038     bool Multiple { get; }
1039   }
1040   /// <summary>Autogenerated type. AMQP specification method "file.reject".</summary>
1041   public interface IFileReject: IMethod {
1042     ulong DeliveryTag { get; }
1043     bool Requeue { get; }
1044   }
1045   /// <summary>Autogenerated type. AMQP specification method "stream.qos".</summary>
1046   public interface IStreamQos: IMethod {
1047     uint PrefetchSize { get; }
1048     ushort PrefetchCount { get; }
1049     uint ConsumeRate { get; }
1050     bool Global { get; }
1051   }
1052   /// <summary>Autogenerated type. AMQP specification method "stream.qos-ok".</summary>
1053   public interface IStreamQosOk: IMethod {
1054   }
1055   /// <summary>Autogenerated type. AMQP specification method "stream.consume".</summary>
1056   public interface IStreamConsume: IMethod {
1057     ushort Ticket { get; }
1058     string Queue { get; }
1059     string ConsumerTag { get; }
1060     bool NoLocal { get; }
1061     bool Exclusive { get; }
1062     bool Nowait { get; }
1063   }
1064   /// <summary>Autogenerated type. AMQP specification method "stream.consume-ok".</summary>
1065   public interface IStreamConsumeOk: IMethod {
1066     string ConsumerTag { get; }
1067   }
1068   /// <summary>Autogenerated type. AMQP specification method "stream.cancel".</summary>
1069   public interface IStreamCancel: IMethod {
1070     string ConsumerTag { get; }
1071     bool Nowait { get; }
1072   }
1073   /// <summary>Autogenerated type. AMQP specification method "stream.cancel-ok".</summary>
1074   public interface IStreamCancelOk: IMethod {
1075     string ConsumerTag { get; }
1076   }
1077   /// <summary>Autogenerated type. AMQP specification method "stream.publish".</summary>
1078   public interface IStreamPublish: IMethod {
1079     ushort Ticket { get; }
1080     string Exchange { get; }
1081     string RoutingKey { get; }
1082     bool Mandatory { get; }
1083     bool Immediate { get; }
1084   }
1085   /// <summary>Autogenerated type. AMQP specification method "stream.return".</summary>
1086   public interface IStreamReturn: IMethod {
1087     ushort ReplyCode { get; }
1088     string ReplyText { get; }
1089     string Exchange { get; }
1090     string RoutingKey { get; }
1091   }
1092   /// <summary>Autogenerated type. AMQP specification method "stream.deliver".</summary>
1093   public interface IStreamDeliver: IMethod {
1094     string ConsumerTag { get; }
1095     ulong DeliveryTag { get; }
1096     string Exchange { get; }
1097     string Queue { get; }
1098   }
1099   /// <summary>Autogenerated type. AMQP specification method "tx.select".</summary>
1100   public interface ITxSelect: IMethod {
1101   }
1102   /// <summary>Autogenerated type. AMQP specification method "tx.select-ok".</summary>
1103   public interface ITxSelectOk: IMethod {
1104   }
1105   /// <summary>Autogenerated type. AMQP specification method "tx.commit".</summary>
1106   public interface ITxCommit: IMethod {
1107   }
1108   /// <summary>Autogenerated type. AMQP specification method "tx.commit-ok".</summary>
1109   public interface ITxCommitOk: IMethod {
1110   }
1111   /// <summary>Autogenerated type. AMQP specification method "tx.rollback".</summary>
1112   public interface ITxRollback: IMethod {
1113   }
1114   /// <summary>Autogenerated type. AMQP specification method "tx.rollback-ok".</summary>
1115   public interface ITxRollbackOk: IMethod {
1116   }
1117   /// <summary>Autogenerated type. AMQP specification method "dtx.select".</summary>
1118   public interface IDtxSelect: IMethod {
1119   }
1120   /// <summary>Autogenerated type. AMQP specification method "dtx.select-ok".</summary>
1121   public interface IDtxSelectOk: IMethod {
1122   }
1123   /// <summary>Autogenerated type. AMQP specification method "dtx.start".</summary>
1124   public interface IDtxStart: IMethod {
1125     string DtxIdentifier { get; }
1126   }
1127   /// <summary>Autogenerated type. AMQP specification method "dtx.start-ok".</summary>
1128   public interface IDtxStartOk: IMethod {
1129   }
1130   /// <summary>Autogenerated type. AMQP specification method "tunnel.request".</summary>
1131   public interface ITunnelRequest: IMethod {
1132     System.Collections.IDictionary MetaData { get; }
1133   }
1134   /// <summary>Autogenerated type. AMQP specification method "test.integer".</summary>
1135   public interface ITestInteger: IMethod {
1136     byte Integer1 { get; }
1137     ushort Integer2 { get; }
1138     uint Integer3 { get; }
1139     ulong Integer4 { get; }
1140     byte Operation { get; }
1141   }
1142   /// <summary>Autogenerated type. AMQP specification method "test.integer-ok".</summary>
1143   public interface ITestIntegerOk: IMethod {
1144     ulong Result { get; }
1145   }
1146   /// <summary>Autogenerated type. AMQP specification method "test.string".</summary>
1147   public interface ITestString: IMethod {
1148     string String1 { get; }
1149     byte[] String2 { get; }
1150     byte Operation { get; }
1151   }
1152   /// <summary>Autogenerated type. AMQP specification method "test.string-ok".</summary>
1153   public interface ITestStringOk: IMethod {
1154     byte[] Result { get; }
1155   }
1156   /// <summary>Autogenerated type. AMQP specification method "test.table".</summary>
1157   public interface ITestTable: IMethod {
1158     System.Collections.IDictionary Table { get; }
1159     byte IntegerOp { get; }
1160     byte StringOp { get; }
1161   }
1162   /// <summary>Autogenerated type. AMQP specification method "test.table-ok".</summary>
1163   public interface ITestTableOk: IMethod {
1164     ulong IntegerResult { get; }
1165     byte[] StringResult { get; }
1166   }
1167   /// <summary>Autogenerated type. AMQP specification method "test.content".</summary>
1168   public interface ITestContent: IMethod {
1169   }
1170   /// <summary>Autogenerated type. AMQP specification method "test.content-ok".</summary>
1171   public interface ITestContentOk: IMethod {
1172     uint ContentChecksum { get; }
1173   }
1174   /// <summary>Autogenerated type. AMQP specification content header properties for content class "basic"</summary>
1175   public class BasicProperties: RabbitMQ.Client.Impl.BasicProperties {
1176     private string m_contentType;
1177     private string m_contentEncoding;
1178     private System.Collections.IDictionary m_headers;
1179     private byte m_deliveryMode;
1180     private byte m_priority;
1181     private string m_correlationId;
1182     private string m_replyTo;
1183     private string m_expiration;
1184     private string m_messageId;
1185     private AmqpTimestamp m_timestamp;
1186     private string m_type;
1187     private string m_userId;
1188     private string m_appId;
1189     private string m_clusterId;
1190
1191     private bool m_contentType_present = false;
1192     private bool m_contentEncoding_present = false;
1193     private bool m_headers_present = false;
1194     private bool m_deliveryMode_present = false;
1195     private bool m_priority_present = false;
1196     private bool m_correlationId_present = false;
1197     private bool m_replyTo_present = false;
1198     private bool m_expiration_present = false;
1199     private bool m_messageId_present = false;
1200     private bool m_timestamp_present = false;
1201     private bool m_type_present = false;
1202     private bool m_userId_present = false;
1203     private bool m_appId_present = false;
1204     private bool m_clusterId_present = false;
1205
1206     public override string ContentType {
1207       get {
1208         return m_contentType;
1209       }
1210       set {
1211         m_contentType_present = true;
1212         m_contentType = value;
1213       }
1214     }
1215     public override string ContentEncoding {
1216       get {
1217         return m_contentEncoding;
1218       }
1219       set {
1220         m_contentEncoding_present = true;
1221         m_contentEncoding = value;
1222       }
1223     }
1224     public override System.Collections.IDictionary Headers {
1225       get {
1226         return m_headers;
1227       }
1228       set {
1229         m_headers_present = true;
1230         m_headers = value;
1231       }
1232     }
1233     public override byte DeliveryMode {
1234       get {
1235         return m_deliveryMode;
1236       }
1237       set {
1238         m_deliveryMode_present = true;
1239         m_deliveryMode = value;
1240       }
1241     }
1242     public override byte Priority {
1243       get {
1244         return m_priority;
1245       }
1246       set {
1247         m_priority_present = true;
1248         m_priority = value;
1249       }
1250     }
1251     public override string CorrelationId {
1252       get {
1253         return m_correlationId;
1254       }
1255       set {
1256         m_correlationId_present = true;
1257         m_correlationId = value;
1258       }
1259     }
1260     public override string ReplyTo {
1261       get {
1262         return m_replyTo;
1263       }
1264       set {
1265         m_replyTo_present = true;
1266         m_replyTo = value;
1267       }
1268     }
1269     public override string Expiration {
1270       get {
1271         return m_expiration;
1272       }
1273       set {
1274         m_expiration_present = true;
1275         m_expiration = value;
1276       }
1277     }
1278     public override string MessageId {
1279       get {
1280         return m_messageId;
1281       }
1282       set {
1283         m_messageId_present = true;
1284         m_messageId = value;
1285       }
1286     }
1287     public override AmqpTimestamp Timestamp {
1288       get {
1289         return m_timestamp;
1290       }
1291       set {
1292         m_timestamp_present = true;
1293         m_timestamp = value;
1294       }
1295     }
1296     public override string Type {
1297       get {
1298         return m_type;
1299       }
1300       set {
1301         m_type_present = true;
1302         m_type = value;
1303       }
1304     }
1305     public override string UserId {
1306       get {
1307         return m_userId;
1308       }
1309       set {
1310         m_userId_present = true;
1311         m_userId = value;
1312       }
1313     }
1314     public override string AppId {
1315       get {
1316         return m_appId;
1317       }
1318       set {
1319         m_appId_present = true;
1320         m_appId = value;
1321       }
1322     }
1323     public override string ClusterId {
1324       get {
1325         return m_clusterId;
1326       }
1327       set {
1328         m_clusterId_present = true;
1329         m_clusterId = value;
1330       }
1331     }
1332
1333     public override void ClearContentType() { m_contentType_present = false; }
1334     public override void ClearContentEncoding() { m_contentEncoding_present = false; }
1335     public override void ClearHeaders() { m_headers_present = false; }
1336     public override void ClearDeliveryMode() { m_deliveryMode_present = false; }
1337     public override void ClearPriority() { m_priority_present = false; }
1338     public override void ClearCorrelationId() { m_correlationId_present = false; }
1339     public override void ClearReplyTo() { m_replyTo_present = false; }
1340     public override void ClearExpiration() { m_expiration_present = false; }
1341     public override void ClearMessageId() { m_messageId_present = false; }
1342     public override void ClearTimestamp() { m_timestamp_present = false; }
1343     public override void ClearType() { m_type_present = false; }
1344     public override void ClearUserId() { m_userId_present = false; }
1345     public override void ClearAppId() { m_appId_present = false; }
1346     public override void ClearClusterId() { m_clusterId_present = false; }
1347
1348     public override bool IsContentTypePresent() { return m_contentType_present; }
1349     public override bool IsContentEncodingPresent() { return m_contentEncoding_present; }
1350     public override bool IsHeadersPresent() { return m_headers_present; }
1351     public override bool IsDeliveryModePresent() { return m_deliveryMode_present; }
1352     public override bool IsPriorityPresent() { return m_priority_present; }
1353     public override bool IsCorrelationIdPresent() { return m_correlationId_present; }
1354     public override bool IsReplyToPresent() { return m_replyTo_present; }
1355     public override bool IsExpirationPresent() { return m_expiration_present; }
1356     public override bool IsMessageIdPresent() { return m_messageId_present; }
1357     public override bool IsTimestampPresent() { return m_timestamp_present; }
1358     public override bool IsTypePresent() { return m_type_present; }
1359     public override bool IsUserIdPresent() { return m_userId_present; }
1360     public override bool IsAppIdPresent() { return m_appId_present; }
1361     public override bool IsClusterIdPresent() { return m_clusterId_present; }
1362
1363     public BasicProperties() {}
1364     public override int ProtocolClassId { get { return 60; } }
1365     public override string ProtocolClassName { get { return "basic"; } }
1366
1367     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
1368       m_contentType_present = reader.ReadPresence();
1369       m_contentEncoding_present = reader.ReadPresence();
1370       m_headers_present = reader.ReadPresence();
1371       m_deliveryMode_present = reader.ReadPresence();
1372       m_priority_present = reader.ReadPresence();
1373       m_correlationId_present = reader.ReadPresence();
1374       m_replyTo_present = reader.ReadPresence();
1375       m_expiration_present = reader.ReadPresence();
1376       m_messageId_present = reader.ReadPresence();
1377       m_timestamp_present = reader.ReadPresence();
1378       m_type_present = reader.ReadPresence();
1379       m_userId_present = reader.ReadPresence();
1380       m_appId_present = reader.ReadPresence();
1381       m_clusterId_present = reader.ReadPresence();
1382       reader.FinishPresence();
1383       if (m_contentType_present) { m_contentType = reader.ReadShortstr(); }
1384       if (m_contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
1385       if (m_headers_present) { m_headers = reader.ReadTable(); }
1386       if (m_deliveryMode_present) { m_deliveryMode = reader.ReadOctet(); }
1387       if (m_priority_present) { m_priority = reader.ReadOctet(); }
1388       if (m_correlationId_present) { m_correlationId = reader.ReadShortstr(); }
1389       if (m_replyTo_present) { m_replyTo = reader.ReadShortstr(); }
1390       if (m_expiration_present) { m_expiration = reader.ReadShortstr(); }
1391       if (m_messageId_present) { m_messageId = reader.ReadShortstr(); }
1392       if (m_timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
1393       if (m_type_present) { m_type = reader.ReadShortstr(); }
1394       if (m_userId_present) { m_userId = reader.ReadShortstr(); }
1395       if (m_appId_present) { m_appId = reader.ReadShortstr(); }
1396       if (m_clusterId_present) { m_clusterId = reader.ReadShortstr(); }
1397     }
1398
1399     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
1400       writer.WritePresence(m_contentType_present);
1401       writer.WritePresence(m_contentEncoding_present);
1402       writer.WritePresence(m_headers_present);
1403       writer.WritePresence(m_deliveryMode_present);
1404       writer.WritePresence(m_priority_present);
1405       writer.WritePresence(m_correlationId_present);
1406       writer.WritePresence(m_replyTo_present);
1407       writer.WritePresence(m_expiration_present);
1408       writer.WritePresence(m_messageId_present);
1409       writer.WritePresence(m_timestamp_present);
1410       writer.WritePresence(m_type_present);
1411       writer.WritePresence(m_userId_present);
1412       writer.WritePresence(m_appId_present);
1413       writer.WritePresence(m_clusterId_present);
1414       writer.FinishPresence();
1415       if (m_contentType_present) { writer.WriteShortstr(m_contentType); }
1416       if (m_contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
1417       if (m_headers_present) { writer.WriteTable(m_headers); }
1418       if (m_deliveryMode_present) { writer.WriteOctet(m_deliveryMode); }
1419       if (m_priority_present) { writer.WriteOctet(m_priority); }
1420       if (m_correlationId_present) { writer.WriteShortstr(m_correlationId); }
1421       if (m_replyTo_present) { writer.WriteShortstr(m_replyTo); }
1422       if (m_expiration_present) { writer.WriteShortstr(m_expiration); }
1423       if (m_messageId_present) { writer.WriteShortstr(m_messageId); }
1424       if (m_timestamp_present) { writer.WriteTimestamp(m_timestamp); }
1425       if (m_type_present) { writer.WriteShortstr(m_type); }
1426       if (m_userId_present) { writer.WriteShortstr(m_userId); }
1427       if (m_appId_present) { writer.WriteShortstr(m_appId); }
1428       if (m_clusterId_present) { writer.WriteShortstr(m_clusterId); }
1429     }
1430
1431     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
1432       sb.Append("(");
1433       sb.Append("content type="); sb.Append(m_contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
1434       sb.Append("content encoding="); sb.Append(m_contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
1435       sb.Append("headers="); sb.Append(m_headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
1436       sb.Append("delivery mode="); sb.Append(m_deliveryMode_present ? m_deliveryMode.ToString() : "_"); sb.Append(", ");
1437       sb.Append("priority="); sb.Append(m_priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
1438       sb.Append("correlation id="); sb.Append(m_correlationId_present ? (m_correlationId == null ? "(null)" : m_correlationId.ToString()) : "_"); sb.Append(", ");
1439       sb.Append("reply to="); sb.Append(m_replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
1440       sb.Append("expiration="); sb.Append(m_expiration_present ? (m_expiration == null ? "(null)" : m_expiration.ToString()) : "_"); sb.Append(", ");
1441       sb.Append("message id="); sb.Append(m_messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
1442       sb.Append("timestamp="); sb.Append(m_timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
1443       sb.Append("type="); sb.Append(m_type_present ? (m_type == null ? "(null)" : m_type.ToString()) : "_"); sb.Append(", ");
1444       sb.Append("user id="); sb.Append(m_userId_present ? (m_userId == null ? "(null)" : m_userId.ToString()) : "_"); sb.Append(", ");
1445       sb.Append("app id="); sb.Append(m_appId_present ? (m_appId == null ? "(null)" : m_appId.ToString()) : "_"); sb.Append(", ");
1446       sb.Append("cluster id="); sb.Append(m_clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
1447       sb.Append(")");
1448     }
1449   }
1450   /// <summary>Autogenerated type. AMQP specification content header properties for content class "file"</summary>
1451   public class FileProperties: RabbitMQ.Client.Impl.FileProperties {
1452     private string m_contentType;
1453     private string m_contentEncoding;
1454     private System.Collections.IDictionary m_headers;
1455     private byte m_priority;
1456     private string m_replyTo;
1457     private string m_messageId;
1458     private string m_filename;
1459     private AmqpTimestamp m_timestamp;
1460     private string m_clusterId;
1461
1462     private bool m_contentType_present = false;
1463     private bool m_contentEncoding_present = false;
1464     private bool m_headers_present = false;
1465     private bool m_priority_present = false;
1466     private bool m_replyTo_present = false;
1467     private bool m_messageId_present = false;
1468     private bool m_filename_present = false;
1469     private bool m_timestamp_present = false;
1470     private bool m_clusterId_present = false;
1471
1472     public override string ContentType {
1473       get {
1474         return m_contentType;
1475       }
1476       set {
1477         m_contentType_present = true;
1478         m_contentType = value;
1479       }
1480     }
1481     public override string ContentEncoding {
1482       get {
1483         return m_contentEncoding;
1484       }
1485       set {
1486         m_contentEncoding_present = true;
1487         m_contentEncoding = value;
1488       }
1489     }
1490     public override System.Collections.IDictionary Headers {
1491       get {
1492         return m_headers;
1493       }
1494       set {
1495         m_headers_present = true;
1496         m_headers = value;
1497       }
1498     }
1499     public override byte Priority {
1500       get {
1501         return m_priority;
1502       }
1503       set {
1504         m_priority_present = true;
1505         m_priority = value;
1506       }
1507     }
1508     public override string ReplyTo {
1509       get {
1510         return m_replyTo;
1511       }
1512       set {
1513         m_replyTo_present = true;
1514         m_replyTo = value;
1515       }
1516     }
1517     public override string MessageId {
1518       get {
1519         return m_messageId;
1520       }
1521       set {
1522         m_messageId_present = true;
1523         m_messageId = value;
1524       }
1525     }
1526     public override string Filename {
1527       get {
1528         return m_filename;
1529       }
1530       set {
1531         m_filename_present = true;
1532         m_filename = value;
1533       }
1534     }
1535     public override AmqpTimestamp Timestamp {
1536       get {
1537         return m_timestamp;
1538       }
1539       set {
1540         m_timestamp_present = true;
1541         m_timestamp = value;
1542       }
1543     }
1544     public override string ClusterId {
1545       get {
1546         return m_clusterId;
1547       }
1548       set {
1549         m_clusterId_present = true;
1550         m_clusterId = value;
1551       }
1552     }
1553
1554     public override void ClearContentType() { m_contentType_present = false; }
1555     public override void ClearContentEncoding() { m_contentEncoding_present = false; }
1556     public override void ClearHeaders() { m_headers_present = false; }
1557     public override void ClearPriority() { m_priority_present = false; }
1558     public override void ClearReplyTo() { m_replyTo_present = false; }
1559     public override void ClearMessageId() { m_messageId_present = false; }
1560     public override void ClearFilename() { m_filename_present = false; }
1561     public override void ClearTimestamp() { m_timestamp_present = false; }
1562     public override void ClearClusterId() { m_clusterId_present = false; }
1563
1564     public override bool IsContentTypePresent() { return m_contentType_present; }
1565     public override bool IsContentEncodingPresent() { return m_contentEncoding_present; }
1566     public override bool IsHeadersPresent() { return m_headers_present; }
1567     public override bool IsPriorityPresent() { return m_priority_present; }
1568     public override bool IsReplyToPresent() { return m_replyTo_present; }
1569     public override bool IsMessageIdPresent() { return m_messageId_present; }
1570     public override bool IsFilenamePresent() { return m_filename_present; }
1571     public override bool IsTimestampPresent() { return m_timestamp_present; }
1572     public override bool IsClusterIdPresent() { return m_clusterId_present; }
1573
1574     public FileProperties() {}
1575     public override int ProtocolClassId { get { return 70; } }
1576     public override string ProtocolClassName { get { return "file"; } }
1577
1578     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
1579       m_contentType_present = reader.ReadPresence();
1580       m_contentEncoding_present = reader.ReadPresence();
1581       m_headers_present = reader.ReadPresence();
1582       m_priority_present = reader.ReadPresence();
1583       m_replyTo_present = reader.ReadPresence();
1584       m_messageId_present = reader.ReadPresence();
1585       m_filename_present = reader.ReadPresence();
1586       m_timestamp_present = reader.ReadPresence();
1587       m_clusterId_present = reader.ReadPresence();
1588       reader.FinishPresence();
1589       if (m_contentType_present) { m_contentType = reader.ReadShortstr(); }
1590       if (m_contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
1591       if (m_headers_present) { m_headers = reader.ReadTable(); }
1592       if (m_priority_present) { m_priority = reader.ReadOctet(); }
1593       if (m_replyTo_present) { m_replyTo = reader.ReadShortstr(); }
1594       if (m_messageId_present) { m_messageId = reader.ReadShortstr(); }
1595       if (m_filename_present) { m_filename = reader.ReadShortstr(); }
1596       if (m_timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
1597       if (m_clusterId_present) { m_clusterId = reader.ReadShortstr(); }
1598     }
1599
1600     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
1601       writer.WritePresence(m_contentType_present);
1602       writer.WritePresence(m_contentEncoding_present);
1603       writer.WritePresence(m_headers_present);
1604       writer.WritePresence(m_priority_present);
1605       writer.WritePresence(m_replyTo_present);
1606       writer.WritePresence(m_messageId_present);
1607       writer.WritePresence(m_filename_present);
1608       writer.WritePresence(m_timestamp_present);
1609       writer.WritePresence(m_clusterId_present);
1610       writer.FinishPresence();
1611       if (m_contentType_present) { writer.WriteShortstr(m_contentType); }
1612       if (m_contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
1613       if (m_headers_present) { writer.WriteTable(m_headers); }
1614       if (m_priority_present) { writer.WriteOctet(m_priority); }
1615       if (m_replyTo_present) { writer.WriteShortstr(m_replyTo); }
1616       if (m_messageId_present) { writer.WriteShortstr(m_messageId); }
1617       if (m_filename_present) { writer.WriteShortstr(m_filename); }
1618       if (m_timestamp_present) { writer.WriteTimestamp(m_timestamp); }
1619       if (m_clusterId_present) { writer.WriteShortstr(m_clusterId); }
1620     }
1621
1622     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
1623       sb.Append("(");
1624       sb.Append("content type="); sb.Append(m_contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
1625       sb.Append("content encoding="); sb.Append(m_contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
1626       sb.Append("headers="); sb.Append(m_headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
1627       sb.Append("priority="); sb.Append(m_priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
1628       sb.Append("reply to="); sb.Append(m_replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
1629       sb.Append("message id="); sb.Append(m_messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
1630       sb.Append("filename="); sb.Append(m_filename_present ? (m_filename == null ? "(null)" : m_filename.ToString()) : "_"); sb.Append(", ");
1631       sb.Append("timestamp="); sb.Append(m_timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
1632       sb.Append("cluster id="); sb.Append(m_clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
1633       sb.Append(")");
1634     }
1635   }
1636   /// <summary>Autogenerated type. AMQP specification content header properties for content class "stream"</summary>
1637   public class StreamProperties: RabbitMQ.Client.Impl.StreamProperties {
1638     private string m_contentType;
1639     private string m_contentEncoding;
1640     private System.Collections.IDictionary m_headers;
1641     private byte m_priority;
1642     private AmqpTimestamp m_timestamp;
1643
1644     private bool m_contentType_present = false;
1645     private bool m_contentEncoding_present = false;
1646     private bool m_headers_present = false;
1647     private bool m_priority_present = false;
1648     private bool m_timestamp_present = false;
1649
1650     public override string ContentType {
1651       get {
1652         return m_contentType;
1653       }
1654       set {
1655         m_contentType_present = true;
1656         m_contentType = value;
1657       }
1658     }
1659     public override string ContentEncoding {
1660       get {
1661         return m_contentEncoding;
1662       }
1663       set {
1664         m_contentEncoding_present = true;
1665         m_contentEncoding = value;
1666       }
1667     }
1668     public override System.Collections.IDictionary Headers {
1669       get {
1670         return m_headers;
1671       }
1672       set {
1673         m_headers_present = true;
1674         m_headers = value;
1675       }
1676     }
1677     public override byte Priority {
1678       get {
1679         return m_priority;
1680       }
1681       set {
1682         m_priority_present = true;
1683         m_priority = value;
1684       }
1685     }
1686     public override AmqpTimestamp Timestamp {
1687       get {
1688         return m_timestamp;
1689       }
1690       set {
1691         m_timestamp_present = true;
1692         m_timestamp = value;
1693       }
1694     }
1695
1696     public override void ClearContentType() { m_contentType_present = false; }
1697     public override void ClearContentEncoding() { m_contentEncoding_present = false; }
1698     public override void ClearHeaders() { m_headers_present = false; }
1699     public override void ClearPriority() { m_priority_present = false; }
1700     public override void ClearTimestamp() { m_timestamp_present = false; }
1701
1702     public override bool IsContentTypePresent() { return m_contentType_present; }
1703     public override bool IsContentEncodingPresent() { return m_contentEncoding_present; }
1704     public override bool IsHeadersPresent() { return m_headers_present; }
1705     public override bool IsPriorityPresent() { return m_priority_present; }
1706     public override bool IsTimestampPresent() { return m_timestamp_present; }
1707
1708     public StreamProperties() {}
1709     public override int ProtocolClassId { get { return 80; } }
1710     public override string ProtocolClassName { get { return "stream"; } }
1711
1712     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
1713       m_contentType_present = reader.ReadPresence();
1714       m_contentEncoding_present = reader.ReadPresence();
1715       m_headers_present = reader.ReadPresence();
1716       m_priority_present = reader.ReadPresence();
1717       m_timestamp_present = reader.ReadPresence();
1718       reader.FinishPresence();
1719       if (m_contentType_present) { m_contentType = reader.ReadShortstr(); }
1720       if (m_contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
1721       if (m_headers_present) { m_headers = reader.ReadTable(); }
1722       if (m_priority_present) { m_priority = reader.ReadOctet(); }
1723       if (m_timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
1724     }
1725
1726     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
1727       writer.WritePresence(m_contentType_present);
1728       writer.WritePresence(m_contentEncoding_present);
1729       writer.WritePresence(m_headers_present);
1730       writer.WritePresence(m_priority_present);
1731       writer.WritePresence(m_timestamp_present);
1732       writer.FinishPresence();
1733       if (m_contentType_present) { writer.WriteShortstr(m_contentType); }
1734       if (m_contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
1735       if (m_headers_present) { writer.WriteTable(m_headers); }
1736       if (m_priority_present) { writer.WriteOctet(m_priority); }
1737       if (m_timestamp_present) { writer.WriteTimestamp(m_timestamp); }
1738     }
1739
1740     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
1741       sb.Append("(");
1742       sb.Append("content type="); sb.Append(m_contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
1743       sb.Append("content encoding="); sb.Append(m_contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
1744       sb.Append("headers="); sb.Append(m_headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
1745       sb.Append("priority="); sb.Append(m_priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
1746       sb.Append("timestamp="); sb.Append(m_timestamp_present ? m_timestamp.ToString() : "_");
1747       sb.Append(")");
1748     }
1749   }
1750   /// <summary>Autogenerated type. AMQP specification content header properties for content class "tunnel"</summary>
1751   public class TunnelProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
1752     private System.Collections.IDictionary m_headers;
1753     private string m_proxyName;
1754     private string m_dataName;
1755     private byte m_durable;
1756     private byte m_broadcast;
1757
1758     private bool m_headers_present = false;
1759     private bool m_proxyName_present = false;
1760     private bool m_dataName_present = false;
1761     private bool m_durable_present = false;
1762     private bool m_broadcast_present = false;
1763
1764     public System.Collections.IDictionary Headers {
1765       get {
1766         return m_headers;
1767       }
1768       set {
1769         m_headers_present = true;
1770         m_headers = value;
1771       }
1772     }
1773     public string ProxyName {
1774       get {
1775         return m_proxyName;
1776       }
1777       set {
1778         m_proxyName_present = true;
1779         m_proxyName = value;
1780       }
1781     }
1782     public string DataName {
1783       get {
1784         return m_dataName;
1785       }
1786       set {
1787         m_dataName_present = true;
1788         m_dataName = value;
1789       }
1790     }
1791     public byte Durable {
1792       get {
1793         return m_durable;
1794       }
1795       set {
1796         m_durable_present = true;
1797         m_durable = value;
1798       }
1799     }
1800     public byte Broadcast {
1801       get {
1802         return m_broadcast;
1803       }
1804       set {
1805         m_broadcast_present = true;
1806         m_broadcast = value;
1807       }
1808     }
1809
1810     public void ClearHeaders() { m_headers_present = false; }
1811     public void ClearProxyName() { m_proxyName_present = false; }
1812     public void ClearDataName() { m_dataName_present = false; }
1813     public void ClearDurable() { m_durable_present = false; }
1814     public void ClearBroadcast() { m_broadcast_present = false; }
1815
1816     public bool IsHeadersPresent() { return m_headers_present; }
1817     public bool IsProxyNamePresent() { return m_proxyName_present; }
1818     public bool IsDataNamePresent() { return m_dataName_present; }
1819     public bool IsDurablePresent() { return m_durable_present; }
1820     public bool IsBroadcastPresent() { return m_broadcast_present; }
1821
1822     public TunnelProperties() {}
1823     public override int ProtocolClassId { get { return 110; } }
1824     public override string ProtocolClassName { get { return "tunnel"; } }
1825
1826     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
1827       m_headers_present = reader.ReadPresence();
1828       m_proxyName_present = reader.ReadPresence();
1829       m_dataName_present = reader.ReadPresence();
1830       m_durable_present = reader.ReadPresence();
1831       m_broadcast_present = reader.ReadPresence();
1832       reader.FinishPresence();
1833       if (m_headers_present) { m_headers = reader.ReadTable(); }
1834       if (m_proxyName_present) { m_proxyName = reader.ReadShortstr(); }
1835       if (m_dataName_present) { m_dataName = reader.ReadShortstr(); }
1836       if (m_durable_present) { m_durable = reader.ReadOctet(); }
1837       if (m_broadcast_present) { m_broadcast = reader.ReadOctet(); }
1838     }
1839
1840     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
1841       writer.WritePresence(m_headers_present);
1842       writer.WritePresence(m_proxyName_present);
1843       writer.WritePresence(m_dataName_present);
1844       writer.WritePresence(m_durable_present);
1845       writer.WritePresence(m_broadcast_present);
1846       writer.FinishPresence();
1847       if (m_headers_present) { writer.WriteTable(m_headers); }
1848       if (m_proxyName_present) { writer.WriteShortstr(m_proxyName); }
1849       if (m_dataName_present) { writer.WriteShortstr(m_dataName); }
1850       if (m_durable_present) { writer.WriteOctet(m_durable); }
1851       if (m_broadcast_present) { writer.WriteOctet(m_broadcast); }
1852     }
1853
1854     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
1855       sb.Append("(");
1856       sb.Append("headers="); sb.Append(m_headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
1857       sb.Append("proxy name="); sb.Append(m_proxyName_present ? (m_proxyName == null ? "(null)" : m_proxyName.ToString()) : "_"); sb.Append(", ");
1858       sb.Append("data name="); sb.Append(m_dataName_present ? (m_dataName == null ? "(null)" : m_dataName.ToString()) : "_"); sb.Append(", ");
1859       sb.Append("durable="); sb.Append(m_durable_present ? m_durable.ToString() : "_"); sb.Append(", ");
1860       sb.Append("broadcast="); sb.Append(m_broadcast_present ? m_broadcast.ToString() : "_");
1861       sb.Append(")");
1862     }
1863   }
1864   /// <summary>Autogenerated type. AMQP specification content header properties for content class "test"</summary>
1865   public class TestProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
1866
1867
1868
1869
1870
1871     public TestProperties() {}
1872     public override int ProtocolClassId { get { return 120; } }
1873     public override string ProtocolClassName { get { return "test"; } }
1874
1875     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
1876       reader.FinishPresence();
1877     }
1878
1879     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
1880       writer.FinishPresence();
1881     }
1882
1883     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
1884       sb.Append("(");
1885       sb.Append(")");
1886     }
1887   }
1888 }
1889 namespace RabbitMQ.Client.Framing.Impl.v0_8qpid {
1890   using RabbitMQ.Client.Framing.v0_8qpid;
1891   public enum ClassId {
1892     Connection = 10,
1893     Channel = 20,
1894     Access = 30,
1895     Exchange = 40,
1896     Queue = 50,
1897     Basic = 60,
1898     File = 70,
1899     Stream = 80,
1900     Tx = 90,
1901     Dtx = 100,
1902     Tunnel = 110,
1903     Test = 120,
1904     Invalid = -1
1905   }
1906   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
1907   public class ConnectionStart: RabbitMQ.Client.Impl.MethodBase, IConnectionStart {
1908     public const int ClassId = 10;
1909     public const int MethodId = 10;
1910
1911     public byte m_versionMajor;
1912     public byte m_versionMinor;
1913     public System.Collections.IDictionary m_serverProperties;
1914     public byte[] m_mechanisms;
1915     public byte[] m_locales;
1916
1917     byte IConnectionStart.VersionMajor { get { return m_versionMajor; } }
1918     byte IConnectionStart.VersionMinor { get { return m_versionMinor; } }
1919     System.Collections.IDictionary IConnectionStart.ServerProperties { get { return m_serverProperties; } }
1920     byte[] IConnectionStart.Mechanisms { get { return m_mechanisms; } }
1921     byte[] IConnectionStart.Locales { get { return m_locales; } }
1922
1923     public ConnectionStart() {}
1924     public ConnectionStart(
1925       byte initVersionMajor,
1926       byte initVersionMinor,
1927       System.Collections.IDictionary initServerProperties,
1928       byte[] initMechanisms,
1929       byte[] initLocales)
1930     {
1931       m_versionMajor = initVersionMajor;
1932       m_versionMinor = initVersionMinor;
1933       m_serverProperties = initServerProperties;
1934       m_mechanisms = initMechanisms;
1935       m_locales = initLocales;
1936     }
1937
1938     public override int ProtocolClassId { get { return 10; } }
1939     public override int ProtocolMethodId { get { return 10; } }
1940     public override string ProtocolMethodName { get { return "connection.start"; } }
1941     public override bool HasContent { get { return false; } }
1942
1943     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
1944       m_versionMajor = reader.ReadOctet();
1945       m_versionMinor = reader.ReadOctet();
1946       m_serverProperties = reader.ReadTable();
1947       m_mechanisms = reader.ReadLongstr();
1948       m_locales = reader.ReadLongstr();
1949     }
1950
1951     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
1952       writer.WriteOctet(m_versionMajor);
1953       writer.WriteOctet(m_versionMinor);
1954       writer.WriteTable(m_serverProperties);
1955       writer.WriteLongstr(m_mechanisms);
1956       writer.WriteLongstr(m_locales);
1957     }
1958
1959     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
1960       sb.Append("(");
1961       sb.Append(m_versionMajor); sb.Append(",");
1962       sb.Append(m_versionMinor); sb.Append(",");
1963       sb.Append(m_serverProperties); sb.Append(",");
1964       sb.Append(m_mechanisms); sb.Append(",");
1965       sb.Append(m_locales);
1966       sb.Append(")");
1967     }
1968   }
1969   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
1970   public class ConnectionStartOk: RabbitMQ.Client.Impl.MethodBase, IConnectionStartOk {
1971     public const int ClassId = 10;
1972     public const int MethodId = 11;
1973
1974     public System.Collections.IDictionary m_clientProperties;
1975     public string m_mechanism;
1976     public byte[] m_response;
1977     public string m_locale;
1978
1979     System.Collections.IDictionary IConnectionStartOk.ClientProperties { get { return m_clientProperties; } }
1980     string IConnectionStartOk.Mechanism { get { return m_mechanism; } }
1981     byte[] IConnectionStartOk.Response { get { return m_response; } }
1982     string IConnectionStartOk.Locale { get { return m_locale; } }
1983
1984     public ConnectionStartOk() {}
1985     public ConnectionStartOk(
1986       System.Collections.IDictionary initClientProperties,
1987       string initMechanism,
1988       byte[] initResponse,
1989       string initLocale)
1990     {
1991       m_clientProperties = initClientProperties;
1992       m_mechanism = initMechanism;
1993       m_response = initResponse;
1994       m_locale = initLocale;
1995     }
1996
1997     public override int ProtocolClassId { get { return 10; } }
1998     public override int ProtocolMethodId { get { return 11; } }
1999     public override string ProtocolMethodName { get { return "connection.start-ok"; } }
2000     public override bool HasContent { get { return false; } }
2001
2002     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2003       m_clientProperties = reader.ReadTable();
2004       m_mechanism = reader.ReadShortstr();
2005       m_response = reader.ReadLongstr();
2006       m_locale = reader.ReadShortstr();
2007     }
2008
2009     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2010       writer.WriteTable(m_clientProperties);
2011       writer.WriteShortstr(m_mechanism);
2012       writer.WriteLongstr(m_response);
2013       writer.WriteShortstr(m_locale);
2014     }
2015
2016     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2017       sb.Append("(");
2018       sb.Append(m_clientProperties); sb.Append(",");
2019       sb.Append(m_mechanism); sb.Append(",");
2020       sb.Append(m_response); sb.Append(",");
2021       sb.Append(m_locale);
2022       sb.Append(")");
2023     }
2024   }
2025   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2026   public class ConnectionSecure: RabbitMQ.Client.Impl.MethodBase, IConnectionSecure {
2027     public const int ClassId = 10;
2028     public const int MethodId = 20;
2029
2030     public byte[] m_challenge;
2031
2032     byte[] IConnectionSecure.Challenge { get { return m_challenge; } }
2033
2034     public ConnectionSecure() {}
2035     public ConnectionSecure(
2036       byte[] initChallenge)
2037     {
2038       m_challenge = initChallenge;
2039     }
2040
2041     public override int ProtocolClassId { get { return 10; } }
2042     public override int ProtocolMethodId { get { return 20; } }
2043     public override string ProtocolMethodName { get { return "connection.secure"; } }
2044     public override bool HasContent { get { return false; } }
2045
2046     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2047       m_challenge = reader.ReadLongstr();
2048     }
2049
2050     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2051       writer.WriteLongstr(m_challenge);
2052     }
2053
2054     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2055       sb.Append("(");
2056       sb.Append(m_challenge);
2057       sb.Append(")");
2058     }
2059   }
2060   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2061   public class ConnectionSecureOk: RabbitMQ.Client.Impl.MethodBase, IConnectionSecureOk {
2062     public const int ClassId = 10;
2063     public const int MethodId = 21;
2064
2065     public byte[] m_response;
2066
2067     byte[] IConnectionSecureOk.Response { get { return m_response; } }
2068
2069     public ConnectionSecureOk() {}
2070     public ConnectionSecureOk(
2071       byte[] initResponse)
2072     {
2073       m_response = initResponse;
2074     }
2075
2076     public override int ProtocolClassId { get { return 10; } }
2077     public override int ProtocolMethodId { get { return 21; } }
2078     public override string ProtocolMethodName { get { return "connection.secure-ok"; } }
2079     public override bool HasContent { get { return false; } }
2080
2081     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2082       m_response = reader.ReadLongstr();
2083     }
2084
2085     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2086       writer.WriteLongstr(m_response);
2087     }
2088
2089     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2090       sb.Append("(");
2091       sb.Append(m_response);
2092       sb.Append(")");
2093     }
2094   }
2095   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2096   public class ConnectionTune: RabbitMQ.Client.Impl.MethodBase, IConnectionTune {
2097     public const int ClassId = 10;
2098     public const int MethodId = 30;
2099
2100     public ushort m_channelMax;
2101     public uint m_frameMax;
2102     public ushort m_heartbeat;
2103
2104     ushort IConnectionTune.ChannelMax { get { return m_channelMax; } }
2105     uint IConnectionTune.FrameMax { get { return m_frameMax; } }
2106     ushort IConnectionTune.Heartbeat { get { return m_heartbeat; } }
2107
2108     public ConnectionTune() {}
2109     public ConnectionTune(
2110       ushort initChannelMax,
2111       uint initFrameMax,
2112       ushort initHeartbeat)
2113     {
2114       m_channelMax = initChannelMax;
2115       m_frameMax = initFrameMax;
2116       m_heartbeat = initHeartbeat;
2117     }
2118
2119     public override int ProtocolClassId { get { return 10; } }
2120     public override int ProtocolMethodId { get { return 30; } }
2121     public override string ProtocolMethodName { get { return "connection.tune"; } }
2122     public override bool HasContent { get { return false; } }
2123
2124     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2125       m_channelMax = reader.ReadShort();
2126       m_frameMax = reader.ReadLong();
2127       m_heartbeat = reader.ReadShort();
2128     }
2129
2130     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2131       writer.WriteShort(m_channelMax);
2132       writer.WriteLong(m_frameMax);
2133       writer.WriteShort(m_heartbeat);
2134     }
2135
2136     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2137       sb.Append("(");
2138       sb.Append(m_channelMax); sb.Append(",");
2139       sb.Append(m_frameMax); sb.Append(",");
2140       sb.Append(m_heartbeat);
2141       sb.Append(")");
2142     }
2143   }
2144   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2145   public class ConnectionTuneOk: RabbitMQ.Client.Impl.MethodBase, IConnectionTuneOk {
2146     public const int ClassId = 10;
2147     public const int MethodId = 31;
2148
2149     public ushort m_channelMax;
2150     public uint m_frameMax;
2151     public ushort m_heartbeat;
2152
2153     ushort IConnectionTuneOk.ChannelMax { get { return m_channelMax; } }
2154     uint IConnectionTuneOk.FrameMax { get { return m_frameMax; } }
2155     ushort IConnectionTuneOk.Heartbeat { get { return m_heartbeat; } }
2156
2157     public ConnectionTuneOk() {}
2158     public ConnectionTuneOk(
2159       ushort initChannelMax,
2160       uint initFrameMax,
2161       ushort initHeartbeat)
2162     {
2163       m_channelMax = initChannelMax;
2164       m_frameMax = initFrameMax;
2165       m_heartbeat = initHeartbeat;
2166     }
2167
2168     public override int ProtocolClassId { get { return 10; } }
2169     public override int ProtocolMethodId { get { return 31; } }
2170     public override string ProtocolMethodName { get { return "connection.tune-ok"; } }
2171     public override bool HasContent { get { return false; } }
2172
2173     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2174       m_channelMax = reader.ReadShort();
2175       m_frameMax = reader.ReadLong();
2176       m_heartbeat = reader.ReadShort();
2177     }
2178
2179     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2180       writer.WriteShort(m_channelMax);
2181       writer.WriteLong(m_frameMax);
2182       writer.WriteShort(m_heartbeat);
2183     }
2184
2185     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2186       sb.Append("(");
2187       sb.Append(m_channelMax); sb.Append(",");
2188       sb.Append(m_frameMax); sb.Append(",");
2189       sb.Append(m_heartbeat);
2190       sb.Append(")");
2191     }
2192   }
2193   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2194   public class ConnectionOpen: RabbitMQ.Client.Impl.MethodBase, IConnectionOpen {
2195     public const int ClassId = 10;
2196     public const int MethodId = 40;
2197
2198     public string m_virtualHost;
2199     public string m_capabilities;
2200     public bool m_insist;
2201
2202     string IConnectionOpen.VirtualHost { get { return m_virtualHost; } }
2203     string IConnectionOpen.Capabilities { get { return m_capabilities; } }
2204     bool IConnectionOpen.Insist { get { return m_insist; } }
2205
2206     public ConnectionOpen() {}
2207     public ConnectionOpen(
2208       string initVirtualHost,
2209       string initCapabilities,
2210       bool initInsist)
2211     {
2212       m_virtualHost = initVirtualHost;
2213       m_capabilities = initCapabilities;
2214       m_insist = initInsist;
2215     }
2216
2217     public override int ProtocolClassId { get { return 10; } }
2218     public override int ProtocolMethodId { get { return 40; } }
2219     public override string ProtocolMethodName { get { return "connection.open"; } }
2220     public override bool HasContent { get { return false; } }
2221
2222     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2223       m_virtualHost = reader.ReadShortstr();
2224       m_capabilities = reader.ReadShortstr();
2225       m_insist = reader.ReadBit();
2226     }
2227
2228     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2229       writer.WriteShortstr(m_virtualHost);
2230       writer.WriteShortstr(m_capabilities);
2231       writer.WriteBit(m_insist);
2232     }
2233
2234     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2235       sb.Append("(");
2236       sb.Append(m_virtualHost); sb.Append(",");
2237       sb.Append(m_capabilities); sb.Append(",");
2238       sb.Append(m_insist);
2239       sb.Append(")");
2240     }
2241   }
2242   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2243   public class ConnectionOpenOk: RabbitMQ.Client.Impl.MethodBase, IConnectionOpenOk {
2244     public const int ClassId = 10;
2245     public const int MethodId = 41;
2246
2247     public string m_knownHosts;
2248
2249     string IConnectionOpenOk.KnownHosts { get { return m_knownHosts; } }
2250
2251     public ConnectionOpenOk() {}
2252     public ConnectionOpenOk(
2253       string initKnownHosts)
2254     {
2255       m_knownHosts = initKnownHosts;
2256     }
2257
2258     public override int ProtocolClassId { get { return 10; } }
2259     public override int ProtocolMethodId { get { return 41; } }
2260     public override string ProtocolMethodName { get { return "connection.open-ok"; } }
2261     public override bool HasContent { get { return false; } }
2262
2263     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2264       m_knownHosts = reader.ReadShortstr();
2265     }
2266
2267     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2268       writer.WriteShortstr(m_knownHosts);
2269     }
2270
2271     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2272       sb.Append("(");
2273       sb.Append(m_knownHosts);
2274       sb.Append(")");
2275     }
2276   }
2277   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2278   public class ConnectionRedirect: RabbitMQ.Client.Impl.MethodBase, IConnectionRedirect {
2279     public const int ClassId = 10;
2280     public const int MethodId = 50;
2281
2282     public string m_host;
2283     public string m_knownHosts;
2284
2285     string IConnectionRedirect.Host { get { return m_host; } }
2286     string IConnectionRedirect.KnownHosts { get { return m_knownHosts; } }
2287
2288     public ConnectionRedirect() {}
2289     public ConnectionRedirect(
2290       string initHost,
2291       string initKnownHosts)
2292     {
2293       m_host = initHost;
2294       m_knownHosts = initKnownHosts;
2295     }
2296
2297     public override int ProtocolClassId { get { return 10; } }
2298     public override int ProtocolMethodId { get { return 50; } }
2299     public override string ProtocolMethodName { get { return "connection.redirect"; } }
2300     public override bool HasContent { get { return false; } }
2301
2302     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2303       m_host = reader.ReadShortstr();
2304       m_knownHosts = reader.ReadShortstr();
2305     }
2306
2307     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2308       writer.WriteShortstr(m_host);
2309       writer.WriteShortstr(m_knownHosts);
2310     }
2311
2312     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2313       sb.Append("(");
2314       sb.Append(m_host); sb.Append(",");
2315       sb.Append(m_knownHosts);
2316       sb.Append(")");
2317     }
2318   }
2319   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2320   public class ConnectionClose: RabbitMQ.Client.Impl.MethodBase, IConnectionClose {
2321     public const int ClassId = 10;
2322     public const int MethodId = 60;
2323
2324     public ushort m_replyCode;
2325     public string m_replyText;
2326     public ushort m_classId;
2327     public ushort m_methodId;
2328
2329     ushort IConnectionClose.ReplyCode { get { return m_replyCode; } }
2330     string IConnectionClose.ReplyText { get { return m_replyText; } }
2331     ushort IConnectionClose.ClassId { get { return m_classId; } }
2332     ushort IConnectionClose.MethodId { get { return m_methodId; } }
2333
2334     public ConnectionClose() {}
2335     public ConnectionClose(
2336       ushort initReplyCode,
2337       string initReplyText,
2338       ushort initClassId,
2339       ushort initMethodId)
2340     {
2341       m_replyCode = initReplyCode;
2342       m_replyText = initReplyText;
2343       m_classId = initClassId;
2344       m_methodId = initMethodId;
2345     }
2346
2347     public override int ProtocolClassId { get { return 10; } }
2348     public override int ProtocolMethodId { get { return 60; } }
2349     public override string ProtocolMethodName { get { return "connection.close"; } }
2350     public override bool HasContent { get { return false; } }
2351
2352     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2353       m_replyCode = reader.ReadShort();
2354       m_replyText = reader.ReadShortstr();
2355       m_classId = reader.ReadShort();
2356       m_methodId = reader.ReadShort();
2357     }
2358
2359     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2360       writer.WriteShort(m_replyCode);
2361       writer.WriteShortstr(m_replyText);
2362       writer.WriteShort(m_classId);
2363       writer.WriteShort(m_methodId);
2364     }
2365
2366     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2367       sb.Append("(");
2368       sb.Append(m_replyCode); sb.Append(",");
2369       sb.Append(m_replyText); sb.Append(",");
2370       sb.Append(m_classId); sb.Append(",");
2371       sb.Append(m_methodId);
2372       sb.Append(")");
2373     }
2374   }
2375   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2376   public class ConnectionCloseOk: RabbitMQ.Client.Impl.MethodBase, IConnectionCloseOk {
2377     public const int ClassId = 10;
2378     public const int MethodId = 61;
2379
2380
2381
2382     public ConnectionCloseOk(
2383 )
2384     {
2385     }
2386
2387     public override int ProtocolClassId { get { return 10; } }
2388     public override int ProtocolMethodId { get { return 61; } }
2389     public override string ProtocolMethodName { get { return "connection.close-ok"; } }
2390     public override bool HasContent { get { return false; } }
2391
2392     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2393     }
2394
2395     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2396     }
2397
2398     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2399       sb.Append("(");
2400       sb.Append(")");
2401     }
2402   }
2403   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2404   public class ChannelOpen: RabbitMQ.Client.Impl.MethodBase, IChannelOpen {
2405     public const int ClassId = 20;
2406     public const int MethodId = 10;
2407
2408     public string m_outOfBand;
2409
2410     string IChannelOpen.OutOfBand { get { return m_outOfBand; } }
2411
2412     public ChannelOpen() {}
2413     public ChannelOpen(
2414       string initOutOfBand)
2415     {
2416       m_outOfBand = initOutOfBand;
2417     }
2418
2419     public override int ProtocolClassId { get { return 20; } }
2420     public override int ProtocolMethodId { get { return 10; } }
2421     public override string ProtocolMethodName { get { return "channel.open"; } }
2422     public override bool HasContent { get { return false; } }
2423
2424     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2425       m_outOfBand = reader.ReadShortstr();
2426     }
2427
2428     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2429       writer.WriteShortstr(m_outOfBand);
2430     }
2431
2432     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2433       sb.Append("(");
2434       sb.Append(m_outOfBand);
2435       sb.Append(")");
2436     }
2437   }
2438   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2439   public class ChannelOpenOk: RabbitMQ.Client.Impl.MethodBase, IChannelOpenOk {
2440     public const int ClassId = 20;
2441     public const int MethodId = 11;
2442
2443
2444
2445     public ChannelOpenOk(
2446 )
2447     {
2448     }
2449
2450     public override int ProtocolClassId { get { return 20; } }
2451     public override int ProtocolMethodId { get { return 11; } }
2452     public override string ProtocolMethodName { get { return "channel.open-ok"; } }
2453     public override bool HasContent { get { return false; } }
2454
2455     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2456     }
2457
2458     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2459     }
2460
2461     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2462       sb.Append("(");
2463       sb.Append(")");
2464     }
2465   }
2466   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2467   public class ChannelFlow: RabbitMQ.Client.Impl.MethodBase, IChannelFlow {
2468     public const int ClassId = 20;
2469     public const int MethodId = 20;
2470
2471     public bool m_active;
2472
2473     bool IChannelFlow.Active { get { return m_active; } }
2474
2475     public ChannelFlow() {}
2476     public ChannelFlow(
2477       bool initActive)
2478     {
2479       m_active = initActive;
2480     }
2481
2482     public override int ProtocolClassId { get { return 20; } }
2483     public override int ProtocolMethodId { get { return 20; } }
2484     public override string ProtocolMethodName { get { return "channel.flow"; } }
2485     public override bool HasContent { get { return false; } }
2486
2487     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2488       m_active = reader.ReadBit();
2489     }
2490
2491     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2492       writer.WriteBit(m_active);
2493     }
2494
2495     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2496       sb.Append("(");
2497       sb.Append(m_active);
2498       sb.Append(")");
2499     }
2500   }
2501   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2502   public class ChannelFlowOk: RabbitMQ.Client.Impl.MethodBase, IChannelFlowOk {
2503     public const int ClassId = 20;
2504     public const int MethodId = 21;
2505
2506     public bool m_active;
2507
2508     bool IChannelFlowOk.Active { get { return m_active; } }
2509
2510     public ChannelFlowOk() {}
2511     public ChannelFlowOk(
2512       bool initActive)
2513     {
2514       m_active = initActive;
2515     }
2516
2517     public override int ProtocolClassId { get { return 20; } }
2518     public override int ProtocolMethodId { get { return 21; } }
2519     public override string ProtocolMethodName { get { return "channel.flow-ok"; } }
2520     public override bool HasContent { get { return false; } }
2521
2522     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2523       m_active = reader.ReadBit();
2524     }
2525
2526     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2527       writer.WriteBit(m_active);
2528     }
2529
2530     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2531       sb.Append("(");
2532       sb.Append(m_active);
2533       sb.Append(")");
2534     }
2535   }
2536   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2537   public class ChannelAlert: RabbitMQ.Client.Impl.MethodBase, IChannelAlert {
2538     public const int ClassId = 20;
2539     public const int MethodId = 30;
2540
2541     public ushort m_replyCode;
2542     public string m_replyText;
2543     public System.Collections.IDictionary m_details;
2544
2545     ushort IChannelAlert.ReplyCode { get { return m_replyCode; } }
2546     string IChannelAlert.ReplyText { get { return m_replyText; } }
2547     System.Collections.IDictionary IChannelAlert.Details { get { return m_details; } }
2548
2549     public ChannelAlert() {}
2550     public ChannelAlert(
2551       ushort initReplyCode,
2552       string initReplyText,
2553       System.Collections.IDictionary initDetails)
2554     {
2555       m_replyCode = initReplyCode;
2556       m_replyText = initReplyText;
2557       m_details = initDetails;
2558     }
2559
2560     public override int ProtocolClassId { get { return 20; } }
2561     public override int ProtocolMethodId { get { return 30; } }
2562     public override string ProtocolMethodName { get { return "channel.alert"; } }
2563     public override bool HasContent { get { return false; } }
2564
2565     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2566       m_replyCode = reader.ReadShort();
2567       m_replyText = reader.ReadShortstr();
2568       m_details = reader.ReadTable();
2569     }
2570
2571     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2572       writer.WriteShort(m_replyCode);
2573       writer.WriteShortstr(m_replyText);
2574       writer.WriteTable(m_details);
2575     }
2576
2577     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2578       sb.Append("(");
2579       sb.Append(m_replyCode); sb.Append(",");
2580       sb.Append(m_replyText); sb.Append(",");
2581       sb.Append(m_details);
2582       sb.Append(")");
2583     }
2584   }
2585   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2586   public class ChannelClose: RabbitMQ.Client.Impl.MethodBase, IChannelClose {
2587     public const int ClassId = 20;
2588     public const int MethodId = 40;
2589
2590     public ushort m_replyCode;
2591     public string m_replyText;
2592     public ushort m_classId;
2593     public ushort m_methodId;
2594
2595     ushort IChannelClose.ReplyCode { get { return m_replyCode; } }
2596     string IChannelClose.ReplyText { get { return m_replyText; } }
2597     ushort IChannelClose.ClassId { get { return m_classId; } }
2598     ushort IChannelClose.MethodId { get { return m_methodId; } }
2599
2600     public ChannelClose() {}
2601     public ChannelClose(
2602       ushort initReplyCode,
2603       string initReplyText,
2604       ushort initClassId,
2605       ushort initMethodId)
2606     {
2607       m_replyCode = initReplyCode;
2608       m_replyText = initReplyText;
2609       m_classId = initClassId;
2610       m_methodId = initMethodId;
2611     }
2612
2613     public override int ProtocolClassId { get { return 20; } }
2614     public override int ProtocolMethodId { get { return 40; } }
2615     public override string ProtocolMethodName { get { return "channel.close"; } }
2616     public override bool HasContent { get { return false; } }
2617
2618     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2619       m_replyCode = reader.ReadShort();
2620       m_replyText = reader.ReadShortstr();
2621       m_classId = reader.ReadShort();
2622       m_methodId = reader.ReadShort();
2623     }
2624
2625     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2626       writer.WriteShort(m_replyCode);
2627       writer.WriteShortstr(m_replyText);
2628       writer.WriteShort(m_classId);
2629       writer.WriteShort(m_methodId);
2630     }
2631
2632     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2633       sb.Append("(");
2634       sb.Append(m_replyCode); sb.Append(",");
2635       sb.Append(m_replyText); sb.Append(",");
2636       sb.Append(m_classId); sb.Append(",");
2637       sb.Append(m_methodId);
2638       sb.Append(")");
2639     }
2640   }
2641   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2642   public class ChannelCloseOk: RabbitMQ.Client.Impl.MethodBase, IChannelCloseOk {
2643     public const int ClassId = 20;
2644     public const int MethodId = 41;
2645
2646
2647
2648     public ChannelCloseOk(
2649 )
2650     {
2651     }
2652
2653     public override int ProtocolClassId { get { return 20; } }
2654     public override int ProtocolMethodId { get { return 41; } }
2655     public override string ProtocolMethodName { get { return "channel.close-ok"; } }
2656     public override bool HasContent { get { return false; } }
2657
2658     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2659     }
2660
2661     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2662     }
2663
2664     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2665       sb.Append("(");
2666       sb.Append(")");
2667     }
2668   }
2669   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2670   public class AccessRequest: RabbitMQ.Client.Impl.MethodBase, IAccessRequest {
2671     public const int ClassId = 30;
2672     public const int MethodId = 10;
2673
2674     public string m_realm;
2675     public bool m_exclusive;
2676     public bool m_passive;
2677     public bool m_active;
2678     public bool m_write;
2679     public bool m_read;
2680
2681     string IAccessRequest.Realm { get { return m_realm; } }
2682     bool IAccessRequest.Exclusive { get { return m_exclusive; } }
2683     bool IAccessRequest.Passive { get { return m_passive; } }
2684     bool IAccessRequest.Active { get { return m_active; } }
2685     bool IAccessRequest.Write { get { return m_write; } }
2686     bool IAccessRequest.Read { get { return m_read; } }
2687
2688     public AccessRequest() {}
2689     public AccessRequest(
2690       string initRealm,
2691       bool initExclusive,
2692       bool initPassive,
2693       bool initActive,
2694       bool initWrite,
2695       bool initRead)
2696     {
2697       m_realm = initRealm;
2698       m_exclusive = initExclusive;
2699       m_passive = initPassive;
2700       m_active = initActive;
2701       m_write = initWrite;
2702       m_read = initRead;
2703     }
2704
2705     public override int ProtocolClassId { get { return 30; } }
2706     public override int ProtocolMethodId { get { return 10; } }
2707     public override string ProtocolMethodName { get { return "access.request"; } }
2708     public override bool HasContent { get { return false; } }
2709
2710     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2711       m_realm = reader.ReadShortstr();
2712       m_exclusive = reader.ReadBit();
2713       m_passive = reader.ReadBit();
2714       m_active = reader.ReadBit();
2715       m_write = reader.ReadBit();
2716       m_read = reader.ReadBit();
2717     }
2718
2719     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2720       writer.WriteShortstr(m_realm);
2721       writer.WriteBit(m_exclusive);
2722       writer.WriteBit(m_passive);
2723       writer.WriteBit(m_active);
2724       writer.WriteBit(m_write);
2725       writer.WriteBit(m_read);
2726     }
2727
2728     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2729       sb.Append("(");
2730       sb.Append(m_realm); sb.Append(",");
2731       sb.Append(m_exclusive); sb.Append(",");
2732       sb.Append(m_passive); sb.Append(",");
2733       sb.Append(m_active); sb.Append(",");
2734       sb.Append(m_write); sb.Append(",");
2735       sb.Append(m_read);
2736       sb.Append(")");
2737     }
2738   }
2739   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2740   public class AccessRequestOk: RabbitMQ.Client.Impl.MethodBase, IAccessRequestOk {
2741     public const int ClassId = 30;
2742     public const int MethodId = 11;
2743
2744     public ushort m_ticket;
2745
2746     ushort IAccessRequestOk.Ticket { get { return m_ticket; } }
2747
2748     public AccessRequestOk() {}
2749     public AccessRequestOk(
2750       ushort initTicket)
2751     {
2752       m_ticket = initTicket;
2753     }
2754
2755     public override int ProtocolClassId { get { return 30; } }
2756     public override int ProtocolMethodId { get { return 11; } }
2757     public override string ProtocolMethodName { get { return "access.request-ok"; } }
2758     public override bool HasContent { get { return false; } }
2759
2760     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2761       m_ticket = reader.ReadShort();
2762     }
2763
2764     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2765       writer.WriteShort(m_ticket);
2766     }
2767
2768     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2769       sb.Append("(");
2770       sb.Append(m_ticket);
2771       sb.Append(")");
2772     }
2773   }
2774   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2775   public class ExchangeDeclare: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclare {
2776     public const int ClassId = 40;
2777     public const int MethodId = 10;
2778
2779     public ushort m_ticket;
2780     public string m_exchange;
2781     public string m_type;
2782     public bool m_passive;
2783     public bool m_durable;
2784     public bool m_autoDelete;
2785     public bool m_internal;
2786     public bool m_nowait;
2787     public System.Collections.IDictionary m_arguments;
2788
2789     ushort IExchangeDeclare.Ticket { get { return m_ticket; } }
2790     string IExchangeDeclare.Exchange { get { return m_exchange; } }
2791     string IExchangeDeclare.Type { get { return m_type; } }
2792     bool IExchangeDeclare.Passive { get { return m_passive; } }
2793     bool IExchangeDeclare.Durable { get { return m_durable; } }
2794     bool IExchangeDeclare.AutoDelete { get { return m_autoDelete; } }
2795     bool IExchangeDeclare.Internal { get { return m_internal; } }
2796     bool IExchangeDeclare.Nowait { get { return m_nowait; } }
2797     System.Collections.IDictionary IExchangeDeclare.Arguments { get { return m_arguments; } }
2798
2799     public ExchangeDeclare() {}
2800     public ExchangeDeclare(
2801       ushort initTicket,
2802       string initExchange,
2803       string initType,
2804       bool initPassive,
2805       bool initDurable,
2806       bool initAutoDelete,
2807       bool initInternal,
2808       bool initNowait,
2809       System.Collections.IDictionary initArguments)
2810     {
2811       m_ticket = initTicket;
2812       m_exchange = initExchange;
2813       m_type = initType;
2814       m_passive = initPassive;
2815       m_durable = initDurable;
2816       m_autoDelete = initAutoDelete;
2817       m_internal = initInternal;
2818       m_nowait = initNowait;
2819       m_arguments = initArguments;
2820     }
2821
2822     public override int ProtocolClassId { get { return 40; } }
2823     public override int ProtocolMethodId { get { return 10; } }
2824     public override string ProtocolMethodName { get { return "exchange.declare"; } }
2825     public override bool HasContent { get { return false; } }
2826
2827     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2828       m_ticket = reader.ReadShort();
2829       m_exchange = reader.ReadShortstr();
2830       m_type = reader.ReadShortstr();
2831       m_passive = reader.ReadBit();
2832       m_durable = reader.ReadBit();
2833       m_autoDelete = reader.ReadBit();
2834       m_internal = reader.ReadBit();
2835       m_nowait = reader.ReadBit();
2836       m_arguments = reader.ReadTable();
2837     }
2838
2839     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2840       writer.WriteShort(m_ticket);
2841       writer.WriteShortstr(m_exchange);
2842       writer.WriteShortstr(m_type);
2843       writer.WriteBit(m_passive);
2844       writer.WriteBit(m_durable);
2845       writer.WriteBit(m_autoDelete);
2846       writer.WriteBit(m_internal);
2847       writer.WriteBit(m_nowait);
2848       writer.WriteTable(m_arguments);
2849     }
2850
2851     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2852       sb.Append("(");
2853       sb.Append(m_ticket); sb.Append(",");
2854       sb.Append(m_exchange); sb.Append(",");
2855       sb.Append(m_type); sb.Append(",");
2856       sb.Append(m_passive); sb.Append(",");
2857       sb.Append(m_durable); sb.Append(",");
2858       sb.Append(m_autoDelete); sb.Append(",");
2859       sb.Append(m_internal); sb.Append(",");
2860       sb.Append(m_nowait); sb.Append(",");
2861       sb.Append(m_arguments);
2862       sb.Append(")");
2863     }
2864   }
2865   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2866   public class ExchangeDeclareOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclareOk {
2867     public const int ClassId = 40;
2868     public const int MethodId = 11;
2869
2870
2871
2872     public ExchangeDeclareOk(
2873 )
2874     {
2875     }
2876
2877     public override int ProtocolClassId { get { return 40; } }
2878     public override int ProtocolMethodId { get { return 11; } }
2879     public override string ProtocolMethodName { get { return "exchange.declare-ok"; } }
2880     public override bool HasContent { get { return false; } }
2881
2882     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2883     }
2884
2885     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2886     }
2887
2888     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2889       sb.Append("(");
2890       sb.Append(")");
2891     }
2892   }
2893   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2894   public class ExchangeDelete: RabbitMQ.Client.Impl.MethodBase, IExchangeDelete {
2895     public const int ClassId = 40;
2896     public const int MethodId = 20;
2897
2898     public ushort m_ticket;
2899     public string m_exchange;
2900     public bool m_ifUnused;
2901     public bool m_nowait;
2902
2903     ushort IExchangeDelete.Ticket { get { return m_ticket; } }
2904     string IExchangeDelete.Exchange { get { return m_exchange; } }
2905     bool IExchangeDelete.IfUnused { get { return m_ifUnused; } }
2906     bool IExchangeDelete.Nowait { get { return m_nowait; } }
2907
2908     public ExchangeDelete() {}
2909     public ExchangeDelete(
2910       ushort initTicket,
2911       string initExchange,
2912       bool initIfUnused,
2913       bool initNowait)
2914     {
2915       m_ticket = initTicket;
2916       m_exchange = initExchange;
2917       m_ifUnused = initIfUnused;
2918       m_nowait = initNowait;
2919     }
2920
2921     public override int ProtocolClassId { get { return 40; } }
2922     public override int ProtocolMethodId { get { return 20; } }
2923     public override string ProtocolMethodName { get { return "exchange.delete"; } }
2924     public override bool HasContent { get { return false; } }
2925
2926     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2927       m_ticket = reader.ReadShort();
2928       m_exchange = reader.ReadShortstr();
2929       m_ifUnused = reader.ReadBit();
2930       m_nowait = reader.ReadBit();
2931     }
2932
2933     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2934       writer.WriteShort(m_ticket);
2935       writer.WriteShortstr(m_exchange);
2936       writer.WriteBit(m_ifUnused);
2937       writer.WriteBit(m_nowait);
2938     }
2939
2940     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2941       sb.Append("(");
2942       sb.Append(m_ticket); sb.Append(",");
2943       sb.Append(m_exchange); sb.Append(",");
2944       sb.Append(m_ifUnused); sb.Append(",");
2945       sb.Append(m_nowait);
2946       sb.Append(")");
2947     }
2948   }
2949   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2950   public class ExchangeDeleteOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeleteOk {
2951     public const int ClassId = 40;
2952     public const int MethodId = 21;
2953
2954
2955
2956     public ExchangeDeleteOk(
2957 )
2958     {
2959     }
2960
2961     public override int ProtocolClassId { get { return 40; } }
2962     public override int ProtocolMethodId { get { return 21; } }
2963     public override string ProtocolMethodName { get { return "exchange.delete-ok"; } }
2964     public override bool HasContent { get { return false; } }
2965
2966     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
2967     }
2968
2969     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
2970     }
2971
2972     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
2973       sb.Append("(");
2974       sb.Append(")");
2975     }
2976   }
2977   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
2978   public class ExchangeBound: RabbitMQ.Client.Impl.MethodBase, IExchangeBound {
2979     public const int ClassId = 40;
2980     public const int MethodId = 22;
2981
2982     public string m_exchange;
2983     public string m_routingKey;
2984     public string m_queue;
2985
2986     string IExchangeBound.Exchange { get { return m_exchange; } }
2987     string IExchangeBound.RoutingKey { get { return m_routingKey; } }
2988     string IExchangeBound.Queue { get { return m_queue; } }
2989
2990     public ExchangeBound() {}
2991     public ExchangeBound(
2992       string initExchange,
2993       string initRoutingKey,
2994       string initQueue)
2995     {
2996       m_exchange = initExchange;
2997       m_routingKey = initRoutingKey;
2998       m_queue = initQueue;
2999     }
3000
3001     public override int ProtocolClassId { get { return 40; } }
3002     public override int ProtocolMethodId { get { return 22; } }
3003     public override string ProtocolMethodName { get { return "exchange.bound"; } }
3004     public override bool HasContent { get { return false; } }
3005
3006     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3007       m_exchange = reader.ReadShortstr();
3008       m_routingKey = reader.ReadShortstr();
3009       m_queue = reader.ReadShortstr();
3010     }
3011
3012     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3013       writer.WriteShortstr(m_exchange);
3014       writer.WriteShortstr(m_routingKey);
3015       writer.WriteShortstr(m_queue);
3016     }
3017
3018     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3019       sb.Append("(");
3020       sb.Append(m_exchange); sb.Append(",");
3021       sb.Append(m_routingKey); sb.Append(",");
3022       sb.Append(m_queue);
3023       sb.Append(")");
3024     }
3025   }
3026   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3027   public class ExchangeBoundOk: RabbitMQ.Client.Impl.MethodBase, IExchangeBoundOk {
3028     public const int ClassId = 40;
3029     public const int MethodId = 23;
3030
3031     public ushort m_replyCode;
3032     public string m_replyText;
3033
3034     ushort IExchangeBoundOk.ReplyCode { get { return m_replyCode; } }
3035     string IExchangeBoundOk.ReplyText { get { return m_replyText; } }
3036
3037     public ExchangeBoundOk() {}
3038     public ExchangeBoundOk(
3039       ushort initReplyCode,
3040       string initReplyText)
3041     {
3042       m_replyCode = initReplyCode;
3043       m_replyText = initReplyText;
3044     }
3045
3046     public override int ProtocolClassId { get { return 40; } }
3047     public override int ProtocolMethodId { get { return 23; } }
3048     public override string ProtocolMethodName { get { return "exchange.bound-ok"; } }
3049     public override bool HasContent { get { return false; } }
3050
3051     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3052       m_replyCode = reader.ReadShort();
3053       m_replyText = reader.ReadShortstr();
3054     }
3055
3056     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3057       writer.WriteShort(m_replyCode);
3058       writer.WriteShortstr(m_replyText);
3059     }
3060
3061     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3062       sb.Append("(");
3063       sb.Append(m_replyCode); sb.Append(",");
3064       sb.Append(m_replyText);
3065       sb.Append(")");
3066     }
3067   }
3068   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3069   public class QueueDeclare: RabbitMQ.Client.Impl.MethodBase, IQueueDeclare {
3070     public const int ClassId = 50;
3071     public const int MethodId = 10;
3072
3073     public ushort m_ticket;
3074     public string m_queue;
3075     public bool m_passive;
3076     public bool m_durable;
3077     public bool m_exclusive;
3078     public bool m_autoDelete;
3079     public bool m_nowait;
3080     public System.Collections.IDictionary m_arguments;
3081
3082     ushort IQueueDeclare.Ticket { get { return m_ticket; } }
3083     string IQueueDeclare.Queue { get { return m_queue; } }
3084     bool IQueueDeclare.Passive { get { return m_passive; } }
3085     bool IQueueDeclare.Durable { get { return m_durable; } }
3086     bool IQueueDeclare.Exclusive { get { return m_exclusive; } }
3087     bool IQueueDeclare.AutoDelete { get { return m_autoDelete; } }
3088     bool IQueueDeclare.Nowait { get { return m_nowait; } }
3089     System.Collections.IDictionary IQueueDeclare.Arguments { get { return m_arguments; } }
3090
3091     public QueueDeclare() {}
3092     public QueueDeclare(
3093       ushort initTicket,
3094       string initQueue,
3095       bool initPassive,
3096       bool initDurable,
3097       bool initExclusive,
3098       bool initAutoDelete,
3099       bool initNowait,
3100       System.Collections.IDictionary initArguments)
3101     {
3102       m_ticket = initTicket;
3103       m_queue = initQueue;
3104       m_passive = initPassive;
3105       m_durable = initDurable;
3106       m_exclusive = initExclusive;
3107       m_autoDelete = initAutoDelete;
3108       m_nowait = initNowait;
3109       m_arguments = initArguments;
3110     }
3111
3112     public override int ProtocolClassId { get { return 50; } }
3113     public override int ProtocolMethodId { get { return 10; } }
3114     public override string ProtocolMethodName { get { return "queue.declare"; } }
3115     public override bool HasContent { get { return false; } }
3116
3117     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3118       m_ticket = reader.ReadShort();
3119       m_queue = reader.ReadShortstr();
3120       m_passive = reader.ReadBit();
3121       m_durable = reader.ReadBit();
3122       m_exclusive = reader.ReadBit();
3123       m_autoDelete = reader.ReadBit();
3124       m_nowait = reader.ReadBit();
3125       m_arguments = reader.ReadTable();
3126     }
3127
3128     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3129       writer.WriteShort(m_ticket);
3130       writer.WriteShortstr(m_queue);
3131       writer.WriteBit(m_passive);
3132       writer.WriteBit(m_durable);
3133       writer.WriteBit(m_exclusive);
3134       writer.WriteBit(m_autoDelete);
3135       writer.WriteBit(m_nowait);
3136       writer.WriteTable(m_arguments);
3137     }
3138
3139     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3140       sb.Append("(");
3141       sb.Append(m_ticket); sb.Append(",");
3142       sb.Append(m_queue); sb.Append(",");
3143       sb.Append(m_passive); sb.Append(",");
3144       sb.Append(m_durable); sb.Append(",");
3145       sb.Append(m_exclusive); sb.Append(",");
3146       sb.Append(m_autoDelete); sb.Append(",");
3147       sb.Append(m_nowait); sb.Append(",");
3148       sb.Append(m_arguments);
3149       sb.Append(")");
3150     }
3151   }
3152   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3153   public class QueueDeclareOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeclareOk {
3154     public const int ClassId = 50;
3155     public const int MethodId = 11;
3156
3157     public string m_queue;
3158     public uint m_messageCount;
3159     public uint m_consumerCount;
3160
3161     string IQueueDeclareOk.Queue { get { return m_queue; } }
3162     uint IQueueDeclareOk.MessageCount { get { return m_messageCount; } }
3163     uint IQueueDeclareOk.ConsumerCount { get { return m_consumerCount; } }
3164
3165     public QueueDeclareOk() {}
3166     public QueueDeclareOk(
3167       string initQueue,
3168       uint initMessageCount,
3169       uint initConsumerCount)
3170     {
3171       m_queue = initQueue;
3172       m_messageCount = initMessageCount;
3173       m_consumerCount = initConsumerCount;
3174     }
3175
3176     public override int ProtocolClassId { get { return 50; } }
3177     public override int ProtocolMethodId { get { return 11; } }
3178     public override string ProtocolMethodName { get { return "queue.declare-ok"; } }
3179     public override bool HasContent { get { return false; } }
3180
3181     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3182       m_queue = reader.ReadShortstr();
3183       m_messageCount = reader.ReadLong();
3184       m_consumerCount = reader.ReadLong();
3185     }
3186
3187     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3188       writer.WriteShortstr(m_queue);
3189       writer.WriteLong(m_messageCount);
3190       writer.WriteLong(m_consumerCount);
3191     }
3192
3193     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3194       sb.Append("(");
3195       sb.Append(m_queue); sb.Append(",");
3196       sb.Append(m_messageCount); sb.Append(",");
3197       sb.Append(m_consumerCount);
3198       sb.Append(")");
3199     }
3200   }
3201   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3202   public class QueueBind: RabbitMQ.Client.Impl.MethodBase, IQueueBind {
3203     public const int ClassId = 50;
3204     public const int MethodId = 20;
3205
3206     public ushort m_ticket;
3207     public string m_queue;
3208     public string m_exchange;
3209     public string m_routingKey;
3210     public bool m_nowait;
3211     public System.Collections.IDictionary m_arguments;
3212
3213     ushort IQueueBind.Ticket { get { return m_ticket; } }
3214     string IQueueBind.Queue { get { return m_queue; } }
3215     string IQueueBind.Exchange { get { return m_exchange; } }
3216     string IQueueBind.RoutingKey { get { return m_routingKey; } }
3217     bool IQueueBind.Nowait { get { return m_nowait; } }
3218     System.Collections.IDictionary IQueueBind.Arguments { get { return m_arguments; } }
3219
3220     public QueueBind() {}
3221     public QueueBind(
3222       ushort initTicket,
3223       string initQueue,
3224       string initExchange,
3225       string initRoutingKey,
3226       bool initNowait,
3227       System.Collections.IDictionary initArguments)
3228     {
3229       m_ticket = initTicket;
3230       m_queue = initQueue;
3231       m_exchange = initExchange;
3232       m_routingKey = initRoutingKey;
3233       m_nowait = initNowait;
3234       m_arguments = initArguments;
3235     }
3236
3237     public override int ProtocolClassId { get { return 50; } }
3238     public override int ProtocolMethodId { get { return 20; } }
3239     public override string ProtocolMethodName { get { return "queue.bind"; } }
3240     public override bool HasContent { get { return false; } }
3241
3242     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3243       m_ticket = reader.ReadShort();
3244       m_queue = reader.ReadShortstr();
3245       m_exchange = reader.ReadShortstr();
3246       m_routingKey = reader.ReadShortstr();
3247       m_nowait = reader.ReadBit();
3248       m_arguments = reader.ReadTable();
3249     }
3250
3251     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3252       writer.WriteShort(m_ticket);
3253       writer.WriteShortstr(m_queue);
3254       writer.WriteShortstr(m_exchange);
3255       writer.WriteShortstr(m_routingKey);
3256       writer.WriteBit(m_nowait);
3257       writer.WriteTable(m_arguments);
3258     }
3259
3260     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3261       sb.Append("(");
3262       sb.Append(m_ticket); sb.Append(",");
3263       sb.Append(m_queue); sb.Append(",");
3264       sb.Append(m_exchange); sb.Append(",");
3265       sb.Append(m_routingKey); sb.Append(",");
3266       sb.Append(m_nowait); sb.Append(",");
3267       sb.Append(m_arguments);
3268       sb.Append(")");
3269     }
3270   }
3271   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3272   public class QueueBindOk: RabbitMQ.Client.Impl.MethodBase, IQueueBindOk {
3273     public const int ClassId = 50;
3274     public const int MethodId = 21;
3275
3276
3277
3278     public QueueBindOk(
3279 )
3280     {
3281     }
3282
3283     public override int ProtocolClassId { get { return 50; } }
3284     public override int ProtocolMethodId { get { return 21; } }
3285     public override string ProtocolMethodName { get { return "queue.bind-ok"; } }
3286     public override bool HasContent { get { return false; } }
3287
3288     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3289     }
3290
3291     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3292     }
3293
3294     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3295       sb.Append("(");
3296       sb.Append(")");
3297     }
3298   }
3299   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3300   public class QueuePurge: RabbitMQ.Client.Impl.MethodBase, IQueuePurge {
3301     public const int ClassId = 50;
3302     public const int MethodId = 30;
3303
3304     public ushort m_ticket;
3305     public string m_queue;
3306     public bool m_nowait;
3307
3308     ushort IQueuePurge.Ticket { get { return m_ticket; } }
3309     string IQueuePurge.Queue { get { return m_queue; } }
3310     bool IQueuePurge.Nowait { get { return m_nowait; } }
3311
3312     public QueuePurge() {}
3313     public QueuePurge(
3314       ushort initTicket,
3315       string initQueue,
3316       bool initNowait)
3317     {
3318       m_ticket = initTicket;
3319       m_queue = initQueue;
3320       m_nowait = initNowait;
3321     }
3322
3323     public override int ProtocolClassId { get { return 50; } }
3324     public override int ProtocolMethodId { get { return 30; } }
3325     public override string ProtocolMethodName { get { return "queue.purge"; } }
3326     public override bool HasContent { get { return false; } }
3327
3328     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3329       m_ticket = reader.ReadShort();
3330       m_queue = reader.ReadShortstr();
3331       m_nowait = reader.ReadBit();
3332     }
3333
3334     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3335       writer.WriteShort(m_ticket);
3336       writer.WriteShortstr(m_queue);
3337       writer.WriteBit(m_nowait);
3338     }
3339
3340     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3341       sb.Append("(");
3342       sb.Append(m_ticket); sb.Append(",");
3343       sb.Append(m_queue); sb.Append(",");
3344       sb.Append(m_nowait);
3345       sb.Append(")");
3346     }
3347   }
3348   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3349   public class QueuePurgeOk: RabbitMQ.Client.Impl.MethodBase, IQueuePurgeOk {
3350     public const int ClassId = 50;
3351     public const int MethodId = 31;
3352
3353     public uint m_messageCount;
3354
3355     uint IQueuePurgeOk.MessageCount { get { return m_messageCount; } }
3356
3357     public QueuePurgeOk() {}
3358     public QueuePurgeOk(
3359       uint initMessageCount)
3360     {
3361       m_messageCount = initMessageCount;
3362     }
3363
3364     public override int ProtocolClassId { get { return 50; } }
3365     public override int ProtocolMethodId { get { return 31; } }
3366     public override string ProtocolMethodName { get { return "queue.purge-ok"; } }
3367     public override bool HasContent { get { return false; } }
3368
3369     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3370       m_messageCount = reader.ReadLong();
3371     }
3372
3373     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3374       writer.WriteLong(m_messageCount);
3375     }
3376
3377     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3378       sb.Append("(");
3379       sb.Append(m_messageCount);
3380       sb.Append(")");
3381     }
3382   }
3383   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3384   public class QueueDelete: RabbitMQ.Client.Impl.MethodBase, IQueueDelete {
3385     public const int ClassId = 50;
3386     public const int MethodId = 40;
3387
3388     public ushort m_ticket;
3389     public string m_queue;
3390     public bool m_ifUnused;
3391     public bool m_ifEmpty;
3392     public bool m_nowait;
3393
3394     ushort IQueueDelete.Ticket { get { return m_ticket; } }
3395     string IQueueDelete.Queue { get { return m_queue; } }
3396     bool IQueueDelete.IfUnused { get { return m_ifUnused; } }
3397     bool IQueueDelete.IfEmpty { get { return m_ifEmpty; } }
3398     bool IQueueDelete.Nowait { get { return m_nowait; } }
3399
3400     public QueueDelete() {}
3401     public QueueDelete(
3402       ushort initTicket,
3403       string initQueue,
3404       bool initIfUnused,
3405       bool initIfEmpty,
3406       bool initNowait)
3407     {
3408       m_ticket = initTicket;
3409       m_queue = initQueue;
3410       m_ifUnused = initIfUnused;
3411       m_ifEmpty = initIfEmpty;
3412       m_nowait = initNowait;
3413     }
3414
3415     public override int ProtocolClassId { get { return 50; } }
3416     public override int ProtocolMethodId { get { return 40; } }
3417     public override string ProtocolMethodName { get { return "queue.delete"; } }
3418     public override bool HasContent { get { return false; } }
3419
3420     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3421       m_ticket = reader.ReadShort();
3422       m_queue = reader.ReadShortstr();
3423       m_ifUnused = reader.ReadBit();
3424       m_ifEmpty = reader.ReadBit();
3425       m_nowait = reader.ReadBit();
3426     }
3427
3428     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3429       writer.WriteShort(m_ticket);
3430       writer.WriteShortstr(m_queue);
3431       writer.WriteBit(m_ifUnused);
3432       writer.WriteBit(m_ifEmpty);
3433       writer.WriteBit(m_nowait);
3434     }
3435
3436     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3437       sb.Append("(");
3438       sb.Append(m_ticket); sb.Append(",");
3439       sb.Append(m_queue); sb.Append(",");
3440       sb.Append(m_ifUnused); sb.Append(",");
3441       sb.Append(m_ifEmpty); sb.Append(",");
3442       sb.Append(m_nowait);
3443       sb.Append(")");
3444     }
3445   }
3446   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3447   public class QueueDeleteOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeleteOk {
3448     public const int ClassId = 50;
3449     public const int MethodId = 41;
3450
3451     public uint m_messageCount;
3452
3453     uint IQueueDeleteOk.MessageCount { get { return m_messageCount; } }
3454
3455     public QueueDeleteOk() {}
3456     public QueueDeleteOk(
3457       uint initMessageCount)
3458     {
3459       m_messageCount = initMessageCount;
3460     }
3461
3462     public override int ProtocolClassId { get { return 50; } }
3463     public override int ProtocolMethodId { get { return 41; } }
3464     public override string ProtocolMethodName { get { return "queue.delete-ok"; } }
3465     public override bool HasContent { get { return false; } }
3466
3467     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3468       m_messageCount = reader.ReadLong();
3469     }
3470
3471     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3472       writer.WriteLong(m_messageCount);
3473     }
3474
3475     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3476       sb.Append("(");
3477       sb.Append(m_messageCount);
3478       sb.Append(")");
3479     }
3480   }
3481   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3482   public class BasicQos: RabbitMQ.Client.Impl.MethodBase, IBasicQos {
3483     public const int ClassId = 60;
3484     public const int MethodId = 10;
3485
3486     public uint m_prefetchSize;
3487     public ushort m_prefetchCount;
3488     public bool m_global;
3489
3490     uint IBasicQos.PrefetchSize { get { return m_prefetchSize; } }
3491     ushort IBasicQos.PrefetchCount { get { return m_prefetchCount; } }
3492     bool IBasicQos.Global { get { return m_global; } }
3493
3494     public BasicQos() {}
3495     public BasicQos(
3496       uint initPrefetchSize,
3497       ushort initPrefetchCount,
3498       bool initGlobal)
3499     {
3500       m_prefetchSize = initPrefetchSize;
3501       m_prefetchCount = initPrefetchCount;
3502       m_global = initGlobal;
3503     }
3504
3505     public override int ProtocolClassId { get { return 60; } }
3506     public override int ProtocolMethodId { get { return 10; } }
3507     public override string ProtocolMethodName { get { return "basic.qos"; } }
3508     public override bool HasContent { get { return false; } }
3509
3510     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3511       m_prefetchSize = reader.ReadLong();
3512       m_prefetchCount = reader.ReadShort();
3513       m_global = reader.ReadBit();
3514     }
3515
3516     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3517       writer.WriteLong(m_prefetchSize);
3518       writer.WriteShort(m_prefetchCount);
3519       writer.WriteBit(m_global);
3520     }
3521
3522     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3523       sb.Append("(");
3524       sb.Append(m_prefetchSize); sb.Append(",");
3525       sb.Append(m_prefetchCount); sb.Append(",");
3526       sb.Append(m_global);
3527       sb.Append(")");
3528     }
3529   }
3530   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3531   public class BasicQosOk: RabbitMQ.Client.Impl.MethodBase, IBasicQosOk {
3532     public const int ClassId = 60;
3533     public const int MethodId = 11;
3534
3535
3536
3537     public BasicQosOk(
3538 )
3539     {
3540     }
3541
3542     public override int ProtocolClassId { get { return 60; } }
3543     public override int ProtocolMethodId { get { return 11; } }
3544     public override string ProtocolMethodName { get { return "basic.qos-ok"; } }
3545     public override bool HasContent { get { return false; } }
3546
3547     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3548     }
3549
3550     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3551     }
3552
3553     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3554       sb.Append("(");
3555       sb.Append(")");
3556     }
3557   }
3558   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3559   public class BasicConsume: RabbitMQ.Client.Impl.MethodBase, IBasicConsume {
3560     public const int ClassId = 60;
3561     public const int MethodId = 20;
3562
3563     public ushort m_ticket;
3564     public string m_queue;
3565     public string m_consumerTag;
3566     public bool m_noLocal;
3567     public bool m_noAck;
3568     public bool m_exclusive;
3569     public bool m_nowait;
3570     public System.Collections.IDictionary m_arguments;
3571
3572     ushort IBasicConsume.Ticket { get { return m_ticket; } }
3573     string IBasicConsume.Queue { get { return m_queue; } }
3574     string IBasicConsume.ConsumerTag { get { return m_consumerTag; } }
3575     bool IBasicConsume.NoLocal { get { return m_noLocal; } }
3576     bool IBasicConsume.NoAck { get { return m_noAck; } }
3577     bool IBasicConsume.Exclusive { get { return m_exclusive; } }
3578     bool IBasicConsume.Nowait { get { return m_nowait; } }
3579     System.Collections.IDictionary IBasicConsume.Arguments { get { return m_arguments; } }
3580
3581     public BasicConsume() {}
3582     public BasicConsume(
3583       ushort initTicket,
3584       string initQueue,
3585       string initConsumerTag,
3586       bool initNoLocal,
3587       bool initNoAck,
3588       bool initExclusive,
3589       bool initNowait,
3590       System.Collections.IDictionary initArguments)
3591     {
3592       m_ticket = initTicket;
3593       m_queue = initQueue;
3594       m_consumerTag = initConsumerTag;
3595       m_noLocal = initNoLocal;
3596       m_noAck = initNoAck;
3597       m_exclusive = initExclusive;
3598       m_nowait = initNowait;
3599       m_arguments = initArguments;
3600     }
3601
3602     public override int ProtocolClassId { get { return 60; } }
3603     public override int ProtocolMethodId { get { return 20; } }
3604     public override string ProtocolMethodName { get { return "basic.consume"; } }
3605     public override bool HasContent { get { return false; } }
3606
3607     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3608       m_ticket = reader.ReadShort();
3609       m_queue = reader.ReadShortstr();
3610       m_consumerTag = reader.ReadShortstr();
3611       m_noLocal = reader.ReadBit();
3612       m_noAck = reader.ReadBit();
3613       m_exclusive = reader.ReadBit();
3614       m_nowait = reader.ReadBit();
3615       m_arguments = reader.ReadTable();
3616     }
3617
3618     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3619       writer.WriteShort(m_ticket);
3620       writer.WriteShortstr(m_queue);
3621       writer.WriteShortstr(m_consumerTag);
3622       writer.WriteBit(m_noLocal);
3623       writer.WriteBit(m_noAck);
3624       writer.WriteBit(m_exclusive);
3625       writer.WriteBit(m_nowait);
3626       writer.WriteTable(m_arguments);
3627     }
3628
3629     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3630       sb.Append("(");
3631       sb.Append(m_ticket); sb.Append(",");
3632       sb.Append(m_queue); sb.Append(",");
3633       sb.Append(m_consumerTag); sb.Append(",");
3634       sb.Append(m_noLocal); sb.Append(",");
3635       sb.Append(m_noAck); sb.Append(",");
3636       sb.Append(m_exclusive); sb.Append(",");
3637       sb.Append(m_nowait); sb.Append(",");
3638       sb.Append(m_arguments);
3639       sb.Append(")");
3640     }
3641   }
3642   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3643   public class BasicConsumeOk: RabbitMQ.Client.Impl.MethodBase, IBasicConsumeOk {
3644     public const int ClassId = 60;
3645     public const int MethodId = 21;
3646
3647     public string m_consumerTag;
3648
3649     string IBasicConsumeOk.ConsumerTag { get { return m_consumerTag; } }
3650
3651     public BasicConsumeOk() {}
3652     public BasicConsumeOk(
3653       string initConsumerTag)
3654     {
3655       m_consumerTag = initConsumerTag;
3656     }
3657
3658     public override int ProtocolClassId { get { return 60; } }
3659     public override int ProtocolMethodId { get { return 21; } }
3660     public override string ProtocolMethodName { get { return "basic.consume-ok"; } }
3661     public override bool HasContent { get { return false; } }
3662
3663     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3664       m_consumerTag = reader.ReadShortstr();
3665     }
3666
3667     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3668       writer.WriteShortstr(m_consumerTag);
3669     }
3670
3671     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3672       sb.Append("(");
3673       sb.Append(m_consumerTag);
3674       sb.Append(")");
3675     }
3676   }
3677   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3678   public class BasicCancel: RabbitMQ.Client.Impl.MethodBase, IBasicCancel {
3679     public const int ClassId = 60;
3680     public const int MethodId = 30;
3681
3682     public string m_consumerTag;
3683     public bool m_nowait;
3684
3685     string IBasicCancel.ConsumerTag { get { return m_consumerTag; } }
3686     bool IBasicCancel.Nowait { get { return m_nowait; } }
3687
3688     public BasicCancel() {}
3689     public BasicCancel(
3690       string initConsumerTag,
3691       bool initNowait)
3692     {
3693       m_consumerTag = initConsumerTag;
3694       m_nowait = initNowait;
3695     }
3696
3697     public override int ProtocolClassId { get { return 60; } }
3698     public override int ProtocolMethodId { get { return 30; } }
3699     public override string ProtocolMethodName { get { return "basic.cancel"; } }
3700     public override bool HasContent { get { return false; } }
3701
3702     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3703       m_consumerTag = reader.ReadShortstr();
3704       m_nowait = reader.ReadBit();
3705     }
3706
3707     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3708       writer.WriteShortstr(m_consumerTag);
3709       writer.WriteBit(m_nowait);
3710     }
3711
3712     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3713       sb.Append("(");
3714       sb.Append(m_consumerTag); sb.Append(",");
3715       sb.Append(m_nowait);
3716       sb.Append(")");
3717     }
3718   }
3719   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3720   public class BasicCancelOk: RabbitMQ.Client.Impl.MethodBase, IBasicCancelOk {
3721     public const int ClassId = 60;
3722     public const int MethodId = 31;
3723
3724     public string m_consumerTag;
3725
3726     string IBasicCancelOk.ConsumerTag { get { return m_consumerTag; } }
3727
3728     public BasicCancelOk() {}
3729     public BasicCancelOk(
3730       string initConsumerTag)
3731     {
3732       m_consumerTag = initConsumerTag;
3733     }
3734
3735     public override int ProtocolClassId { get { return 60; } }
3736     public override int ProtocolMethodId { get { return 31; } }
3737     public override string ProtocolMethodName { get { return "basic.cancel-ok"; } }
3738     public override bool HasContent { get { return false; } }
3739
3740     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3741       m_consumerTag = reader.ReadShortstr();
3742     }
3743
3744     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3745       writer.WriteShortstr(m_consumerTag);
3746     }
3747
3748     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3749       sb.Append("(");
3750       sb.Append(m_consumerTag);
3751       sb.Append(")");
3752     }
3753   }
3754   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3755   public class BasicPublish: RabbitMQ.Client.Impl.MethodBase, IBasicPublish {
3756     public const int ClassId = 60;
3757     public const int MethodId = 40;
3758
3759     public ushort m_ticket;
3760     public string m_exchange;
3761     public string m_routingKey;
3762     public bool m_mandatory;
3763     public bool m_immediate;
3764
3765     ushort IBasicPublish.Ticket { get { return m_ticket; } }
3766     string IBasicPublish.Exchange { get { return m_exchange; } }
3767     string IBasicPublish.RoutingKey { get { return m_routingKey; } }
3768     bool IBasicPublish.Mandatory { get { return m_mandatory; } }
3769     bool IBasicPublish.Immediate { get { return m_immediate; } }
3770
3771     public BasicPublish() {}
3772     public BasicPublish(
3773       ushort initTicket,
3774       string initExchange,
3775       string initRoutingKey,
3776       bool initMandatory,
3777       bool initImmediate)
3778     {
3779       m_ticket = initTicket;
3780       m_exchange = initExchange;
3781       m_routingKey = initRoutingKey;
3782       m_mandatory = initMandatory;
3783       m_immediate = initImmediate;
3784     }
3785
3786     public override int ProtocolClassId { get { return 60; } }
3787     public override int ProtocolMethodId { get { return 40; } }
3788     public override string ProtocolMethodName { get { return "basic.publish"; } }
3789     public override bool HasContent { get { return true; } }
3790
3791     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3792       m_ticket = reader.ReadShort();
3793       m_exchange = reader.ReadShortstr();
3794       m_routingKey = reader.ReadShortstr();
3795       m_mandatory = reader.ReadBit();
3796       m_immediate = reader.ReadBit();
3797     }
3798
3799     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3800       writer.WriteShort(m_ticket);
3801       writer.WriteShortstr(m_exchange);
3802       writer.WriteShortstr(m_routingKey);
3803       writer.WriteBit(m_mandatory);
3804       writer.WriteBit(m_immediate);
3805     }
3806
3807     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3808       sb.Append("(");
3809       sb.Append(m_ticket); sb.Append(",");
3810       sb.Append(m_exchange); sb.Append(",");
3811       sb.Append(m_routingKey); sb.Append(",");
3812       sb.Append(m_mandatory); sb.Append(",");
3813       sb.Append(m_immediate);
3814       sb.Append(")");
3815     }
3816   }
3817   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3818   public class BasicReturn: RabbitMQ.Client.Impl.MethodBase, IBasicReturn {
3819     public const int ClassId = 60;
3820     public const int MethodId = 50;
3821
3822     public ushort m_replyCode;
3823     public string m_replyText;
3824     public string m_exchange;
3825     public string m_routingKey;
3826
3827     ushort IBasicReturn.ReplyCode { get { return m_replyCode; } }
3828     string IBasicReturn.ReplyText { get { return m_replyText; } }
3829     string IBasicReturn.Exchange { get { return m_exchange; } }
3830     string IBasicReturn.RoutingKey { get { return m_routingKey; } }
3831
3832     public BasicReturn() {}
3833     public BasicReturn(
3834       ushort initReplyCode,
3835       string initReplyText,
3836       string initExchange,
3837       string initRoutingKey)
3838     {
3839       m_replyCode = initReplyCode;
3840       m_replyText = initReplyText;
3841       m_exchange = initExchange;
3842       m_routingKey = initRoutingKey;
3843     }
3844
3845     public override int ProtocolClassId { get { return 60; } }
3846     public override int ProtocolMethodId { get { return 50; } }
3847     public override string ProtocolMethodName { get { return "basic.return"; } }
3848     public override bool HasContent { get { return true; } }
3849
3850     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3851       m_replyCode = reader.ReadShort();
3852       m_replyText = reader.ReadShortstr();
3853       m_exchange = reader.ReadShortstr();
3854       m_routingKey = reader.ReadShortstr();
3855     }
3856
3857     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3858       writer.WriteShort(m_replyCode);
3859       writer.WriteShortstr(m_replyText);
3860       writer.WriteShortstr(m_exchange);
3861       writer.WriteShortstr(m_routingKey);
3862     }
3863
3864     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3865       sb.Append("(");
3866       sb.Append(m_replyCode); sb.Append(",");
3867       sb.Append(m_replyText); sb.Append(",");
3868       sb.Append(m_exchange); sb.Append(",");
3869       sb.Append(m_routingKey);
3870       sb.Append(")");
3871     }
3872   }
3873   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3874   public class BasicDeliver: RabbitMQ.Client.Impl.MethodBase, IBasicDeliver {
3875     public const int ClassId = 60;
3876     public const int MethodId = 60;
3877
3878     public string m_consumerTag;
3879     public ulong m_deliveryTag;
3880     public bool m_redelivered;
3881     public string m_exchange;
3882     public string m_routingKey;
3883
3884     string IBasicDeliver.ConsumerTag { get { return m_consumerTag; } }
3885     ulong IBasicDeliver.DeliveryTag { get { return m_deliveryTag; } }
3886     bool IBasicDeliver.Redelivered { get { return m_redelivered; } }
3887     string IBasicDeliver.Exchange { get { return m_exchange; } }
3888     string IBasicDeliver.RoutingKey { get { return m_routingKey; } }
3889
3890     public BasicDeliver() {}
3891     public BasicDeliver(
3892       string initConsumerTag,
3893       ulong initDeliveryTag,
3894       bool initRedelivered,
3895       string initExchange,
3896       string initRoutingKey)
3897     {
3898       m_consumerTag = initConsumerTag;
3899       m_deliveryTag = initDeliveryTag;
3900       m_redelivered = initRedelivered;
3901       m_exchange = initExchange;
3902       m_routingKey = initRoutingKey;
3903     }
3904
3905     public override int ProtocolClassId { get { return 60; } }
3906     public override int ProtocolMethodId { get { return 60; } }
3907     public override string ProtocolMethodName { get { return "basic.deliver"; } }
3908     public override bool HasContent { get { return true; } }
3909
3910     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3911       m_consumerTag = reader.ReadShortstr();
3912       m_deliveryTag = reader.ReadLonglong();
3913       m_redelivered = reader.ReadBit();
3914       m_exchange = reader.ReadShortstr();
3915       m_routingKey = reader.ReadShortstr();
3916     }
3917
3918     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3919       writer.WriteShortstr(m_consumerTag);
3920       writer.WriteLonglong(m_deliveryTag);
3921       writer.WriteBit(m_redelivered);
3922       writer.WriteShortstr(m_exchange);
3923       writer.WriteShortstr(m_routingKey);
3924     }
3925
3926     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3927       sb.Append("(");
3928       sb.Append(m_consumerTag); sb.Append(",");
3929       sb.Append(m_deliveryTag); sb.Append(",");
3930       sb.Append(m_redelivered); sb.Append(",");
3931       sb.Append(m_exchange); sb.Append(",");
3932       sb.Append(m_routingKey);
3933       sb.Append(")");
3934     }
3935   }
3936   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3937   public class BasicGet: RabbitMQ.Client.Impl.MethodBase, IBasicGet {
3938     public const int ClassId = 60;
3939     public const int MethodId = 70;
3940
3941     public ushort m_ticket;
3942     public string m_queue;
3943     public bool m_noAck;
3944
3945     ushort IBasicGet.Ticket { get { return m_ticket; } }
3946     string IBasicGet.Queue { get { return m_queue; } }
3947     bool IBasicGet.NoAck { get { return m_noAck; } }
3948
3949     public BasicGet() {}
3950     public BasicGet(
3951       ushort initTicket,
3952       string initQueue,
3953       bool initNoAck)
3954     {
3955       m_ticket = initTicket;
3956       m_queue = initQueue;
3957       m_noAck = initNoAck;
3958     }
3959
3960     public override int ProtocolClassId { get { return 60; } }
3961     public override int ProtocolMethodId { get { return 70; } }
3962     public override string ProtocolMethodName { get { return "basic.get"; } }
3963     public override bool HasContent { get { return false; } }
3964
3965     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3966       m_ticket = reader.ReadShort();
3967       m_queue = reader.ReadShortstr();
3968       m_noAck = reader.ReadBit();
3969     }
3970
3971     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3972       writer.WriteShort(m_ticket);
3973       writer.WriteShortstr(m_queue);
3974       writer.WriteBit(m_noAck);
3975     }
3976
3977     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3978       sb.Append("(");
3979       sb.Append(m_ticket); sb.Append(",");
3980       sb.Append(m_queue); sb.Append(",");
3981       sb.Append(m_noAck);
3982       sb.Append(")");
3983     }
3984   }
3985   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3986   public class BasicGetOk: RabbitMQ.Client.Impl.MethodBase, IBasicGetOk {
3987     public const int ClassId = 60;
3988     public const int MethodId = 71;
3989
3990     public ulong m_deliveryTag;
3991     public bool m_redelivered;
3992     public string m_exchange;
3993     public string m_routingKey;
3994     public uint m_messageCount;
3995
3996     ulong IBasicGetOk.DeliveryTag { get { return m_deliveryTag; } }
3997     bool IBasicGetOk.Redelivered { get { return m_redelivered; } }
3998     string IBasicGetOk.Exchange { get { return m_exchange; } }
3999     string IBasicGetOk.RoutingKey { get { return m_routingKey; } }
4000     uint IBasicGetOk.MessageCount { get { return m_messageCount; } }
4001
4002     public BasicGetOk() {}
4003     public BasicGetOk(
4004       ulong initDeliveryTag,
4005       bool initRedelivered,
4006       string initExchange,
4007       string initRoutingKey,
4008       uint initMessageCount)
4009     {
4010       m_deliveryTag = initDeliveryTag;
4011       m_redelivered = initRedelivered;
4012       m_exchange = initExchange;
4013       m_routingKey = initRoutingKey;
4014       m_messageCount = initMessageCount;
4015     }
4016
4017     public override int ProtocolClassId { get { return 60; } }
4018     public override int ProtocolMethodId { get { return 71; } }
4019     public override string ProtocolMethodName { get { return "basic.get-ok"; } }
4020     public override bool HasContent { get { return true; } }
4021
4022     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4023       m_deliveryTag = reader.ReadLonglong();
4024       m_redelivered = reader.ReadBit();
4025       m_exchange = reader.ReadShortstr();
4026       m_routingKey = reader.ReadShortstr();
4027       m_messageCount = reader.ReadLong();
4028     }
4029
4030     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4031       writer.WriteLonglong(m_deliveryTag);
4032       writer.WriteBit(m_redelivered);
4033       writer.WriteShortstr(m_exchange);
4034       writer.WriteShortstr(m_routingKey);
4035       writer.WriteLong(m_messageCount);
4036     }
4037
4038     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4039       sb.Append("(");
4040       sb.Append(m_deliveryTag); sb.Append(",");
4041       sb.Append(m_redelivered); sb.Append(",");
4042       sb.Append(m_exchange); sb.Append(",");
4043       sb.Append(m_routingKey); sb.Append(",");
4044       sb.Append(m_messageCount);
4045       sb.Append(")");
4046     }
4047   }
4048   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4049   public class BasicGetEmpty: RabbitMQ.Client.Impl.MethodBase, IBasicGetEmpty {
4050     public const int ClassId = 60;
4051     public const int MethodId = 72;
4052
4053     public string m_clusterId;
4054
4055     string IBasicGetEmpty.ClusterId { get { return m_clusterId; } }
4056
4057     public BasicGetEmpty() {}
4058     public BasicGetEmpty(
4059       string initClusterId)
4060     {
4061       m_clusterId = initClusterId;
4062     }
4063
4064     public override int ProtocolClassId { get { return 60; } }
4065     public override int ProtocolMethodId { get { return 72; } }
4066     public override string ProtocolMethodName { get { return "basic.get-empty"; } }
4067     public override bool HasContent { get { return false; } }
4068
4069     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4070       m_clusterId = reader.ReadShortstr();
4071     }
4072
4073     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4074       writer.WriteShortstr(m_clusterId);
4075     }
4076
4077     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4078       sb.Append("(");
4079       sb.Append(m_clusterId);
4080       sb.Append(")");
4081     }
4082   }
4083   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4084   public class BasicAck: RabbitMQ.Client.Impl.MethodBase, IBasicAck {
4085     public const int ClassId = 60;
4086     public const int MethodId = 80;
4087
4088     public ulong m_deliveryTag;
4089     public bool m_multiple;
4090
4091     ulong IBasicAck.DeliveryTag { get { return m_deliveryTag; } }
4092     bool IBasicAck.Multiple { get { return m_multiple; } }
4093
4094     public BasicAck() {}
4095     public BasicAck(
4096       ulong initDeliveryTag,
4097       bool initMultiple)
4098     {
4099       m_deliveryTag = initDeliveryTag;
4100       m_multiple = initMultiple;
4101     }
4102
4103     public override int ProtocolClassId { get { return 60; } }
4104     public override int ProtocolMethodId { get { return 80; } }
4105     public override string ProtocolMethodName { get { return "basic.ack"; } }
4106     public override bool HasContent { get { return false; } }
4107
4108     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4109       m_deliveryTag = reader.ReadLonglong();
4110       m_multiple = reader.ReadBit();
4111     }
4112
4113     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4114       writer.WriteLonglong(m_deliveryTag);
4115       writer.WriteBit(m_multiple);
4116     }
4117
4118     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4119       sb.Append("(");
4120       sb.Append(m_deliveryTag); sb.Append(",");
4121       sb.Append(m_multiple);
4122       sb.Append(")");
4123     }
4124   }
4125   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4126   public class BasicReject: RabbitMQ.Client.Impl.MethodBase, IBasicReject {
4127     public const int ClassId = 60;
4128     public const int MethodId = 90;
4129
4130     public ulong m_deliveryTag;
4131     public bool m_requeue;
4132
4133     ulong IBasicReject.DeliveryTag { get { return m_deliveryTag; } }
4134     bool IBasicReject.Requeue { get { return m_requeue; } }
4135
4136     public BasicReject() {}
4137     public BasicReject(
4138       ulong initDeliveryTag,
4139       bool initRequeue)
4140     {
4141       m_deliveryTag = initDeliveryTag;
4142       m_requeue = initRequeue;
4143     }
4144
4145     public override int ProtocolClassId { get { return 60; } }
4146     public override int ProtocolMethodId { get { return 90; } }
4147     public override string ProtocolMethodName { get { return "basic.reject"; } }
4148     public override bool HasContent { get { return false; } }
4149
4150     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4151       m_deliveryTag = reader.ReadLonglong();
4152       m_requeue = reader.ReadBit();
4153     }
4154
4155     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4156       writer.WriteLonglong(m_deliveryTag);
4157       writer.WriteBit(m_requeue);
4158     }
4159
4160     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4161       sb.Append("(");
4162       sb.Append(m_deliveryTag); sb.Append(",");
4163       sb.Append(m_requeue);
4164       sb.Append(")");
4165     }
4166   }
4167   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4168   public class BasicRecover: RabbitMQ.Client.Impl.MethodBase, IBasicRecover {
4169     public const int ClassId = 60;
4170     public const int MethodId = 100;
4171
4172     public bool m_requeue;
4173
4174     bool IBasicRecover.Requeue { get { return m_requeue; } }
4175
4176     public BasicRecover() {}
4177     public BasicRecover(
4178       bool initRequeue)
4179     {
4180       m_requeue = initRequeue;
4181     }
4182
4183     public override int ProtocolClassId { get { return 60; } }
4184     public override int ProtocolMethodId { get { return 100; } }
4185     public override string ProtocolMethodName { get { return "basic.recover"; } }
4186     public override bool HasContent { get { return false; } }
4187
4188     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4189       m_requeue = reader.ReadBit();
4190     }
4191
4192     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4193       writer.WriteBit(m_requeue);
4194     }
4195
4196     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4197       sb.Append("(");
4198       sb.Append(m_requeue);
4199       sb.Append(")");
4200     }
4201   }
4202   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4203   public class BasicRecoverOk: RabbitMQ.Client.Impl.MethodBase, IBasicRecoverOk {
4204     public const int ClassId = 60;
4205     public const int MethodId = 101;
4206
4207
4208
4209     public BasicRecoverOk(
4210 )
4211     {
4212     }
4213
4214     public override int ProtocolClassId { get { return 60; } }
4215     public override int ProtocolMethodId { get { return 101; } }
4216     public override string ProtocolMethodName { get { return "basic.recover-ok"; } }
4217     public override bool HasContent { get { return false; } }
4218
4219     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4220     }
4221
4222     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4223     }
4224
4225     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4226       sb.Append("(");
4227       sb.Append(")");
4228     }
4229   }
4230   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4231   public class FileQos: RabbitMQ.Client.Impl.MethodBase, IFileQos {
4232     public const int ClassId = 70;
4233     public const int MethodId = 10;
4234
4235     public uint m_prefetchSize;
4236     public ushort m_prefetchCount;
4237     public bool m_global;
4238
4239     uint IFileQos.PrefetchSize { get { return m_prefetchSize; } }
4240     ushort IFileQos.PrefetchCount { get { return m_prefetchCount; } }
4241     bool IFileQos.Global { get { return m_global; } }
4242
4243     public FileQos() {}
4244     public FileQos(
4245       uint initPrefetchSize,
4246       ushort initPrefetchCount,
4247       bool initGlobal)
4248     {
4249       m_prefetchSize = initPrefetchSize;
4250       m_prefetchCount = initPrefetchCount;
4251       m_global = initGlobal;
4252     }
4253
4254     public override int ProtocolClassId { get { return 70; } }
4255     public override int ProtocolMethodId { get { return 10; } }
4256     public override string ProtocolMethodName { get { return "file.qos"; } }
4257     public override bool HasContent { get { return false; } }
4258
4259     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4260       m_prefetchSize = reader.ReadLong();
4261       m_prefetchCount = reader.ReadShort();
4262       m_global = reader.ReadBit();
4263     }
4264
4265     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4266       writer.WriteLong(m_prefetchSize);
4267       writer.WriteShort(m_prefetchCount);
4268       writer.WriteBit(m_global);
4269     }
4270
4271     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4272       sb.Append("(");
4273       sb.Append(m_prefetchSize); sb.Append(",");
4274       sb.Append(m_prefetchCount); sb.Append(",");
4275       sb.Append(m_global);
4276       sb.Append(")");
4277     }
4278   }
4279   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4280   public class FileQosOk: RabbitMQ.Client.Impl.MethodBase, IFileQosOk {
4281     public const int ClassId = 70;
4282     public const int MethodId = 11;
4283
4284
4285
4286     public FileQosOk(
4287 )
4288     {
4289     }
4290
4291     public override int ProtocolClassId { get { return 70; } }
4292     public override int ProtocolMethodId { get { return 11; } }
4293     public override string ProtocolMethodName { get { return "file.qos-ok"; } }
4294     public override bool HasContent { get { return false; } }
4295
4296     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4297     }
4298
4299     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4300     }
4301
4302     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4303       sb.Append("(");
4304       sb.Append(")");
4305     }
4306   }
4307   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4308   public class FileConsume: RabbitMQ.Client.Impl.MethodBase, IFileConsume {
4309     public const int ClassId = 70;
4310     public const int MethodId = 20;
4311
4312     public ushort m_ticket;
4313     public string m_queue;
4314     public string m_consumerTag;
4315     public bool m_noLocal;
4316     public bool m_noAck;
4317     public bool m_exclusive;
4318     public bool m_nowait;
4319
4320     ushort IFileConsume.Ticket { get { return m_ticket; } }
4321     string IFileConsume.Queue { get { return m_queue; } }
4322     string IFileConsume.ConsumerTag { get { return m_consumerTag; } }
4323     bool IFileConsume.NoLocal { get { return m_noLocal; } }
4324     bool IFileConsume.NoAck { get { return m_noAck; } }
4325     bool IFileConsume.Exclusive { get { return m_exclusive; } }
4326     bool IFileConsume.Nowait { get { return m_nowait; } }
4327
4328     public FileConsume() {}
4329     public FileConsume(
4330       ushort initTicket,
4331       string initQueue,
4332       string initConsumerTag,
4333       bool initNoLocal,
4334       bool initNoAck,
4335       bool initExclusive,
4336       bool initNowait)
4337     {
4338       m_ticket = initTicket;
4339       m_queue = initQueue;
4340       m_consumerTag = initConsumerTag;
4341       m_noLocal = initNoLocal;
4342       m_noAck = initNoAck;
4343       m_exclusive = initExclusive;
4344       m_nowait = initNowait;
4345     }
4346
4347     public override int ProtocolClassId { get { return 70; } }
4348     public override int ProtocolMethodId { get { return 20; } }
4349     public override string ProtocolMethodName { get { return "file.consume"; } }
4350     public override bool HasContent { get { return false; } }
4351
4352     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4353       m_ticket = reader.ReadShort();
4354       m_queue = reader.ReadShortstr();
4355       m_consumerTag = reader.ReadShortstr();
4356       m_noLocal = reader.ReadBit();
4357       m_noAck = reader.ReadBit();
4358       m_exclusive = reader.ReadBit();
4359       m_nowait = reader.ReadBit();
4360     }
4361
4362     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4363       writer.WriteShort(m_ticket);
4364       writer.WriteShortstr(m_queue);
4365       writer.WriteShortstr(m_consumerTag);
4366       writer.WriteBit(m_noLocal);
4367       writer.WriteBit(m_noAck);
4368       writer.WriteBit(m_exclusive);
4369       writer.WriteBit(m_nowait);
4370     }
4371
4372     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4373       sb.Append("(");
4374       sb.Append(m_ticket); sb.Append(",");
4375       sb.Append(m_queue); sb.Append(",");
4376       sb.Append(m_consumerTag); sb.Append(",");
4377       sb.Append(m_noLocal); sb.Append(",");
4378       sb.Append(m_noAck); sb.Append(",");
4379       sb.Append(m_exclusive); sb.Append(",");
4380       sb.Append(m_nowait);
4381       sb.Append(")");
4382     }
4383   }
4384   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4385   public class FileConsumeOk: RabbitMQ.Client.Impl.MethodBase, IFileConsumeOk {
4386     public const int ClassId = 70;
4387     public const int MethodId = 21;
4388
4389     public string m_consumerTag;
4390
4391     string IFileConsumeOk.ConsumerTag { get { return m_consumerTag; } }
4392
4393     public FileConsumeOk() {}
4394     public FileConsumeOk(
4395       string initConsumerTag)
4396     {
4397       m_consumerTag = initConsumerTag;
4398     }
4399
4400     public override int ProtocolClassId { get { return 70; } }
4401     public override int ProtocolMethodId { get { return 21; } }
4402     public override string ProtocolMethodName { get { return "file.consume-ok"; } }
4403     public override bool HasContent { get { return false; } }
4404
4405     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4406       m_consumerTag = reader.ReadShortstr();
4407     }
4408
4409     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4410       writer.WriteShortstr(m_consumerTag);
4411     }
4412
4413     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4414       sb.Append("(");
4415       sb.Append(m_consumerTag);
4416       sb.Append(")");
4417     }
4418   }
4419   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4420   public class FileCancel: RabbitMQ.Client.Impl.MethodBase, IFileCancel {
4421     public const int ClassId = 70;
4422     public const int MethodId = 30;
4423
4424     public string m_consumerTag;
4425     public bool m_nowait;
4426
4427     string IFileCancel.ConsumerTag { get { return m_consumerTag; } }
4428     bool IFileCancel.Nowait { get { return m_nowait; } }
4429
4430     public FileCancel() {}
4431     public FileCancel(
4432       string initConsumerTag,
4433       bool initNowait)
4434     {
4435       m_consumerTag = initConsumerTag;
4436       m_nowait = initNowait;
4437     }
4438
4439     public override int ProtocolClassId { get { return 70; } }
4440     public override int ProtocolMethodId { get { return 30; } }
4441     public override string ProtocolMethodName { get { return "file.cancel"; } }
4442     public override bool HasContent { get { return false; } }
4443
4444     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4445       m_consumerTag = reader.ReadShortstr();
4446       m_nowait = reader.ReadBit();
4447     }
4448
4449     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4450       writer.WriteShortstr(m_consumerTag);
4451       writer.WriteBit(m_nowait);
4452     }
4453
4454     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4455       sb.Append("(");
4456       sb.Append(m_consumerTag); sb.Append(",");
4457       sb.Append(m_nowait);
4458       sb.Append(")");
4459     }
4460   }
4461   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4462   public class FileCancelOk: RabbitMQ.Client.Impl.MethodBase, IFileCancelOk {
4463     public const int ClassId = 70;
4464     public const int MethodId = 31;
4465
4466     public string m_consumerTag;
4467
4468     string IFileCancelOk.ConsumerTag { get { return m_consumerTag; } }
4469
4470     public FileCancelOk() {}
4471     public FileCancelOk(
4472       string initConsumerTag)
4473     {
4474       m_consumerTag = initConsumerTag;
4475     }
4476
4477     public override int ProtocolClassId { get { return 70; } }
4478     public override int ProtocolMethodId { get { return 31; } }
4479     public override string ProtocolMethodName { get { return "file.cancel-ok"; } }
4480     public override bool HasContent { get { return false; } }
4481
4482     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4483       m_consumerTag = reader.ReadShortstr();
4484     }
4485
4486     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4487       writer.WriteShortstr(m_consumerTag);
4488     }
4489
4490     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4491       sb.Append("(");
4492       sb.Append(m_consumerTag);
4493       sb.Append(")");
4494     }
4495   }
4496   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4497   public class FileOpen: RabbitMQ.Client.Impl.MethodBase, IFileOpen {
4498     public const int ClassId = 70;
4499     public const int MethodId = 40;
4500
4501     public string m_identifier;
4502     public ulong m_contentSize;
4503
4504     string IFileOpen.Identifier { get { return m_identifier; } }
4505     ulong IFileOpen.ContentSize { get { return m_contentSize; } }
4506
4507     public FileOpen() {}
4508     public FileOpen(
4509       string initIdentifier,
4510       ulong initContentSize)
4511     {
4512       m_identifier = initIdentifier;
4513       m_contentSize = initContentSize;
4514     }
4515
4516     public override int ProtocolClassId { get { return 70; } }
4517     public override int ProtocolMethodId { get { return 40; } }
4518     public override string ProtocolMethodName { get { return "file.open"; } }
4519     public override bool HasContent { get { return false; } }
4520
4521     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4522       m_identifier = reader.ReadShortstr();
4523       m_contentSize = reader.ReadLonglong();
4524     }
4525
4526     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4527       writer.WriteShortstr(m_identifier);
4528       writer.WriteLonglong(m_contentSize);
4529     }
4530
4531     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4532       sb.Append("(");
4533       sb.Append(m_identifier); sb.Append(",");
4534       sb.Append(m_contentSize);
4535       sb.Append(")");
4536     }
4537   }
4538   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4539   public class FileOpenOk: RabbitMQ.Client.Impl.MethodBase, IFileOpenOk {
4540     public const int ClassId = 70;
4541     public const int MethodId = 41;
4542
4543     public ulong m_stagedSize;
4544
4545     ulong IFileOpenOk.StagedSize { get { return m_stagedSize; } }
4546
4547     public FileOpenOk() {}
4548     public FileOpenOk(
4549       ulong initStagedSize)
4550     {
4551       m_stagedSize = initStagedSize;
4552     }
4553
4554     public override int ProtocolClassId { get { return 70; } }
4555     public override int ProtocolMethodId { get { return 41; } }
4556     public override string ProtocolMethodName { get { return "file.open-ok"; } }
4557     public override bool HasContent { get { return false; } }
4558
4559     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4560       m_stagedSize = reader.ReadLonglong();
4561     }
4562
4563     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4564       writer.WriteLonglong(m_stagedSize);
4565     }
4566
4567     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4568       sb.Append("(");
4569       sb.Append(m_stagedSize);
4570       sb.Append(")");
4571     }
4572   }
4573   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4574   public class FileStage: RabbitMQ.Client.Impl.MethodBase, IFileStage {
4575     public const int ClassId = 70;
4576     public const int MethodId = 50;
4577
4578
4579
4580     public FileStage(
4581 )
4582     {
4583     }
4584
4585     public override int ProtocolClassId { get { return 70; } }
4586     public override int ProtocolMethodId { get { return 50; } }
4587     public override string ProtocolMethodName { get { return "file.stage"; } }
4588     public override bool HasContent { get { return true; } }
4589
4590     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4591     }
4592
4593     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4594     }
4595
4596     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4597       sb.Append("(");
4598       sb.Append(")");
4599     }
4600   }
4601   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4602   public class FilePublish: RabbitMQ.Client.Impl.MethodBase, IFilePublish {
4603     public const int ClassId = 70;
4604     public const int MethodId = 60;
4605
4606     public ushort m_ticket;
4607     public string m_exchange;
4608     public string m_routingKey;
4609     public bool m_mandatory;
4610     public bool m_immediate;
4611     public string m_identifier;
4612
4613     ushort IFilePublish.Ticket { get { return m_ticket; } }
4614     string IFilePublish.Exchange { get { return m_exchange; } }
4615     string IFilePublish.RoutingKey { get { return m_routingKey; } }
4616     bool IFilePublish.Mandatory { get { return m_mandatory; } }
4617     bool IFilePublish.Immediate { get { return m_immediate; } }
4618     string IFilePublish.Identifier { get { return m_identifier; } }
4619
4620     public FilePublish() {}
4621     public FilePublish(
4622       ushort initTicket,
4623       string initExchange,
4624       string initRoutingKey,
4625       bool initMandatory,
4626       bool initImmediate,
4627       string initIdentifier)
4628     {
4629       m_ticket = initTicket;
4630       m_exchange = initExchange;
4631       m_routingKey = initRoutingKey;
4632       m_mandatory = initMandatory;
4633       m_immediate = initImmediate;
4634       m_identifier = initIdentifier;
4635     }
4636
4637     public override int ProtocolClassId { get { return 70; } }
4638     public override int ProtocolMethodId { get { return 60; } }
4639     public override string ProtocolMethodName { get { return "file.publish"; } }
4640     public override bool HasContent { get { return false; } }
4641
4642     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4643       m_ticket = reader.ReadShort();
4644       m_exchange = reader.ReadShortstr();
4645       m_routingKey = reader.ReadShortstr();
4646       m_mandatory = reader.ReadBit();
4647       m_immediate = reader.ReadBit();
4648       m_identifier = reader.ReadShortstr();
4649     }
4650
4651     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4652       writer.WriteShort(m_ticket);
4653       writer.WriteShortstr(m_exchange);
4654       writer.WriteShortstr(m_routingKey);
4655       writer.WriteBit(m_mandatory);
4656       writer.WriteBit(m_immediate);
4657       writer.WriteShortstr(m_identifier);
4658     }
4659
4660     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4661       sb.Append("(");
4662       sb.Append(m_ticket); sb.Append(",");
4663       sb.Append(m_exchange); sb.Append(",");
4664       sb.Append(m_routingKey); sb.Append(",");
4665       sb.Append(m_mandatory); sb.Append(",");
4666       sb.Append(m_immediate); sb.Append(",");
4667       sb.Append(m_identifier);
4668       sb.Append(")");
4669     }
4670   }
4671   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4672   public class FileReturn: RabbitMQ.Client.Impl.MethodBase, IFileReturn {
4673     public const int ClassId = 70;
4674     public const int MethodId = 70;
4675
4676     public ushort m_replyCode;
4677     public string m_replyText;
4678     public string m_exchange;
4679     public string m_routingKey;
4680
4681     ushort IFileReturn.ReplyCode { get { return m_replyCode; } }
4682     string IFileReturn.ReplyText { get { return m_replyText; } }
4683     string IFileReturn.Exchange { get { return m_exchange; } }
4684     string IFileReturn.RoutingKey { get { return m_routingKey; } }
4685
4686     public FileReturn() {}
4687     public FileReturn(
4688       ushort initReplyCode,
4689       string initReplyText,
4690       string initExchange,
4691       string initRoutingKey)
4692     {
4693       m_replyCode = initReplyCode;
4694       m_replyText = initReplyText;
4695       m_exchange = initExchange;
4696       m_routingKey = initRoutingKey;
4697     }
4698
4699     public override int ProtocolClassId { get { return 70; } }
4700     public override int ProtocolMethodId { get { return 70; } }
4701     public override string ProtocolMethodName { get { return "file.return"; } }
4702     public override bool HasContent { get { return true; } }
4703
4704     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4705       m_replyCode = reader.ReadShort();
4706       m_replyText = reader.ReadShortstr();
4707       m_exchange = reader.ReadShortstr();
4708       m_routingKey = reader.ReadShortstr();
4709     }
4710
4711     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4712       writer.WriteShort(m_replyCode);
4713       writer.WriteShortstr(m_replyText);
4714       writer.WriteShortstr(m_exchange);
4715       writer.WriteShortstr(m_routingKey);
4716     }
4717
4718     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4719       sb.Append("(");
4720       sb.Append(m_replyCode); sb.Append(",");
4721       sb.Append(m_replyText); sb.Append(",");
4722       sb.Append(m_exchange); sb.Append(",");
4723       sb.Append(m_routingKey);
4724       sb.Append(")");
4725     }
4726   }
4727   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4728   public class FileDeliver: RabbitMQ.Client.Impl.MethodBase, IFileDeliver {
4729     public const int ClassId = 70;
4730     public const int MethodId = 80;
4731
4732     public string m_consumerTag;
4733     public ulong m_deliveryTag;
4734     public bool m_redelivered;
4735     public string m_exchange;
4736     public string m_routingKey;
4737     public string m_identifier;
4738
4739     string IFileDeliver.ConsumerTag { get { return m_consumerTag; } }
4740     ulong IFileDeliver.DeliveryTag { get { return m_deliveryTag; } }
4741     bool IFileDeliver.Redelivered { get { return m_redelivered; } }
4742     string IFileDeliver.Exchange { get { return m_exchange; } }
4743     string IFileDeliver.RoutingKey { get { return m_routingKey; } }
4744     string IFileDeliver.Identifier { get { return m_identifier; } }
4745
4746     public FileDeliver() {}
4747     public FileDeliver(
4748       string initConsumerTag,
4749       ulong initDeliveryTag,
4750       bool initRedelivered,
4751       string initExchange,
4752       string initRoutingKey,
4753       string initIdentifier)
4754     {
4755       m_consumerTag = initConsumerTag;
4756       m_deliveryTag = initDeliveryTag;
4757       m_redelivered = initRedelivered;
4758       m_exchange = initExchange;
4759       m_routingKey = initRoutingKey;
4760       m_identifier = initIdentifier;
4761     }
4762
4763     public override int ProtocolClassId { get { return 70; } }
4764     public override int ProtocolMethodId { get { return 80; } }
4765     public override string ProtocolMethodName { get { return "file.deliver"; } }
4766     public override bool HasContent { get { return false; } }
4767
4768     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4769       m_consumerTag = reader.ReadShortstr();
4770       m_deliveryTag = reader.ReadLonglong();
4771       m_redelivered = reader.ReadBit();
4772       m_exchange = reader.ReadShortstr();
4773       m_routingKey = reader.ReadShortstr();
4774       m_identifier = reader.ReadShortstr();
4775     }
4776
4777     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4778       writer.WriteShortstr(m_consumerTag);
4779       writer.WriteLonglong(m_deliveryTag);
4780       writer.WriteBit(m_redelivered);
4781       writer.WriteShortstr(m_exchange);
4782       writer.WriteShortstr(m_routingKey);
4783       writer.WriteShortstr(m_identifier);
4784     }
4785
4786     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4787       sb.Append("(");
4788       sb.Append(m_consumerTag); sb.Append(",");
4789       sb.Append(m_deliveryTag); sb.Append(",");
4790       sb.Append(m_redelivered); sb.Append(",");
4791       sb.Append(m_exchange); sb.Append(",");
4792       sb.Append(m_routingKey); sb.Append(",");
4793       sb.Append(m_identifier);
4794       sb.Append(")");
4795     }
4796   }
4797   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4798   public class FileAck: RabbitMQ.Client.Impl.MethodBase, IFileAck {
4799     public const int ClassId = 70;
4800     public const int MethodId = 90;
4801
4802     public ulong m_deliveryTag;
4803     public bool m_multiple;
4804
4805     ulong IFileAck.DeliveryTag { get { return m_deliveryTag; } }
4806     bool IFileAck.Multiple { get { return m_multiple; } }
4807
4808     public FileAck() {}
4809     public FileAck(
4810       ulong initDeliveryTag,
4811       bool initMultiple)
4812     {
4813       m_deliveryTag = initDeliveryTag;
4814       m_multiple = initMultiple;
4815     }
4816
4817     public override int ProtocolClassId { get { return 70; } }
4818     public override int ProtocolMethodId { get { return 90; } }
4819     public override string ProtocolMethodName { get { return "file.ack"; } }
4820     public override bool HasContent { get { return false; } }
4821
4822     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4823       m_deliveryTag = reader.ReadLonglong();
4824       m_multiple = reader.ReadBit();
4825     }
4826
4827     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4828       writer.WriteLonglong(m_deliveryTag);
4829       writer.WriteBit(m_multiple);
4830     }
4831
4832     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4833       sb.Append("(");
4834       sb.Append(m_deliveryTag); sb.Append(",");
4835       sb.Append(m_multiple);
4836       sb.Append(")");
4837     }
4838   }
4839   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4840   public class FileReject: RabbitMQ.Client.Impl.MethodBase, IFileReject {
4841     public const int ClassId = 70;
4842     public const int MethodId = 100;
4843
4844     public ulong m_deliveryTag;
4845     public bool m_requeue;
4846
4847     ulong IFileReject.DeliveryTag { get { return m_deliveryTag; } }
4848     bool IFileReject.Requeue { get { return m_requeue; } }
4849
4850     public FileReject() {}
4851     public FileReject(
4852       ulong initDeliveryTag,
4853       bool initRequeue)
4854     {
4855       m_deliveryTag = initDeliveryTag;
4856       m_requeue = initRequeue;
4857     }
4858
4859     public override int ProtocolClassId { get { return 70; } }
4860     public override int ProtocolMethodId { get { return 100; } }
4861     public override string ProtocolMethodName { get { return "file.reject"; } }
4862     public override bool HasContent { get { return false; } }
4863
4864     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4865       m_deliveryTag = reader.ReadLonglong();
4866       m_requeue = reader.ReadBit();
4867     }
4868
4869     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4870       writer.WriteLonglong(m_deliveryTag);
4871       writer.WriteBit(m_requeue);
4872     }
4873
4874     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4875       sb.Append("(");
4876       sb.Append(m_deliveryTag); sb.Append(",");
4877       sb.Append(m_requeue);
4878       sb.Append(")");
4879     }
4880   }
4881   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4882   public class StreamQos: RabbitMQ.Client.Impl.MethodBase, IStreamQos {
4883     public const int ClassId = 80;
4884     public const int MethodId = 10;
4885
4886     public uint m_prefetchSize;
4887     public ushort m_prefetchCount;
4888     public uint m_consumeRate;
4889     public bool m_global;
4890
4891     uint IStreamQos.PrefetchSize { get { return m_prefetchSize; } }
4892     ushort IStreamQos.PrefetchCount { get { return m_prefetchCount; } }
4893     uint IStreamQos.ConsumeRate { get { return m_consumeRate; } }
4894     bool IStreamQos.Global { get { return m_global; } }
4895
4896     public StreamQos() {}
4897     public StreamQos(
4898       uint initPrefetchSize,
4899       ushort initPrefetchCount,
4900       uint initConsumeRate,
4901       bool initGlobal)
4902     {
4903       m_prefetchSize = initPrefetchSize;
4904       m_prefetchCount = initPrefetchCount;
4905       m_consumeRate = initConsumeRate;
4906       m_global = initGlobal;
4907     }
4908
4909     public override int ProtocolClassId { get { return 80; } }
4910     public override int ProtocolMethodId { get { return 10; } }
4911     public override string ProtocolMethodName { get { return "stream.qos"; } }
4912     public override bool HasContent { get { return false; } }
4913
4914     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4915       m_prefetchSize = reader.ReadLong();
4916       m_prefetchCount = reader.ReadShort();
4917       m_consumeRate = reader.ReadLong();
4918       m_global = reader.ReadBit();
4919     }
4920
4921     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4922       writer.WriteLong(m_prefetchSize);
4923       writer.WriteShort(m_prefetchCount);
4924       writer.WriteLong(m_consumeRate);
4925       writer.WriteBit(m_global);
4926     }
4927
4928     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4929       sb.Append("(");
4930       sb.Append(m_prefetchSize); sb.Append(",");
4931       sb.Append(m_prefetchCount); sb.Append(",");
4932       sb.Append(m_consumeRate); sb.Append(",");
4933       sb.Append(m_global);
4934       sb.Append(")");
4935     }
4936   }
4937   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4938   public class StreamQosOk: RabbitMQ.Client.Impl.MethodBase, IStreamQosOk {
4939     public const int ClassId = 80;
4940     public const int MethodId = 11;
4941
4942
4943
4944     public StreamQosOk(
4945 )
4946     {
4947     }
4948
4949     public override int ProtocolClassId { get { return 80; } }
4950     public override int ProtocolMethodId { get { return 11; } }
4951     public override string ProtocolMethodName { get { return "stream.qos-ok"; } }
4952     public override bool HasContent { get { return false; } }
4953
4954     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4955     }
4956
4957     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4958     }
4959
4960     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4961       sb.Append("(");
4962       sb.Append(")");
4963     }
4964   }
4965   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4966   public class StreamConsume: RabbitMQ.Client.Impl.MethodBase, IStreamConsume {
4967     public const int ClassId = 80;
4968     public const int MethodId = 20;
4969
4970     public ushort m_ticket;
4971     public string m_queue;
4972     public string m_consumerTag;
4973     public bool m_noLocal;
4974     public bool m_exclusive;
4975     public bool m_nowait;
4976
4977     ushort IStreamConsume.Ticket { get { return m_ticket; } }
4978     string IStreamConsume.Queue { get { return m_queue; } }
4979     string IStreamConsume.ConsumerTag { get { return m_consumerTag; } }
4980     bool IStreamConsume.NoLocal { get { return m_noLocal; } }
4981     bool IStreamConsume.Exclusive { get { return m_exclusive; } }
4982     bool IStreamConsume.Nowait { get { return m_nowait; } }
4983
4984     public StreamConsume() {}
4985     public StreamConsume(
4986       ushort initTicket,
4987       string initQueue,
4988       string initConsumerTag,
4989       bool initNoLocal,
4990       bool initExclusive,
4991       bool initNowait)
4992     {
4993       m_ticket = initTicket;
4994       m_queue = initQueue;
4995       m_consumerTag = initConsumerTag;
4996       m_noLocal = initNoLocal;
4997       m_exclusive = initExclusive;
4998       m_nowait = initNowait;
4999     }
5000
5001     public override int ProtocolClassId { get { return 80; } }
5002     public override int ProtocolMethodId { get { return 20; } }
5003     public override string ProtocolMethodName { get { return "stream.consume"; } }
5004     public override bool HasContent { get { return false; } }
5005
5006     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5007       m_ticket = reader.ReadShort();
5008       m_queue = reader.ReadShortstr();
5009       m_consumerTag = reader.ReadShortstr();
5010       m_noLocal = reader.ReadBit();
5011       m_exclusive = reader.ReadBit();
5012       m_nowait = reader.ReadBit();
5013     }
5014
5015     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5016       writer.WriteShort(m_ticket);
5017       writer.WriteShortstr(m_queue);
5018       writer.WriteShortstr(m_consumerTag);
5019       writer.WriteBit(m_noLocal);
5020       writer.WriteBit(m_exclusive);
5021       writer.WriteBit(m_nowait);
5022     }
5023
5024     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5025       sb.Append("(");
5026       sb.Append(m_ticket); sb.Append(",");
5027       sb.Append(m_queue); sb.Append(",");
5028       sb.Append(m_consumerTag); sb.Append(",");
5029       sb.Append(m_noLocal); sb.Append(",");
5030       sb.Append(m_exclusive); sb.Append(",");
5031       sb.Append(m_nowait);
5032       sb.Append(")");
5033     }
5034   }
5035   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5036   public class StreamConsumeOk: RabbitMQ.Client.Impl.MethodBase, IStreamConsumeOk {
5037     public const int ClassId = 80;
5038     public const int MethodId = 21;
5039
5040     public string m_consumerTag;
5041
5042     string IStreamConsumeOk.ConsumerTag { get { return m_consumerTag; } }
5043
5044     public StreamConsumeOk() {}
5045     public StreamConsumeOk(
5046       string initConsumerTag)
5047     {
5048       m_consumerTag = initConsumerTag;
5049     }
5050
5051     public override int ProtocolClassId { get { return 80; } }
5052     public override int ProtocolMethodId { get { return 21; } }
5053     public override string ProtocolMethodName { get { return "stream.consume-ok"; } }
5054     public override bool HasContent { get { return false; } }
5055
5056     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5057       m_consumerTag = reader.ReadShortstr();
5058     }
5059
5060     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5061       writer.WriteShortstr(m_consumerTag);
5062     }
5063
5064     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5065       sb.Append("(");
5066       sb.Append(m_consumerTag);
5067       sb.Append(")");
5068     }
5069   }
5070   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5071   public class StreamCancel: RabbitMQ.Client.Impl.MethodBase, IStreamCancel {
5072     public const int ClassId = 80;
5073     public const int MethodId = 30;
5074
5075     public string m_consumerTag;
5076     public bool m_nowait;
5077
5078     string IStreamCancel.ConsumerTag { get { return m_consumerTag; } }
5079     bool IStreamCancel.Nowait { get { return m_nowait; } }
5080
5081     public StreamCancel() {}
5082     public StreamCancel(
5083       string initConsumerTag,
5084       bool initNowait)
5085     {
5086       m_consumerTag = initConsumerTag;
5087       m_nowait = initNowait;
5088     }
5089
5090     public override int ProtocolClassId { get { return 80; } }
5091     public override int ProtocolMethodId { get { return 30; } }
5092     public override string ProtocolMethodName { get { return "stream.cancel"; } }
5093     public override bool HasContent { get { return false; } }
5094
5095     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5096       m_consumerTag = reader.ReadShortstr();
5097       m_nowait = reader.ReadBit();
5098     }
5099
5100     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5101       writer.WriteShortstr(m_consumerTag);
5102       writer.WriteBit(m_nowait);
5103     }
5104
5105     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5106       sb.Append("(");
5107       sb.Append(m_consumerTag); sb.Append(",");
5108       sb.Append(m_nowait);
5109       sb.Append(")");
5110     }
5111   }
5112   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5113   public class StreamCancelOk: RabbitMQ.Client.Impl.MethodBase, IStreamCancelOk {
5114     public const int ClassId = 80;
5115     public const int MethodId = 31;
5116
5117     public string m_consumerTag;
5118
5119     string IStreamCancelOk.ConsumerTag { get { return m_consumerTag; } }
5120
5121     public StreamCancelOk() {}
5122     public StreamCancelOk(
5123       string initConsumerTag)
5124     {
5125       m_consumerTag = initConsumerTag;
5126     }
5127
5128     public override int ProtocolClassId { get { return 80; } }
5129     public override int ProtocolMethodId { get { return 31; } }
5130     public override string ProtocolMethodName { get { return "stream.cancel-ok"; } }
5131     public override bool HasContent { get { return false; } }
5132
5133     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5134       m_consumerTag = reader.ReadShortstr();
5135     }
5136
5137     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5138       writer.WriteShortstr(m_consumerTag);
5139     }
5140
5141     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5142       sb.Append("(");
5143       sb.Append(m_consumerTag);
5144       sb.Append(")");
5145     }
5146   }
5147   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5148   public class StreamPublish: RabbitMQ.Client.Impl.MethodBase, IStreamPublish {
5149     public const int ClassId = 80;
5150     public const int MethodId = 40;
5151
5152     public ushort m_ticket;
5153     public string m_exchange;
5154     public string m_routingKey;
5155     public bool m_mandatory;
5156     public bool m_immediate;
5157
5158     ushort IStreamPublish.Ticket { get { return m_ticket; } }
5159     string IStreamPublish.Exchange { get { return m_exchange; } }
5160     string IStreamPublish.RoutingKey { get { return m_routingKey; } }
5161     bool IStreamPublish.Mandatory { get { return m_mandatory; } }
5162     bool IStreamPublish.Immediate { get { return m_immediate; } }
5163
5164     public StreamPublish() {}
5165     public StreamPublish(
5166       ushort initTicket,
5167       string initExchange,
5168       string initRoutingKey,
5169       bool initMandatory,
5170       bool initImmediate)
5171     {
5172       m_ticket = initTicket;
5173       m_exchange = initExchange;
5174       m_routingKey = initRoutingKey;
5175       m_mandatory = initMandatory;
5176       m_immediate = initImmediate;
5177     }
5178
5179     public override int ProtocolClassId { get { return 80; } }
5180     public override int ProtocolMethodId { get { return 40; } }
5181     public override string ProtocolMethodName { get { return "stream.publish"; } }
5182     public override bool HasContent { get { return true; } }
5183
5184     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5185       m_ticket = reader.ReadShort();
5186       m_exchange = reader.ReadShortstr();
5187       m_routingKey = reader.ReadShortstr();
5188       m_mandatory = reader.ReadBit();
5189       m_immediate = reader.ReadBit();
5190     }
5191
5192     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5193       writer.WriteShort(m_ticket);
5194       writer.WriteShortstr(m_exchange);
5195       writer.WriteShortstr(m_routingKey);
5196       writer.WriteBit(m_mandatory);
5197       writer.WriteBit(m_immediate);
5198     }
5199
5200     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5201       sb.Append("(");
5202       sb.Append(m_ticket); sb.Append(",");
5203       sb.Append(m_exchange); sb.Append(",");
5204       sb.Append(m_routingKey); sb.Append(",");
5205       sb.Append(m_mandatory); sb.Append(",");
5206       sb.Append(m_immediate);
5207       sb.Append(")");
5208     }
5209   }
5210   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5211   public class StreamReturn: RabbitMQ.Client.Impl.MethodBase, IStreamReturn {
5212     public const int ClassId = 80;
5213     public const int MethodId = 50;
5214
5215     public ushort m_replyCode;
5216     public string m_replyText;
5217     public string m_exchange;
5218     public string m_routingKey;
5219
5220     ushort IStreamReturn.ReplyCode { get { return m_replyCode; } }
5221     string IStreamReturn.ReplyText { get { return m_replyText; } }
5222     string IStreamReturn.Exchange { get { return m_exchange; } }
5223     string IStreamReturn.RoutingKey { get { return m_routingKey; } }
5224
5225     public StreamReturn() {}
5226     public StreamReturn(
5227       ushort initReplyCode,
5228       string initReplyText,
5229       string initExchange,
5230       string initRoutingKey)
5231     {
5232       m_replyCode = initReplyCode;
5233       m_replyText = initReplyText;
5234       m_exchange = initExchange;
5235       m_routingKey = initRoutingKey;
5236     }
5237
5238     public override int ProtocolClassId { get { return 80; } }
5239     public override int ProtocolMethodId { get { return 50; } }
5240     public override string ProtocolMethodName { get { return "stream.return"; } }
5241     public override bool HasContent { get { return true; } }
5242
5243     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5244       m_replyCode = reader.ReadShort();
5245       m_replyText = reader.ReadShortstr();
5246       m_exchange = reader.ReadShortstr();
5247       m_routingKey = reader.ReadShortstr();
5248     }
5249
5250     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5251       writer.WriteShort(m_replyCode);
5252       writer.WriteShortstr(m_replyText);
5253       writer.WriteShortstr(m_exchange);
5254       writer.WriteShortstr(m_routingKey);
5255     }
5256
5257     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5258       sb.Append("(");
5259       sb.Append(m_replyCode); sb.Append(",");
5260       sb.Append(m_replyText); sb.Append(",");
5261       sb.Append(m_exchange); sb.Append(",");
5262       sb.Append(m_routingKey);
5263       sb.Append(")");
5264     }
5265   }
5266   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5267   public class StreamDeliver: RabbitMQ.Client.Impl.MethodBase, IStreamDeliver {
5268     public const int ClassId = 80;
5269     public const int MethodId = 60;
5270
5271     public string m_consumerTag;
5272     public ulong m_deliveryTag;
5273     public string m_exchange;
5274     public string m_queue;
5275
5276     string IStreamDeliver.ConsumerTag { get { return m_consumerTag; } }
5277     ulong IStreamDeliver.DeliveryTag { get { return m_deliveryTag; } }
5278     string IStreamDeliver.Exchange { get { return m_exchange; } }
5279     string IStreamDeliver.Queue { get { return m_queue; } }
5280
5281     public StreamDeliver() {}
5282     public StreamDeliver(
5283       string initConsumerTag,
5284       ulong initDeliveryTag,
5285       string initExchange,
5286       string initQueue)
5287     {
5288       m_consumerTag = initConsumerTag;
5289       m_deliveryTag = initDeliveryTag;
5290       m_exchange = initExchange;
5291       m_queue = initQueue;
5292     }
5293
5294     public override int ProtocolClassId { get { return 80; } }
5295     public override int ProtocolMethodId { get { return 60; } }
5296     public override string ProtocolMethodName { get { return "stream.deliver"; } }
5297     public override bool HasContent { get { return true; } }
5298
5299     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5300       m_consumerTag = reader.ReadShortstr();
5301       m_deliveryTag = reader.ReadLonglong();
5302       m_exchange = reader.ReadShortstr();
5303       m_queue = reader.ReadShortstr();
5304     }
5305
5306     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5307       writer.WriteShortstr(m_consumerTag);
5308       writer.WriteLonglong(m_deliveryTag);
5309       writer.WriteShortstr(m_exchange);
5310       writer.WriteShortstr(m_queue);
5311     }
5312
5313     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5314       sb.Append("(");
5315       sb.Append(m_consumerTag); sb.Append(",");
5316       sb.Append(m_deliveryTag); sb.Append(",");
5317       sb.Append(m_exchange); sb.Append(",");
5318       sb.Append(m_queue);
5319       sb.Append(")");
5320     }
5321   }
5322   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5323   public class TxSelect: RabbitMQ.Client.Impl.MethodBase, ITxSelect {
5324     public const int ClassId = 90;
5325     public const int MethodId = 10;
5326
5327
5328
5329     public TxSelect(
5330 )
5331     {
5332     }
5333
5334     public override int ProtocolClassId { get { return 90; } }
5335     public override int ProtocolMethodId { get { return 10; } }
5336     public override string ProtocolMethodName { get { return "tx.select"; } }
5337     public override bool HasContent { get { return false; } }
5338
5339     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5340     }
5341
5342     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5343     }
5344
5345     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5346       sb.Append("(");
5347       sb.Append(")");
5348     }
5349   }
5350   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5351   public class TxSelectOk: RabbitMQ.Client.Impl.MethodBase, ITxSelectOk {
5352     public const int ClassId = 90;
5353     public const int MethodId = 11;
5354
5355
5356
5357     public TxSelectOk(
5358 )
5359     {
5360     }
5361
5362     public override int ProtocolClassId { get { return 90; } }
5363     public override int ProtocolMethodId { get { return 11; } }
5364     public override string ProtocolMethodName { get { return "tx.select-ok"; } }
5365     public override bool HasContent { get { return false; } }
5366
5367     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5368     }
5369
5370     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5371     }
5372
5373     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5374       sb.Append("(");
5375       sb.Append(")");
5376     }
5377   }
5378   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5379   public class TxCommit: RabbitMQ.Client.Impl.MethodBase, ITxCommit {
5380     public const int ClassId = 90;
5381     public const int MethodId = 20;
5382
5383
5384
5385     public TxCommit(
5386 )
5387     {
5388     }
5389
5390     public override int ProtocolClassId { get { return 90; } }
5391     public override int ProtocolMethodId { get { return 20; } }
5392     public override string ProtocolMethodName { get { return "tx.commit"; } }
5393     public override bool HasContent { get { return false; } }
5394
5395     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5396     }
5397
5398     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5399     }
5400
5401     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5402       sb.Append("(");
5403       sb.Append(")");
5404     }
5405   }
5406   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5407   public class TxCommitOk: RabbitMQ.Client.Impl.MethodBase, ITxCommitOk {
5408     public const int ClassId = 90;
5409     public const int MethodId = 21;
5410
5411
5412
5413     public TxCommitOk(
5414 )
5415     {
5416     }
5417
5418     public override int ProtocolClassId { get { return 90; } }
5419     public override int ProtocolMethodId { get { return 21; } }
5420     public override string ProtocolMethodName { get { return "tx.commit-ok"; } }
5421     public override bool HasContent { get { return false; } }
5422
5423     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5424     }
5425
5426     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5427     }
5428
5429     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5430       sb.Append("(");
5431       sb.Append(")");
5432     }
5433   }
5434   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5435   public class TxRollback: RabbitMQ.Client.Impl.MethodBase, ITxRollback {
5436     public const int ClassId = 90;
5437     public const int MethodId = 30;
5438
5439
5440
5441     public TxRollback(
5442 )
5443     {
5444     }
5445
5446     public override int ProtocolClassId { get { return 90; } }
5447     public override int ProtocolMethodId { get { return 30; } }
5448     public override string ProtocolMethodName { get { return "tx.rollback"; } }
5449     public override bool HasContent { get { return false; } }
5450
5451     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5452     }
5453
5454     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5455     }
5456
5457     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5458       sb.Append("(");
5459       sb.Append(")");
5460     }
5461   }
5462   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5463   public class TxRollbackOk: RabbitMQ.Client.Impl.MethodBase, ITxRollbackOk {
5464     public const int ClassId = 90;
5465     public const int MethodId = 31;
5466
5467
5468
5469     public TxRollbackOk(
5470 )
5471     {
5472     }
5473
5474     public override int ProtocolClassId { get { return 90; } }
5475     public override int ProtocolMethodId { get { return 31; } }
5476     public override string ProtocolMethodName { get { return "tx.rollback-ok"; } }
5477     public override bool HasContent { get { return false; } }
5478
5479     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5480     }
5481
5482     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5483     }
5484
5485     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5486       sb.Append("(");
5487       sb.Append(")");
5488     }
5489   }
5490   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5491   public class DtxSelect: RabbitMQ.Client.Impl.MethodBase, IDtxSelect {
5492     public const int ClassId = 100;
5493     public const int MethodId = 10;
5494
5495
5496
5497     public DtxSelect(
5498 )
5499     {
5500     }
5501
5502     public override int ProtocolClassId { get { return 100; } }
5503     public override int ProtocolMethodId { get { return 10; } }
5504     public override string ProtocolMethodName { get { return "dtx.select"; } }
5505     public override bool HasContent { get { return false; } }
5506
5507     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5508     }
5509
5510     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5511     }
5512
5513     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5514       sb.Append("(");
5515       sb.Append(")");
5516     }
5517   }
5518   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5519   public class DtxSelectOk: RabbitMQ.Client.Impl.MethodBase, IDtxSelectOk {
5520     public const int ClassId = 100;
5521     public const int MethodId = 11;
5522
5523
5524
5525     public DtxSelectOk(
5526 )
5527     {
5528     }
5529
5530     public override int ProtocolClassId { get { return 100; } }
5531     public override int ProtocolMethodId { get { return 11; } }
5532     public override string ProtocolMethodName { get { return "dtx.select-ok"; } }
5533     public override bool HasContent { get { return false; } }
5534
5535     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5536     }
5537
5538     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5539     }
5540
5541     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5542       sb.Append("(");
5543       sb.Append(")");
5544     }
5545   }
5546   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5547   public class DtxStart: RabbitMQ.Client.Impl.MethodBase, IDtxStart {
5548     public const int ClassId = 100;
5549     public const int MethodId = 20;
5550
5551     public string m_dtxIdentifier;
5552
5553     string IDtxStart.DtxIdentifier { get { return m_dtxIdentifier; } }
5554
5555     public DtxStart() {}
5556     public DtxStart(
5557       string initDtxIdentifier)
5558     {
5559       m_dtxIdentifier = initDtxIdentifier;
5560     }
5561
5562     public override int ProtocolClassId { get { return 100; } }
5563     public override int ProtocolMethodId { get { return 20; } }
5564     public override string ProtocolMethodName { get { return "dtx.start"; } }
5565     public override bool HasContent { get { return false; } }
5566
5567     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5568       m_dtxIdentifier = reader.ReadShortstr();
5569     }
5570
5571     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5572       writer.WriteShortstr(m_dtxIdentifier);
5573     }
5574
5575     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5576       sb.Append("(");
5577       sb.Append(m_dtxIdentifier);
5578       sb.Append(")");
5579     }
5580   }
5581   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5582   public class DtxStartOk: RabbitMQ.Client.Impl.MethodBase, IDtxStartOk {
5583     public const int ClassId = 100;
5584     public const int MethodId = 21;
5585
5586
5587
5588     public DtxStartOk(
5589 )
5590     {
5591     }
5592
5593     public override int ProtocolClassId { get { return 100; } }
5594     public override int ProtocolMethodId { get { return 21; } }
5595     public override string ProtocolMethodName { get { return "dtx.start-ok"; } }
5596     public override bool HasContent { get { return false; } }
5597
5598     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5599     }
5600
5601     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5602     }
5603
5604     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5605       sb.Append("(");
5606       sb.Append(")");
5607     }
5608   }
5609   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5610   public class TunnelRequest: RabbitMQ.Client.Impl.MethodBase, ITunnelRequest {
5611     public const int ClassId = 110;
5612     public const int MethodId = 10;
5613
5614     public System.Collections.IDictionary m_metaData;
5615
5616     System.Collections.IDictionary ITunnelRequest.MetaData { get { return m_metaData; } }
5617
5618     public TunnelRequest() {}
5619     public TunnelRequest(
5620       System.Collections.IDictionary initMetaData)
5621     {
5622       m_metaData = initMetaData;
5623     }
5624
5625     public override int ProtocolClassId { get { return 110; } }
5626     public override int ProtocolMethodId { get { return 10; } }
5627     public override string ProtocolMethodName { get { return "tunnel.request"; } }
5628     public override bool HasContent { get { return true; } }
5629
5630     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5631       m_metaData = reader.ReadTable();
5632     }
5633
5634     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5635       writer.WriteTable(m_metaData);
5636     }
5637
5638     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5639       sb.Append("(");
5640       sb.Append(m_metaData);
5641       sb.Append(")");
5642     }
5643   }
5644   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5645   public class TestInteger: RabbitMQ.Client.Impl.MethodBase, ITestInteger {
5646     public const int ClassId = 120;
5647     public const int MethodId = 10;
5648
5649     public byte m_integer1;
5650     public ushort m_integer2;
5651     public uint m_integer3;
5652     public ulong m_integer4;
5653     public byte m_operation;
5654
5655     byte ITestInteger.Integer1 { get { return m_integer1; } }
5656     ushort ITestInteger.Integer2 { get { return m_integer2; } }
5657     uint ITestInteger.Integer3 { get { return m_integer3; } }
5658     ulong ITestInteger.Integer4 { get { return m_integer4; } }
5659     byte ITestInteger.Operation { get { return m_operation; } }
5660
5661     public TestInteger() {}
5662     public TestInteger(
5663       byte initInteger1,
5664       ushort initInteger2,
5665       uint initInteger3,
5666       ulong initInteger4,
5667       byte initOperation)
5668     {
5669       m_integer1 = initInteger1;
5670       m_integer2 = initInteger2;
5671       m_integer3 = initInteger3;
5672       m_integer4 = initInteger4;
5673       m_operation = initOperation;
5674     }
5675
5676     public override int ProtocolClassId { get { return 120; } }
5677     public override int ProtocolMethodId { get { return 10; } }
5678     public override string ProtocolMethodName { get { return "test.integer"; } }
5679     public override bool HasContent { get { return false; } }
5680
5681     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5682       m_integer1 = reader.ReadOctet();
5683       m_integer2 = reader.ReadShort();
5684       m_integer3 = reader.ReadLong();
5685       m_integer4 = reader.ReadLonglong();
5686       m_operation = reader.ReadOctet();
5687     }
5688
5689     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5690       writer.WriteOctet(m_integer1);
5691       writer.WriteShort(m_integer2);
5692       writer.WriteLong(m_integer3);
5693       writer.WriteLonglong(m_integer4);
5694       writer.WriteOctet(m_operation);
5695     }
5696
5697     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5698       sb.Append("(");
5699       sb.Append(m_integer1); sb.Append(",");
5700       sb.Append(m_integer2); sb.Append(",");
5701       sb.Append(m_integer3); sb.Append(",");
5702       sb.Append(m_integer4); sb.Append(",");
5703       sb.Append(m_operation);
5704       sb.Append(")");
5705     }
5706   }
5707   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5708   public class TestIntegerOk: RabbitMQ.Client.Impl.MethodBase, ITestIntegerOk {
5709     public const int ClassId = 120;
5710     public const int MethodId = 11;
5711
5712     public ulong m_result;
5713
5714     ulong ITestIntegerOk.Result { get { return m_result; } }
5715
5716     public TestIntegerOk() {}
5717     public TestIntegerOk(
5718       ulong initResult)
5719     {
5720       m_result = initResult;
5721     }
5722
5723     public override int ProtocolClassId { get { return 120; } }
5724     public override int ProtocolMethodId { get { return 11; } }
5725     public override string ProtocolMethodName { get { return "test.integer-ok"; } }
5726     public override bool HasContent { get { return false; } }
5727
5728     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5729       m_result = reader.ReadLonglong();
5730     }
5731
5732     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5733       writer.WriteLonglong(m_result);
5734     }
5735
5736     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5737       sb.Append("(");
5738       sb.Append(m_result);
5739       sb.Append(")");
5740     }
5741   }
5742   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5743   public class TestString: RabbitMQ.Client.Impl.MethodBase, ITestString {
5744     public const int ClassId = 120;
5745     public const int MethodId = 20;
5746
5747     public string m_string1;
5748     public byte[] m_string2;
5749     public byte m_operation;
5750
5751     string ITestString.String1 { get { return m_string1; } }
5752     byte[] ITestString.String2 { get { return m_string2; } }
5753     byte ITestString.Operation { get { return m_operation; } }
5754
5755     public TestString() {}
5756     public TestString(
5757       string initString1,
5758       byte[] initString2,
5759       byte initOperation)
5760     {
5761       m_string1 = initString1;
5762       m_string2 = initString2;
5763       m_operation = initOperation;
5764     }
5765
5766     public override int ProtocolClassId { get { return 120; } }
5767     public override int ProtocolMethodId { get { return 20; } }
5768     public override string ProtocolMethodName { get { return "test.string"; } }
5769     public override bool HasContent { get { return false; } }
5770
5771     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5772       m_string1 = reader.ReadShortstr();
5773       m_string2 = reader.ReadLongstr();
5774       m_operation = reader.ReadOctet();
5775     }
5776
5777     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5778       writer.WriteShortstr(m_string1);
5779       writer.WriteLongstr(m_string2);
5780       writer.WriteOctet(m_operation);
5781     }
5782
5783     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5784       sb.Append("(");
5785       sb.Append(m_string1); sb.Append(",");
5786       sb.Append(m_string2); sb.Append(",");
5787       sb.Append(m_operation);
5788       sb.Append(")");
5789     }
5790   }
5791   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5792   public class TestStringOk: RabbitMQ.Client.Impl.MethodBase, ITestStringOk {
5793     public const int ClassId = 120;
5794     public const int MethodId = 21;
5795
5796     public byte[] m_result;
5797
5798     byte[] ITestStringOk.Result { get { return m_result; } }
5799
5800     public TestStringOk() {}
5801     public TestStringOk(
5802       byte[] initResult)
5803     {
5804       m_result = initResult;
5805     }
5806
5807     public override int ProtocolClassId { get { return 120; } }
5808     public override int ProtocolMethodId { get { return 21; } }
5809     public override string ProtocolMethodName { get { return "test.string-ok"; } }
5810     public override bool HasContent { get { return false; } }
5811
5812     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5813       m_result = reader.ReadLongstr();
5814     }
5815
5816     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5817       writer.WriteLongstr(m_result);
5818     }
5819
5820     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5821       sb.Append("(");
5822       sb.Append(m_result);
5823       sb.Append(")");
5824     }
5825   }
5826   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5827   public class TestTable: RabbitMQ.Client.Impl.MethodBase, ITestTable {
5828     public const int ClassId = 120;
5829     public const int MethodId = 30;
5830
5831     public System.Collections.IDictionary m_table;
5832     public byte m_integerOp;
5833     public byte m_stringOp;
5834
5835     System.Collections.IDictionary ITestTable.Table { get { return m_table; } }
5836     byte ITestTable.IntegerOp { get { return m_integerOp; } }
5837     byte ITestTable.StringOp { get { return m_stringOp; } }
5838
5839     public TestTable() {}
5840     public TestTable(
5841       System.Collections.IDictionary initTable,
5842       byte initIntegerOp,
5843       byte initStringOp)
5844     {
5845       m_table = initTable;
5846       m_integerOp = initIntegerOp;
5847       m_stringOp = initStringOp;
5848     }
5849
5850     public override int ProtocolClassId { get { return 120; } }
5851     public override int ProtocolMethodId { get { return 30; } }
5852     public override string ProtocolMethodName { get { return "test.table"; } }
5853     public override bool HasContent { get { return false; } }
5854
5855     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5856       m_table = reader.ReadTable();
5857       m_integerOp = reader.ReadOctet();
5858       m_stringOp = reader.ReadOctet();
5859     }
5860
5861     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5862       writer.WriteTable(m_table);
5863       writer.WriteOctet(m_integerOp);
5864       writer.WriteOctet(m_stringOp);
5865     }
5866
5867     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5868       sb.Append("(");
5869       sb.Append(m_table); sb.Append(",");
5870       sb.Append(m_integerOp); sb.Append(",");
5871       sb.Append(m_stringOp);
5872       sb.Append(")");
5873     }
5874   }
5875   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5876   public class TestTableOk: RabbitMQ.Client.Impl.MethodBase, ITestTableOk {
5877     public const int ClassId = 120;
5878     public const int MethodId = 31;
5879
5880     public ulong m_integerResult;
5881     public byte[] m_stringResult;
5882
5883     ulong ITestTableOk.IntegerResult { get { return m_integerResult; } }
5884     byte[] ITestTableOk.StringResult { get { return m_stringResult; } }
5885
5886     public TestTableOk() {}
5887     public TestTableOk(
5888       ulong initIntegerResult,
5889       byte[] initStringResult)
5890     {
5891       m_integerResult = initIntegerResult;
5892       m_stringResult = initStringResult;
5893     }
5894
5895     public override int ProtocolClassId { get { return 120; } }
5896     public override int ProtocolMethodId { get { return 31; } }
5897     public override string ProtocolMethodName { get { return "test.table-ok"; } }
5898     public override bool HasContent { get { return false; } }
5899
5900     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5901       m_integerResult = reader.ReadLonglong();
5902       m_stringResult = reader.ReadLongstr();
5903     }
5904
5905     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5906       writer.WriteLonglong(m_integerResult);
5907       writer.WriteLongstr(m_stringResult);
5908     }
5909
5910     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5911       sb.Append("(");
5912       sb.Append(m_integerResult); sb.Append(",");
5913       sb.Append(m_stringResult);
5914       sb.Append(")");
5915     }
5916   }
5917   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5918   public class TestContent: RabbitMQ.Client.Impl.MethodBase, ITestContent {
5919     public const int ClassId = 120;
5920     public const int MethodId = 40;
5921
5922
5923
5924     public TestContent(
5925 )
5926     {
5927     }
5928
5929     public override int ProtocolClassId { get { return 120; } }
5930     public override int ProtocolMethodId { get { return 40; } }
5931     public override string ProtocolMethodName { get { return "test.content"; } }
5932     public override bool HasContent { get { return true; } }
5933
5934     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5935     }
5936
5937     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5938     }
5939
5940     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5941       sb.Append("(");
5942       sb.Append(")");
5943     }
5944   }
5945   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5946   public class TestContentOk: RabbitMQ.Client.Impl.MethodBase, ITestContentOk {
5947     public const int ClassId = 120;
5948     public const int MethodId = 41;
5949
5950     public uint m_contentChecksum;
5951
5952     uint ITestContentOk.ContentChecksum { get { return m_contentChecksum; } }
5953
5954     public TestContentOk() {}
5955     public TestContentOk(
5956       uint initContentChecksum)
5957     {
5958       m_contentChecksum = initContentChecksum;
5959     }
5960
5961     public override int ProtocolClassId { get { return 120; } }
5962     public override int ProtocolMethodId { get { return 41; } }
5963     public override string ProtocolMethodName { get { return "test.content-ok"; } }
5964     public override bool HasContent { get { return true; } }
5965
5966     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5967       m_contentChecksum = reader.ReadLong();
5968     }
5969
5970     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5971       writer.WriteLong(m_contentChecksum);
5972     }
5973
5974     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5975       sb.Append("(");
5976       sb.Append(m_contentChecksum);
5977       sb.Append(")");
5978     }
5979   }
5980
5981   public class Model: RabbitMQ.Client.Impl.ModelBase {
5982     public Model(RabbitMQ.Client.Impl.ISession session): base(session) {}
5983     public override void _Private_BasicPublish(
5984       System.String @exchange,
5985       System.String @routingKey,
5986       System.Boolean @mandatory,
5987       System.Boolean @immediate,
5988       RabbitMQ.Client.IBasicProperties @basicProperties,
5989       System.Byte[] @body)
5990     {
5991       BasicPublish __req = new BasicPublish();
5992       __req.m_exchange = @exchange;
5993       __req.m_routingKey = @routingKey;
5994       __req.m_mandatory = @mandatory;
5995       __req.m_immediate = @immediate;
5996       ModelSend(__req, (BasicProperties) basicProperties,body);
5997     }
5998     public override void _Private_BasicConsume(
5999       System.String @queue,
6000       System.String @consumerTag,
6001       System.Boolean @noLocal,
6002       System.Boolean @noAck,
6003       System.Boolean @exclusive,
6004       System.Boolean @nowait,
6005       System.Collections.IDictionary @filter)
6006     {
6007       BasicConsume __req = new BasicConsume();
6008       __req.m_queue = @queue;
6009       __req.m_consumerTag = @consumerTag;
6010       __req.m_noLocal = @noLocal;
6011       __req.m_noAck = @noAck;
6012       __req.m_exclusive = @exclusive;
6013       __req.m_nowait = @nowait;
6014       __req.m_arguments = @filter;
6015       ModelSend(__req,null,null);
6016     }
6017     public override void _Private_BasicCancel(
6018       System.String @consumerTag,
6019       System.Boolean @nowait)
6020     {
6021       BasicCancel __req = new BasicCancel();
6022       __req.m_consumerTag = @consumerTag;
6023       __req.m_nowait = @nowait;
6024       ModelSend(__req,null,null);
6025     }
6026     public override void _Private_ChannelOpen(
6027       System.String @outOfBand)
6028     {
6029       ChannelOpen __req = new ChannelOpen();
6030       __req.m_outOfBand = @outOfBand;
6031       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6032       ChannelOpenOk __rep = __repBase as ChannelOpenOk;
6033       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6034     }
6035     public override void _Private_ChannelCloseOk()
6036     {
6037       ChannelCloseOk __req = new ChannelCloseOk();
6038       ModelSend(__req,null,null);
6039     }
6040     public override void _Private_ChannelClose(
6041       System.UInt16 @replyCode,
6042       System.String @replyText,
6043       System.UInt16 @classId,
6044       System.UInt16 @methodId)
6045     {
6046       ChannelClose __req = new ChannelClose();
6047       __req.m_replyCode = @replyCode;
6048       __req.m_replyText = @replyText;
6049       __req.m_classId = @classId;
6050       __req.m_methodId = @methodId;
6051       ModelSend(__req,null,null);
6052     }
6053     public override void _Private_BasicGet(
6054       System.String @queue,
6055       System.Boolean @noAck)
6056     {
6057       BasicGet __req = new BasicGet();
6058       __req.m_queue = @queue;
6059       __req.m_noAck = @noAck;
6060       ModelSend(__req,null,null);
6061     }
6062     public override void _Private_ChannelFlowOk()
6063     {
6064       ChannelFlowOk __req = new ChannelFlowOk();
6065       ModelSend(__req,null,null);
6066     }
6067     public override RabbitMQ.Client.Impl.ConnectionTuneDetails ConnectionStartOk(
6068       System.Collections.IDictionary @clientProperties,
6069       System.String @mechanism,
6070       System.Byte[] @response,
6071       System.String @locale)
6072     {
6073       ConnectionStartOk __req = new ConnectionStartOk();
6074       __req.m_clientProperties = @clientProperties;
6075       __req.m_mechanism = @mechanism;
6076       __req.m_response = @response;
6077       __req.m_locale = @locale;
6078       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6079       ConnectionTune __rep = __repBase as ConnectionTune;
6080       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6081       RabbitMQ.Client.Impl.ConnectionTuneDetails __result = new RabbitMQ.Client.Impl.ConnectionTuneDetails();
6082       __result.m_channelMax = __rep.m_channelMax;
6083       __result.m_frameMax = __rep.m_frameMax;
6084       __result.m_heartbeat = __rep.m_heartbeat;
6085       return __result;
6086     }
6087     public override void ConnectionTuneOk(
6088       System.UInt16 @channelMax,
6089       System.UInt32 @frameMax,
6090       System.UInt16 @heartbeat)
6091     {
6092       ConnectionTuneOk __req = new ConnectionTuneOk();
6093       __req.m_channelMax = @channelMax;
6094       __req.m_frameMax = @frameMax;
6095       __req.m_heartbeat = @heartbeat;
6096       ModelSend(__req,null,null);
6097     }
6098     public override void _Private_ConnectionOpen(
6099       System.String @virtualHost,
6100       System.String @capabilities,
6101       System.Boolean @insist)
6102     {
6103       ConnectionOpen __req = new ConnectionOpen();
6104       __req.m_virtualHost = @virtualHost;
6105       __req.m_capabilities = @capabilities;
6106       __req.m_insist = @insist;
6107       ModelSend(__req,null,null);
6108     }
6109     public override void _Private_ConnectionClose(
6110       System.UInt16 @replyCode,
6111       System.String @replyText,
6112       System.UInt16 @classId,
6113       System.UInt16 @methodId)
6114     {
6115       ConnectionClose __req = new ConnectionClose();
6116       __req.m_replyCode = @replyCode;
6117       __req.m_replyText = @replyText;
6118       __req.m_classId = @classId;
6119       __req.m_methodId = @methodId;
6120       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6121       ConnectionCloseOk __rep = __repBase as ConnectionCloseOk;
6122       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6123     }
6124     public override void _Private_ConnectionCloseOk()
6125     {
6126       ConnectionCloseOk __req = new ConnectionCloseOk();
6127       ModelSend(__req,null,null);
6128     }
6129     public override RabbitMQ.Client.IBasicProperties CreateBasicProperties()
6130     {
6131       return new BasicProperties();
6132     }
6133     public override RabbitMQ.Client.IFileProperties CreateFileProperties()
6134     {
6135       return new FileProperties();
6136     }
6137     public override RabbitMQ.Client.IStreamProperties CreateStreamProperties()
6138     {
6139       return new StreamProperties();
6140     }
6141     public override void ChannelFlow(
6142       System.Boolean @active)
6143     {
6144       ChannelFlow __req = new ChannelFlow();
6145       __req.m_active = @active;
6146       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6147       ChannelFlowOk __rep = __repBase as ChannelFlowOk;
6148       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6149     }
6150     public override void ExchangeDeclare(
6151       System.String @exchange,
6152       System.String @type,
6153       System.Boolean @passive,
6154       System.Boolean @durable,
6155       System.Boolean @autoDelete,
6156       System.Boolean @internal,
6157       System.Boolean @nowait,
6158       System.Collections.IDictionary @arguments)
6159     {
6160       ExchangeDeclare __req = new ExchangeDeclare();
6161       __req.m_exchange = @exchange;
6162       __req.m_type = @type;
6163       __req.m_passive = @passive;
6164       __req.m_durable = @durable;
6165       __req.m_autoDelete = @autoDelete;
6166       __req.m_internal = @internal;
6167       __req.m_nowait = @nowait;
6168       __req.m_arguments = @arguments;
6169       if (nowait) {
6170         ModelSend(__req,null,null);
6171       }
6172       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6173       ExchangeDeclareOk __rep = __repBase as ExchangeDeclareOk;
6174       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6175     }
6176     public override void ExchangeDelete(
6177       System.String @exchange,
6178       System.Boolean @ifUnused,
6179       System.Boolean @nowait)
6180     {
6181       ExchangeDelete __req = new ExchangeDelete();
6182       __req.m_exchange = @exchange;
6183       __req.m_ifUnused = @ifUnused;
6184       __req.m_nowait = @nowait;
6185       if (nowait) {
6186         ModelSend(__req,null,null);
6187       }
6188       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6189       ExchangeDeleteOk __rep = __repBase as ExchangeDeleteOk;
6190       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6191     }
6192     public override System.String QueueDeclare(
6193       System.String @queue,
6194       System.Boolean @passive,
6195       System.Boolean @durable,
6196       System.Boolean @exclusive,
6197       System.Boolean @autoDelete,
6198       System.Boolean @nowait,
6199       System.Collections.IDictionary @arguments)
6200     {
6201       QueueDeclare __req = new QueueDeclare();
6202       __req.m_queue = @queue;
6203       __req.m_passive = @passive;
6204       __req.m_durable = @durable;
6205       __req.m_exclusive = @exclusive;
6206       __req.m_autoDelete = @autoDelete;
6207       __req.m_nowait = @nowait;
6208       __req.m_arguments = @arguments;
6209       if (nowait) {
6210         ModelSend(__req,null,null);
6211         return null;
6212       }
6213       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6214       QueueDeclareOk __rep = __repBase as QueueDeclareOk;
6215       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6216       return __rep.m_queue;
6217     }
6218     public override void QueueBind(
6219       System.String @queue,
6220       System.String @exchange,
6221       System.String @routingKey,
6222       System.Boolean @nowait,
6223       System.Collections.IDictionary @arguments)
6224     {
6225       QueueBind __req = new QueueBind();
6226       __req.m_queue = @queue;
6227       __req.m_exchange = @exchange;
6228       __req.m_routingKey = @routingKey;
6229       __req.m_nowait = @nowait;
6230       __req.m_arguments = @arguments;
6231       if (nowait) {
6232         ModelSend(__req,null,null);
6233       }
6234       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6235       QueueBindOk __rep = __repBase as QueueBindOk;
6236       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6237     }
6238     public override void QueueUnbind(
6239       System.String @queue,
6240       System.String @exchange,
6241       System.String @routingKey,
6242       System.Collections.IDictionary @arguments)
6243     {
6244       throw new UnsupportedMethodException("QueueUnbind");
6245     }
6246     public override System.UInt32 QueuePurge(
6247       System.String @queue,
6248       System.Boolean @nowait)
6249     {
6250       QueuePurge __req = new QueuePurge();
6251       __req.m_queue = @queue;
6252       __req.m_nowait = @nowait;
6253       if (nowait) {
6254         ModelSend(__req,null,null);
6255         return 0xFFFFFFFF;
6256       }
6257       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6258       QueuePurgeOk __rep = __repBase as QueuePurgeOk;
6259       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6260       return __rep.m_messageCount;
6261     }
6262     public override System.UInt32 QueueDelete(
6263       System.String @queue,
6264       System.Boolean @ifUnused,
6265       System.Boolean @ifEmpty,
6266       System.Boolean @nowait)
6267     {
6268       QueueDelete __req = new QueueDelete();
6269       __req.m_queue = @queue;
6270       __req.m_ifUnused = @ifUnused;
6271       __req.m_ifEmpty = @ifEmpty;
6272       __req.m_nowait = @nowait;
6273       if (nowait) {
6274         ModelSend(__req,null,null);
6275         return 0xFFFFFFFF;
6276       }
6277       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6278       QueueDeleteOk __rep = __repBase as QueueDeleteOk;
6279       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6280       return __rep.m_messageCount;
6281     }
6282     public override void BasicQos(
6283       System.UInt32 @prefetchSize,
6284       System.UInt16 @prefetchCount,
6285       System.Boolean @global)
6286     {
6287       BasicQos __req = new BasicQos();
6288       __req.m_prefetchSize = @prefetchSize;
6289       __req.m_prefetchCount = @prefetchCount;
6290       __req.m_global = @global;
6291       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6292       BasicQosOk __rep = __repBase as BasicQosOk;
6293       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6294     }
6295     public override void BasicAck(
6296       System.UInt64 @deliveryTag,
6297       System.Boolean @multiple)
6298     {
6299       BasicAck __req = new BasicAck();
6300       __req.m_deliveryTag = @deliveryTag;
6301       __req.m_multiple = @multiple;
6302       ModelSend(__req,null,null);
6303     }
6304     public override void BasicReject(
6305       System.UInt64 @deliveryTag,
6306       System.Boolean @requeue)
6307     {
6308       BasicReject __req = new BasicReject();
6309       __req.m_deliveryTag = @deliveryTag;
6310       __req.m_requeue = @requeue;
6311       ModelSend(__req,null,null);
6312     }
6313     public override void BasicRecover(
6314       System.Boolean @requeue)
6315     {
6316       BasicRecover __req = new BasicRecover();
6317       __req.m_requeue = @requeue;
6318       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6319       BasicRecoverOk __rep = __repBase as BasicRecoverOk;
6320       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6321     }
6322     public override void TxSelect()
6323     {
6324       TxSelect __req = new TxSelect();
6325       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6326       TxSelectOk __rep = __repBase as TxSelectOk;
6327       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6328     }
6329     public override void TxCommit()
6330     {
6331       TxCommit __req = new TxCommit();
6332       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6333       TxCommitOk __rep = __repBase as TxCommitOk;
6334       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6335     }
6336     public override void TxRollback()
6337     {
6338       TxRollback __req = new TxRollback();
6339       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6340       TxRollbackOk __rep = __repBase as TxRollbackOk;
6341       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6342     }
6343     public override void DtxSelect()
6344     {
6345       DtxSelect __req = new DtxSelect();
6346       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6347       DtxSelectOk __rep = __repBase as DtxSelectOk;
6348       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6349     }
6350     public override void DtxStart(
6351       System.String @dtxIdentifier)
6352     {
6353       DtxStart __req = new DtxStart();
6354       __req.m_dtxIdentifier = @dtxIdentifier;
6355       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
6356       DtxStartOk __rep = __repBase as DtxStartOk;
6357       if (__rep == null) throw new UnexpectedMethodException(__repBase);
6358     }
6359     public override bool DispatchAsynchronous(RabbitMQ.Client.Impl.Command cmd) {
6360       RabbitMQ.Client.Impl.MethodBase __method = (RabbitMQ.Client.Impl.MethodBase) cmd.Method;
6361       switch ((__method.ProtocolClassId << 16) | __method.ProtocolMethodId) {
6362         case 3932181: {
6363           BasicConsumeOk __impl = (BasicConsumeOk) __method;
6364           HandleBasicConsumeOk(
6365             __impl.m_consumerTag);
6366           return true;
6367         }
6368         case 3932191: {
6369           BasicCancelOk __impl = (BasicCancelOk) __method;
6370           HandleBasicCancelOk(
6371             __impl.m_consumerTag);
6372           return true;
6373         }
6374         case 3932231: {
6375           BasicGetOk __impl = (BasicGetOk) __method;
6376           HandleBasicGetOk(
6377             __impl.m_deliveryTag,
6378             __impl.m_redelivered,
6379             __impl.m_exchange,
6380             __impl.m_routingKey,
6381             __impl.m_messageCount,
6382             (RabbitMQ.Client.IBasicProperties) cmd.Header,
6383             cmd.Body);
6384           return true;
6385         }
6386         case 3932232: {
6387           HandleBasicGetEmpty();
6388           return true;
6389         }
6390         case 3932220: {
6391           BasicDeliver __impl = (BasicDeliver) __method;
6392           HandleBasicDeliver(
6393             __impl.m_consumerTag,
6394             __impl.m_deliveryTag,
6395             __impl.m_redelivered,
6396             __impl.m_exchange,
6397             __impl.m_routingKey,
6398             (RabbitMQ.Client.IBasicProperties) cmd.Header,
6399             cmd.Body);
6400           return true;
6401         }
6402         case 3932210: {
6403           BasicReturn __impl = (BasicReturn) __method;
6404           HandleBasicReturn(
6405             __impl.m_replyCode,
6406             __impl.m_replyText,
6407             __impl.m_exchange,
6408             __impl.m_routingKey,
6409             (RabbitMQ.Client.IBasicProperties) cmd.Header,
6410             cmd.Body);
6411           return true;
6412         }
6413         case 1310740: {
6414           ChannelFlow __impl = (ChannelFlow) __method;
6415           HandleChannelFlow(
6416             __impl.m_active);
6417           return true;
6418         }
6419         case 1310760: {
6420           ChannelClose __impl = (ChannelClose) __method;
6421           HandleChannelClose(
6422             __impl.m_replyCode,
6423             __impl.m_replyText,
6424             __impl.m_classId,
6425             __impl.m_methodId);
6426           return true;
6427         }
6428         case 1310761: {
6429           HandleChannelCloseOk();
6430           return true;
6431         }
6432         case 655370: {
6433           ConnectionStart __impl = (ConnectionStart) __method;
6434           HandleConnectionStart(
6435             __impl.m_versionMajor,
6436             __impl.m_versionMinor,
6437             __impl.m_serverProperties,
6438             __impl.m_mechanisms,
6439             __impl.m_locales);
6440           return true;
6441         }
6442         case 655401: {
6443           ConnectionOpenOk __impl = (ConnectionOpenOk) __method;
6444           HandleConnectionOpenOk(
6445             __impl.m_knownHosts);
6446           return true;
6447         }
6448         case 655410: {
6449           ConnectionRedirect __impl = (ConnectionRedirect) __method;
6450           HandleConnectionRedirect(
6451             __impl.m_host,
6452             __impl.m_knownHosts);
6453           return true;
6454         }
6455         case 655420: {
6456           ConnectionClose __impl = (ConnectionClose) __method;
6457           HandleConnectionClose(
6458             __impl.m_replyCode,
6459             __impl.m_replyText,
6460             __impl.m_classId,
6461             __impl.m_methodId);
6462           return true;
6463         }
6464         default: return false;
6465       }
6466     }
6467   }
6468 }