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