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

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