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