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   /// <remarks>
 624   ///
 625   ///     This method starts the connection negotiation process by telling
 626   ///     the client the protocol version that the server proposes, along
 627   ///     with a list of security mechanisms which the client can use for
 628   ///     authentication.
 629   ///
 630   /// </remarks>
 631   public interface IConnectionStart: IMethod {
 632     /// <summary>
 633     ///
 634     ///       The protocol major version that the server agrees to use, which
 635     ///       cannot be higher than the client's major version.
 636     ///
 637     /// </summary>
 638     byte VersionMajor { get; }
 639     /// <summary>
 640     ///
 641     ///       The protocol minor version that the server agrees to use, which
 642     ///       cannot be higher than the client's minor version.
 643     ///
 644     /// </summary>
 645     byte VersionMinor { get; }
 646     // (no documentation)
 647     System.Collections.IDictionary ServerProperties { get; }
 648     /// <summary>
 649     ///
 650     ///       A list of the security mechanisms that the server supports, delimited
 651     ///       by spaces.  Currently ASL supports these mechanisms: PLAIN.
 652     ///
 653     /// </summary>
 654     byte[] Mechanisms { get; }
 655     /// <summary>
 656     ///
 657     ///       A list of the message locales that the server supports, delimited
 658     ///       by spaces.  The locale defines the language in which the server
 659     ///       will send reply texts.
 660     ///
 661     /// </summary>
 662     byte[] Locales { get; }
 663   }
 664   /// <summary>Autogenerated type. AMQP specification method "connection.start-ok".</summary>
 665   /// <remarks>
 666   ///
 667   ///     This method selects a SASL security mechanism. ASL uses SASL
 668   ///     (RFC2222) to negotiate authentication and encryption.
 669   ///
 670   /// </remarks>
 671   public interface IConnectionStartOk: IMethod {
 672     // (no documentation)
 673     System.Collections.IDictionary ClientProperties { get; }
 674     /// <summary>
 675     ///
 676     ///       A single security mechanisms selected by the client, which must be
 677     ///       one of those specified by the server.
 678     ///
 679     /// </summary>
 680     string Mechanism { get; }
 681     /// <summary>
 682     ///
 683     ///       A block of opaque data passed to the security mechanism. The contents
 684     ///       of this data are defined by the SASL security mechanism.  For the
 685     ///       PLAIN security mechanism this is defined as a field table holding
 686     ///       two fields, LOGIN and PASSWORD.
 687     ///
 688     /// </summary>
 689     byte[] Response { get; }
 690     /// <summary>
 691     ///
 692     ///       A single message local selected by the client, which must be one
 693     ///       of those specified by the server.
 694     ///
 695     /// </summary>
 696     string Locale { get; }
 697   }
 698   /// <summary>Autogenerated type. AMQP specification method "connection.secure".</summary>
 699   /// <remarks>
 700   ///
 701   ///     The SASL protocol works by exchanging challenges and responses until
 702   ///     both peers have received sufficient information to authenticate each
 703   ///     other.  This method challenges the client to provide more information.
 704   ///
 705   /// </remarks>
 706   public interface IConnectionSecure: IMethod {
 707     /// <summary>
 708     ///
 709     ///       Challenge information, a block of opaque binary data passed to
 710     ///       the security mechanism.
 711     ///
 712     /// </summary>
 713     byte[] Challenge { get; }
 714   }
 715   /// <summary>Autogenerated type. AMQP specification method "connection.secure-ok".</summary>
 716   /// <remarks>
 717   ///
 718   ///     This method attempts to authenticate, passing a block of SASL data
 719   ///     for the security mechanism at the server side.
 720   ///
 721   /// </remarks>
 722   public interface IConnectionSecureOk: IMethod {
 723     /// <summary>
 724     ///
 725     ///       A block of opaque data passed to the security mechanism.  The contents
 726     ///       of this data are defined by the SASL security mechanism.
 727     ///
 728     /// </summary>
 729     byte[] Response { get; }
 730   }
 731   /// <summary>Autogenerated type. AMQP specification method "connection.tune".</summary>
 732   /// <remarks>
 733   ///
 734   ///     This method proposes a set of connection configuration values
 735   ///     to the client.  The client can accept and/or adjust these.
 736   ///
 737   /// </remarks>
 738   public interface IConnectionTune: IMethod {
 739     /// <summary>
 740     ///
 741     ///       The maximum total number of channels that the server allows
 742     ///       per connection. Zero means that the server does not impose a
 743     ///       fixed limit, but the number of allowed channels may be limited
 744     ///       by available server resources.
 745     ///
 746     /// </summary>
 747     ushort ChannelMax { get; }
 748     /// <summary>
 749     ///
 750     ///       The largest frame size that the server proposes for the
 751     ///       connection. The client can negotiate a lower value.  Zero means
 752     ///       that the server does not impose any specific limit but may reject
 753     ///       very large frames if it cannot allocate resources for them.
 754     ///
 755     /// </summary>
 756     uint FrameMax { get; }
 757     /// <summary>
 758     ///
 759     ///       The delay, in seconds, of the connection heartbeat that the server
 760     ///       wants.  Zero means the server does not want a heartbeat.
 761     ///
 762     /// </summary>
 763     ushort Heartbeat { get; }
 764   }
 765   /// <summary>Autogenerated type. AMQP specification method "connection.tune-ok".</summary>
 766   /// <remarks>
 767   ///
 768   ///     This method sends the client's connection tuning parameters to the
 769   ///     server. Certain fields are negotiated, others provide capability
 770   ///     information.
 771   ///
 772   /// </remarks>
 773   public interface IConnectionTuneOk: IMethod {
 774     /// <summary>
 775     ///
 776     ///       The maximum total number of channels that the client will use
 777     ///       per connection.  May not be higher than the value specified by
 778     ///       the server.
 779     ///
 780     /// </summary>
 781     ushort ChannelMax { get; }
 782     /// <summary>
 783     ///
 784     ///       The largest frame size that the client and server will use for
 785     ///       the connection.  Zero means that the client does not impose any
 786     ///       specific limit but may reject very large frames if it cannot
 787     ///       allocate resources for them.  Note that the frame-max limit
 788     ///       applies principally to content frames, where large contents
 789     ///       can be broken into frames of arbitrary size.
 790     ///
 791     /// </summary>
 792     uint FrameMax { get; }
 793     /// <summary>
 794     ///
 795     ///       The delay, in seconds, of the connection heartbeat that the client
 796     ///       wants. Zero means the client does not want a heartbeat.
 797     ///
 798     /// </summary>
 799     ushort Heartbeat { get; }
 800   }
 801   /// <summary>Autogenerated type. AMQP specification method "connection.open".</summary>
 802   /// <remarks>
 803   ///
 804   ///     This method opens a connection to a virtual host, which is a
 805   ///     collection of resources, and acts to separate multiple application
 806   ///     domains within a server.
 807   ///
 808   /// </remarks>
 809   public interface IConnectionOpen: IMethod {
 810     /// <summary>
 811     ///
 812     ///       The name of the virtual host to work with.
 813     ///
 814     /// </summary>
 815     string VirtualHost { get; }
 816     /// <summary>
 817     ///
 818     ///       The client may specify a number of capability names, delimited by
 819     ///       spaces.  The server can use this string to how to process the
 820     ///       client's connection request.
 821     ///
 822     /// </summary>
 823     string Capabilities { get; }
 824     /// <summary>
 825     ///
 826     ///       In a configuration with multiple load-sharing servers, the server
 827     ///       may respond to a Connection.Open method with a Connection.Redirect.
 828     ///       The insist option tells the server that the client is insisting on
 829     ///       a connection to the specified server.
 830     ///
 831     /// </summary>
 832     bool Insist { get; }
 833   }
 834   /// <summary>Autogenerated type. AMQP specification method "connection.open-ok".</summary>
 835   /// <remarks>
 836   ///
 837   ///     This method signals to the client that the connection is ready for
 838   ///     use.
 839   ///
 840   /// </remarks>
 841   public interface IConnectionOpenOk: IMethod {
 842     // (no documentation)
 843     string KnownHosts { get; }
 844   }
 845   /// <summary>Autogenerated type. AMQP specification method "connection.redirect".</summary>
 846   /// <remarks>
 847   ///
 848   ///     This method redirects the client to another server, based on the
 849   ///     requested virtual host and/or capabilities.
 850   ///
 851   /// </remarks>
 852   public interface IConnectionRedirect: IMethod {
 853     /// <summary>
 854     ///
 855     ///       Specifies the server to connect to.  This is an IP address or a
 856     ///       DNS name, optionally followed by a colon and a port number. If
 857     ///       no port number is specified, the client should use the default
 858     ///       port number for the protocol.
 859     ///
 860     /// </summary>
 861     string Host { get; }
 862     // (no documentation)
 863     string KnownHosts { get; }
 864   }
 865   /// <summary>Autogenerated type. AMQP specification method "connection.close".</summary>
 866   /// <remarks>
 867   ///
 868   ///     This method indicates that the sender wants to close the connection.
 869   ///     This may be due to internal conditions (e.g. a forced shut-down) or
 870   ///     due to an error handling a specific method, i.e. an exception.  When
 871   ///     a close is due to an exception, the sender provides the class and
 872   ///     method id of the method which caused the exception.
 873   ///
 874   /// </remarks>
 875   public interface IConnectionClose: IMethod {
 876     // (no documentation)
 877     ushort ReplyCode { get; }
 878     // (no documentation)
 879     string ReplyText { get; }
 880     /// <summary>
 881     ///
 882     ///       When the close is provoked by a method exception, this is the
 883     ///       class of the method.
 884     ///
 885     /// </summary>
 886     ushort ClassId { get; }
 887     /// <summary>
 888     ///
 889     ///       When the close is provoked by a method exception, this is the
 890     ///       ID of the method.
 891     ///
 892     /// </summary>
 893     ushort MethodId { get; }
 894   }
 895   /// <summary>Autogenerated type. AMQP specification method "connection.close-ok".</summary>
 896   /// <remarks>
 897   ///
 898   ///     This method confirms a Connection.Close method and tells the
 899   ///     recipient that it is safe to release resources for the connection
 900   ///     and close the socket.
 901   ///
 902   /// </remarks>
 903   public interface IConnectionCloseOk: IMethod {
 904   }
 905   /// <summary>Autogenerated type. AMQP specification method "channel.open".</summary>
 906   /// <remarks>
 907   ///
 908   ///     This method opens a virtual connection (a channel).
 909   ///
 910   /// </remarks>
 911   public interface IChannelOpen: IMethod {
 912     /// <summary>
 913     ///
 914     ///       Configures out-of-band transfers on this channel.  The syntax and
 915     ///       meaning of this field will be formally defined at a later date.
 916     ///
 917     /// </summary>
 918     string OutOfBand { get; }
 919   }
 920   /// <summary>Autogenerated type. AMQP specification method "channel.open-ok".</summary>
 921   /// <remarks>
 922   ///
 923   ///     This method signals to the client that the channel is ready for use.
 924   ///
 925   /// </remarks>
 926   public interface IChannelOpenOk: IMethod {
 927   }
 928   /// <summary>Autogenerated type. AMQP specification method "channel.flow".</summary>
 929   /// <remarks>
 930   ///
 931   ///     This method asks the peer to pause or restart the flow of content
 932   ///     data. This is a simple flow-control mechanism that a peer can use
 933   ///     to avoid oveflowing its queues or otherwise finding itself receiving
 934   ///     more messages than it can process.  Note that this method is not
 935   ///     intended for window control.  The peer that receives a request to
 936   ///     stop sending content should finish sending the current content, if
 937   ///     any, and then wait until it receives a Flow restart method.
 938   ///
 939   /// </remarks>
 940   public interface IChannelFlow: IMethod {
 941     /// <summary>
 942     ///
 943     ///       If 1, the peer starts sending content frames.  If 0, the peer
 944     ///       stops sending content frames.
 945     ///
 946     /// </summary>
 947     bool Active { get; }
 948   }
 949   /// <summary>Autogenerated type. AMQP specification method "channel.flow-ok".</summary>
 950   /// <remarks>
 951   ///
 952   ///     Confirms to the peer that a flow command was received and processed.
 953   ///
 954   /// </remarks>
 955   public interface IChannelFlowOk: IMethod {
 956     /// <summary>
 957     ///
 958     ///       Confirms the setting of the processed flow method: 1 means the
 959     ///       peer will start sending or continue to send content frames; 0
 960     ///       means it will not.
 961     ///
 962     /// </summary>
 963     bool Active { get; }
 964   }
 965   /// <summary>Autogenerated type. AMQP specification method "channel.alert".</summary>
 966   /// <remarks>
 967   ///
 968   ///     This method allows the server to send a non-fatal warning to the
 969   ///     client.  This is used for methods that are normally asynchronous
 970   ///     and thus do not have confirmations, and for which the server may
 971   ///     detect errors that need to be reported.  Fatal errors are handled
 972   ///     as channel or connection exceptions; non-fatal errors are sent
 973   ///     through this method.
 974   ///
 975   /// </remarks>
 976   public interface IChannelAlert: IMethod {
 977     // (no documentation)
 978     ushort ReplyCode { get; }
 979     // (no documentation)
 980     string ReplyText { get; }
 981     /// <summary>
 982     ///
 983     ///       A set of fields that provide more information about the
 984     ///       problem.  The meaning of these fields are defined on a
 985     ///       per-reply-code basis (TO BE DEFINED).
 986     ///
 987     /// </summary>
 988     System.Collections.IDictionary Details { get; }
 989   }
 990   /// <summary>Autogenerated type. AMQP specification method "channel.close".</summary>
 991   /// <remarks>
 992   ///
 993   ///     This method indicates that the sender wants to close the channel.
 994   ///     This may be due to internal conditions (e.g. a forced shut-down) or
 995   ///     due to an error handling a specific method, i.e. an exception.  When
 996   ///     a close is due to an exception, the sender provides the class and
 997   ///     method id of the method which caused the exception.
 998   ///
 999   /// </remarks>
1000   public interface IChannelClose: IMethod {
1001     // (no documentation)
1002     ushort ReplyCode { get; }
1003     // (no documentation)
1004     string ReplyText { get; }
1005     /// <summary>
1006     ///
1007     ///       When the close is provoked by a method exception, this is the
1008     ///       class of the method.
1009     ///
1010     /// </summary>
1011     ushort ClassId { get; }
1012     /// <summary>
1013     ///
1014     ///       When the close is provoked by a method exception, this is the
1015     ///       ID of the method.
1016     ///
1017     /// </summary>
1018     ushort MethodId { get; }
1019   }
1020   /// <summary>Autogenerated type. AMQP specification method "channel.close-ok".</summary>
1021   /// <remarks>
1022   ///
1023   ///     This method confirms a Channel.Close method and tells the recipient
1024   ///     that it is safe to release resources for the channel and close the
1025   ///     socket.
1026   ///
1027   /// </remarks>
1028   public interface IChannelCloseOk: IMethod {
1029   }
1030   /// <summary>Autogenerated type. AMQP specification method "access.request".</summary>
1031   /// <remarks>
1032   ///
1033   ///     This method requests an access ticket for an access realm.
1034   ///     The server responds by granting the access ticket.  If the
1035   ///     client does not have access rights to the requested realm
1036   ///     this causes a connection exception.  Access tickets are a
1037   ///     per-channel resource.
1038   ///
1039   /// </remarks>
1040   public interface IAccessRequest: IMethod {
1041     // (no documentation)
1042     string Realm { get; }
1043     /// <summary>
1044     ///
1045     ///       Request exclusive access to the realm. If the server cannot grant
1046     ///       this - because there are other active tickets for the realm - it
1047     ///       raises a channel exception.
1048     ///
1049     /// </summary>
1050     bool Exclusive { get; }
1051     /// <summary>
1052     ///
1053     ///       Request message passive access to the specified access realm.
1054     ///       Passive access lets a client get information about resources in
1055     ///       the realm but not to make any changes to them.
1056     ///
1057     /// </summary>
1058     bool Passive { get; }
1059     /// <summary>
1060     ///
1061     ///       Request message active access to the specified access realm.
1062     ///       Acvtive access lets a client get create and delete resources in
1063     ///       the realm.
1064     ///
1065     /// </summary>
1066     bool Active { get; }
1067     /// <summary>
1068     ///
1069     ///       Request write access to the specified access realm.  Write access
1070     ///       lets a client publish messages to all exchanges in the realm.
1071     ///
1072     /// </summary>
1073     bool Write { get; }
1074     /// <summary>
1075     ///
1076     ///       Request read access to the specified access realm.  Read access
1077     ///       lets a client consume messages from queues in the realm.
1078     ///
1079     /// </summary>
1080     bool Read { get; }
1081   }
1082   /// <summary>Autogenerated type. AMQP specification method "access.request-ok".</summary>
1083   /// <remarks>
1084   ///
1085   ///     This method provides the client with an access ticket. The access
1086   ///     ticket is valid within the current channel and for the lifespan of
1087   ///     the channel.
1088   ///
1089   /// </remarks>
1090   public interface IAccessRequestOk: IMethod {
1091     // (no documentation)
1092     ushort Ticket { get; }
1093   }
1094   /// <summary>Autogenerated type. AMQP specification method "exchange.declare".</summary>
1095   /// <remarks>
1096   ///
1097   ///     This method creates an exchange if it does not already exist, and if the
1098   ///     exchange exists, verifies that it is of the correct and expected class.
1099   ///
1100   /// </remarks>
1101   public interface IExchangeDeclare: IMethod {
1102     /// <summary>
1103     ///
1104     ///       When a client defines a new exchange, this belongs to the access realm
1105     ///       of the ticket used.  All further work done with that exchange must be
1106     ///       done with an access ticket for the same realm.
1107     ///
1108     /// </summary>
1109     ushort Ticket { get; }
1110     // (no documentation)
1111     string Exchange { get; }
1112     /// <summary>
1113     ///
1114     ///       Each exchange belongs to one of a set of exchange types implemented
1115     ///       by the server.  The exchange types define the functionality of the
1116     ///       exchange - i.e. how messages are routed through it.  It is not valid
1117     ///       or meaningful to attempt to change the type of an existing exchange.
1118     ///
1119     /// </summary>
1120     string Type { get; }
1121     /// <summary>
1122     ///
1123     ///     If set, the server will not create the exchange.  The client can use
1124     ///     this to check whether an exchange exists without modifying the server
1125     ///     state.
1126     ///
1127     /// </summary>
1128     bool Passive { get; }
1129     /// <summary>
1130     ///
1131     ///       If set when creating a new exchange, the exchange will be marked as
1132     ///       durable.  Durable exchanges remain active when a server restarts.
1133     ///       Non-durable exchanges (transient exchanges) are purged if/when a
1134     ///       server restarts.
1135     ///
1136     /// </summary>
1137     bool Durable { get; }
1138     /// <summary>
1139     ///
1140     ///       If set, the exchange is deleted when all queues have finished
1141     ///       using it.
1142     ///
1143     /// </summary>
1144     bool AutoDelete { get; }
1145     /// <summary>
1146     ///
1147     ///       If set, the exchange may not be used directly by publishers, but
1148     ///       only when bound to other exchanges. Internal exchanges are used to
1149     ///       construct wiring that is not visible to applications.
1150     ///
1151     /// </summary>
1152     bool Internal { get; }
1153     /// <summary>
1154     ///
1155     ///     If set, the server will not respond to the method. The client should
1156     ///     not wait for a reply method.  If the server could not complete the
1157     ///     method it will raise a channel or connection exception.
1158     ///
1159     /// </summary>
1160     bool Nowait { get; }
1161     /// <summary>
1162     ///
1163     ///       A set of arguments for the declaration. The syntax and semantics
1164     ///       of these arguments depends on the server implementation.  This
1165     ///       field is ignored if passive is 1.
1166     ///
1167     /// </summary>
1168     System.Collections.IDictionary Arguments { get; }
1169   }
1170   /// <summary>Autogenerated type. AMQP specification method "exchange.declare-ok".</summary>
1171   /// <remarks>
1172   ///
1173   ///     This method confirms a Declare method and confirms the name of the
1174   ///     exchange, essential for automatically-named exchanges.
1175   ///
1176   /// </remarks>
1177   public interface IExchangeDeclareOk: IMethod {
1178   }
1179   /// <summary>Autogenerated type. AMQP specification method "exchange.delete".</summary>
1180   /// <remarks>
1181   ///
1182   ///     This method deletes an exchange.  When an exchange is deleted all queue
1183   ///     bindings on the exchange are cancelled.
1184   ///
1185   /// </remarks>
1186   public interface IExchangeDelete: IMethod {
1187     // (no documentation)
1188     ushort Ticket { get; }
1189     // (no documentation)
1190     string Exchange { get; }
1191     /// <summary>
1192     ///
1193     ///       If set, the server will only delete the exchange if it has no queue
1194     ///       bindings. If the exchange has queue bindings the server does not
1195     ///       delete it but raises a channel exception instead.
1196     ///
1197     /// </summary>
1198     bool IfUnused { get; }
1199     /// <summary>
1200     ///
1201     ///     If set, the server will not respond to the method. The client should
1202     ///     not wait for a reply method.  If the server could not complete the
1203     ///     method it will raise a channel or connection exception.
1204     ///
1205     /// </summary>
1206     bool Nowait { get; }
1207   }
1208   /// <summary>Autogenerated type. AMQP specification method "exchange.delete-ok".</summary>
1209   /// <remarks>
1210   ///
1211   ///     This method confirms the deletion of an exchange.
1212   ///
1213   /// </remarks>
1214   public interface IExchangeDeleteOk: IMethod {
1215   }
1216   /// <summary>Autogenerated type. AMQP specification method "queue.declare".</summary>
1217   /// <remarks>
1218   ///
1219   ///     This method creates or checks a queue.  When creating a new queue
1220   ///     the client can specify various properties that control the durability
1221   ///     of the queue and its contents, and the level of sharing for the queue.
1222   ///
1223   /// </remarks>
1224   public interface IQueueDeclare: IMethod {
1225     /// <summary>
1226     ///
1227     ///       When a client defines a new queue, this belongs to the access realm
1228     ///       of the ticket used.  All further work done with that queue must be
1229     ///       done with an access ticket for the same realm.
1230     ///
1231     /// </summary>
1232     ushort Ticket { get; }
1233     // (no documentation)
1234     string Queue { get; }
1235     /// <summary>
1236     ///
1237     ///     If set, the server will not create the queue.  The client can use
1238     ///     this to check whether a queue exists without modifying the server
1239     ///     state.
1240     ///
1241     /// </summary>
1242     bool Passive { get; }
1243     /// <summary>
1244     ///
1245     ///       If set when creating a new queue, the queue will be marked as
1246     ///       durable.  Durable queues remain active when a server restarts.
1247     ///       Non-durable queues (transient queues) are purged if/when a
1248     ///       server restarts.  Note that durable queues do not necessarily
1249     ///       hold persistent messages, although it does not make sense to
1250     ///       send persistent messages to a transient queue.
1251     ///
1252     /// </summary>
1253     bool Durable { get; }
1254     /// <summary>
1255     ///
1256     ///       Exclusive queues may only be consumed from by the current connection.
1257     ///       Setting the 'exclusive' flag always implies 'auto-delete'.
1258     ///
1259     /// </summary>
1260     bool Exclusive { get; }
1261     /// <summary>
1262     ///
1263     ///       If set, the queue is deleted when all consumers have finished
1264     ///       using it. Last consumer can be cancelled either explicitly or because
1265     ///       its channel is closed. If there was no consumer ever on the queue, it
1266     ///       won't be deleted.
1267     ///
1268     /// </summary>
1269     bool AutoDelete { get; }
1270     /// <summary>
1271     ///
1272     ///     If set, the server will not respond to the method. The client should
1273     ///     not wait for a reply method.  If the server could not complete the
1274     ///     method it will raise a channel or connection exception.
1275     ///
1276     /// </summary>
1277     bool Nowait { get; }
1278     /// <summary>
1279     ///
1280     ///       A set of arguments for the declaration. The syntax and semantics
1281     ///       of these arguments depends on the server implementation.  This
1282     ///       field is ignored if passive is 1.
1283     ///
1284     /// </summary>
1285     System.Collections.IDictionary Arguments { get; }
1286   }
1287   /// <summary>Autogenerated type. AMQP specification method "queue.declare-ok".</summary>
1288   /// <remarks>
1289   ///
1290   ///     This method confirms a Declare method and confirms the name of the
1291   ///     queue, essential for automatically-named queues.
1292   ///
1293   /// </remarks>
1294   public interface IQueueDeclareOk: IMethod {
1295     /// <summary>
1296     ///
1297     ///       Reports the name of the queue. If the server generated a queue
1298     ///       name, this field contains that name.
1299     ///
1300     /// </summary>
1301     string Queue { get; }
1302     /// <summary>
1303     ///
1304     ///       Reports the number of messages in the queue, which will be zero
1305     ///       for newly-created queues.
1306     ///
1307     /// </summary>
1308     uint MessageCount { get; }
1309     /// <summary>
1310     ///
1311     ///       Reports the number of active consumers for the queue. Note that
1312     ///       consumers can suspend activity (Channel.Flow) in which case they
1313     ///       do not appear in this count.
1314     ///
1315     /// </summary>
1316     uint ConsumerCount { get; }
1317   }
1318   /// <summary>Autogenerated type. AMQP specification method "queue.bind".</summary>
1319   /// <remarks>
1320   ///
1321   ///     This method binds a queue to an exchange.  Until a queue is
1322   ///     bound it will not receive any messages.  In a classic messaging
1323   ///     model, store-and-forward queues are bound to a dest exchange
1324   ///     and subscription queues are bound to a dest_wild exchange.
1325   ///
1326   /// </remarks>
1327   public interface IQueueBind: IMethod {
1328     /// <summary>
1329     ///
1330     ///       The client provides a valid access ticket giving "active"
1331     ///       access rights to the queue's access realm.
1332     ///
1333     /// </summary>
1334     ushort Ticket { get; }
1335     /// <summary>
1336     ///
1337     ///       Specifies the name of the queue to bind.  If the queue name is
1338     ///       empty, refers to the current queue for the channel, which is
1339     ///       the last declared queue.
1340     ///
1341     /// </summary>
1342     string Queue { get; }
1343     // (no documentation)
1344     string Exchange { get; }
1345     /// <summary>
1346     ///
1347     ///       Specifies the routing key for the binding.  The routing key is
1348     ///       used for routing messages depending on the exchange configuration.
1349     ///       Not all exchanges use a routing key - refer to the specific
1350     ///       exchange documentation.  If the routing key is empty and the queue
1351     ///       name is empty, the routing key will be the current queue for the
1352     ///       channel, which is the last declared queue.
1353     ///
1354     /// </summary>
1355     string RoutingKey { get; }
1356     /// <summary>
1357     ///
1358     ///     If set, the server will not respond to the method. The client should
1359     ///     not wait for a reply method.  If the server could not complete the
1360     ///     method it will raise a channel or connection exception.
1361     ///
1362     /// </summary>
1363     bool Nowait { get; }
1364     /// <summary>
1365     ///
1366     ///       A set of arguments for the binding.  The syntax and semantics of
1367     ///       these arguments depends on the exchange class.
1368     ///
1369     /// </summary>
1370     System.Collections.IDictionary Arguments { get; }
1371   }
1372   /// <summary>Autogenerated type. AMQP specification method "queue.bind-ok".</summary>
1373   /// <remarks>
1374   ///
1375   ///     This method confirms that the bind was successful.
1376   ///
1377   /// </remarks>
1378   public interface IQueueBindOk: IMethod {
1379   }
1380   /// <summary>Autogenerated type. AMQP specification method "queue.unbind".</summary>
1381   /// <remarks>
1382   /// This method unbinds a queue from an exchange.
1383   /// </remarks>
1384   public interface IQueueUnbind: IMethod {
1385     /// <summary>
1386     ///
1387     ///           The client provides a valid access ticket giving "active"
1388     ///           access rights to the queue's access realm.
1389     ///
1390     /// </summary>
1391     ushort Ticket { get; }
1392     /// <summary>
1393     /// Specifies the name of the queue to unbind.
1394     /// </summary>
1395     string Queue { get; }
1396     /// <summary>
1397     /// The name of the exchange to unbind from.
1398     /// </summary>
1399     string Exchange { get; }
1400     /// <summary>
1401     /// Specifies the routing key of the binding to unbind.
1402     /// </summary>
1403     string RoutingKey { get; }
1404     /// <summary>
1405     /// Specifies the arguments of the binding to unbind.
1406     /// </summary>
1407     System.Collections.IDictionary Arguments { get; }
1408   }
1409   /// <summary>Autogenerated type. AMQP specification method "queue.unbind-ok".</summary>
1410   /// <remarks>
1411   /// This method confirms that the unbind was successful.
1412   /// </remarks>
1413   public interface IQueueUnbindOk: IMethod {
1414   }
1415   /// <summary>Autogenerated type. AMQP specification method "queue.purge".</summary>
1416   /// <remarks>
1417   ///
1418   ///     This method removes all messages from a queue.  It does not cancel
1419   ///     consumers.  Purged messages are deleted without any formal "undo"
1420   ///     mechanism.
1421   ///
1422   /// </remarks>
1423   public interface IQueuePurge: IMethod {
1424     /// <summary>
1425     ///
1426     ///       The access ticket must be for the access realm that holds the
1427     ///       queue.
1428     ///
1429     /// </summary>
1430     ushort Ticket { get; }
1431     /// <summary>
1432     ///
1433     ///       Specifies the name of the queue to purge.  If the queue name is
1434     ///       empty, refers to the current queue for the channel, which is
1435     ///       the last declared queue.
1436     ///
1437     /// </summary>
1438     string Queue { get; }
1439     /// <summary>
1440     ///
1441     ///     If set, the server will not respond to the method. The client should
1442     ///     not wait for a reply method.  If the server could not complete the
1443     ///     method it will raise a channel or connection exception.
1444     ///
1445     /// </summary>
1446     bool Nowait { get; }
1447   }
1448   /// <summary>Autogenerated type. AMQP specification method "queue.purge-ok".</summary>
1449   /// <remarks>
1450   ///
1451   ///     This method confirms the purge of a queue.
1452   ///
1453   /// </remarks>
1454   public interface IQueuePurgeOk: IMethod {
1455     /// <summary>
1456     ///
1457     ///       Reports the number of messages purged.
1458     ///
1459     /// </summary>
1460     uint MessageCount { get; }
1461   }
1462   /// <summary>Autogenerated type. AMQP specification method "queue.delete".</summary>
1463   /// <remarks>
1464   ///
1465   ///     This method deletes a queue.  When a queue is deleted any pending
1466   ///     messages are sent to a dead-letter queue if this is defined in the
1467   ///     server configuration, and all consumers on the queue are cancelled.
1468   ///
1469   /// </remarks>
1470   public interface IQueueDelete: IMethod {
1471     /// <summary>
1472     ///
1473     ///       The client provides a valid access ticket giving "active"
1474     ///       access rights to the queue's access realm.
1475     ///
1476     /// </summary>
1477     ushort Ticket { get; }
1478     /// <summary>
1479     ///
1480     ///       Specifies the name of the queue to delete. If the queue name is
1481     ///       empty, refers to the current queue for the channel, which is the
1482     ///       last declared queue.
1483     ///
1484     /// </summary>
1485     string Queue { get; }
1486     /// <summary>
1487     ///
1488     ///       If set, the server will only delete the queue if it has no
1489     ///       consumers. If the queue has consumers the server does does not
1490     ///       delete it but raises a channel exception instead.
1491     ///
1492     /// </summary>
1493     bool IfUnused { get; }
1494     /// <summary>
1495     ///
1496     ///       If set, the server will only delete the queue if it has no
1497     ///       messages. If the queue is not empty the server raises a channel
1498     ///       exception.
1499     ///
1500     /// </summary>
1501     bool IfEmpty { get; }
1502     /// <summary>
1503     ///
1504     ///     If set, the server will not respond to the method. The client should
1505     ///     not wait for a reply method.  If the server could not complete the
1506     ///     method it will raise a channel or connection exception.
1507     ///
1508     /// </summary>
1509     bool Nowait { get; }
1510   }
1511   /// <summary>Autogenerated type. AMQP specification method "queue.delete-ok".</summary>
1512   /// <remarks>
1513   ///
1514   ///     This method confirms the deletion of a queue.
1515   ///
1516   /// </remarks>
1517   public interface IQueueDeleteOk: IMethod {
1518     /// <summary>
1519     ///
1520     ///       Reports the number of messages purged.
1521     ///
1522     /// </summary>
1523     uint MessageCount { get; }
1524   }
1525   /// <summary>Autogenerated type. AMQP specification method "basic.qos".</summary>
1526   /// <remarks>
1527   ///
1528   ///     This method requests a specific quality of service.  The QoS can
1529   ///     be specified for the current channel or for all channels on the
1530   ///     connection.  The particular properties and semantics of a qos method
1531   ///     always depend on the content class semantics.  Though the qos method
1532   ///     could in principle apply to both peers, it is currently meaningful
1533   ///     only for the server.
1534   ///
1535   /// </remarks>
1536   public interface IBasicQos: IMethod {
1537     /// <summary>
1538     ///
1539     ///       The client can request that messages be sent in advance so that
1540     ///       when the client finishes processing a message, the following
1541     ///       message is already held locally, rather than needing to be sent
1542     ///       down the channel.  Prefetching gives a performance improvement.
1543     ///       This field specifies the prefetch window size in octets.  The
1544     ///       server will send a message in advance if it is equal to or
1545     ///       smaller in size than the available prefetch size (and also falls
1546     ///       into other prefetch limits). May be set to zero, meaning "no
1547     ///       specific limit", although other prefetch limits may still apply.
1548     ///       The prefetch-size is ignored if the no-ack option is set.
1549     ///
1550     /// </summary>
1551     uint PrefetchSize { get; }
1552     /// <summary>
1553     ///
1554     ///       Specifies a prefetch window in terms of whole messages.  This
1555     ///       field may be used in combination with the prefetch-size field;
1556     ///       a message will only be sent in advance if both prefetch windows
1557     ///       (and those at the channel and connection level) allow it.
1558     ///       The prefetch-count is ignored if the no-ack option is set.
1559     ///
1560     /// </summary>
1561     ushort PrefetchCount { get; }
1562     /// <summary>
1563     ///
1564     ///       By default the QoS settings apply to the current channel only.  If
1565     ///       this field is set, they are applied to the entire connection.
1566     ///
1567     /// </summary>
1568     bool Global { get; }
1569   }
1570   /// <summary>Autogenerated type. AMQP specification method "basic.qos-ok".</summary>
1571   /// <remarks>
1572   ///
1573   ///     This method tells the client that the requested QoS levels could
1574   ///     be handled by the server.  The requested QoS applies to all active
1575   ///     consumers until a new QoS is defined.
1576   ///
1577   /// </remarks>
1578   public interface IBasicQosOk: IMethod {
1579   }
1580   /// <summary>Autogenerated type. AMQP specification method "basic.consume".</summary>
1581   /// <remarks>
1582   ///
1583   ///     This method asks the server to start a "consumer", which is a
1584   ///     transient request for messages from a specific queue. Consumers
1585   ///     last as long as the channel they were created on, or until the
1586   ///     client cancels them.
1587   ///
1588   /// </remarks>
1589   public interface IBasicConsume: IMethod {
1590     /// <summary>
1591     ///
1592     ///       The client MUST provide a valid access ticket giving "read" access
1593     ///       rights to the realm for the queue.
1594     ///
1595     /// </summary>
1596     ushort Ticket { get; }
1597     /// <summary>
1598     ///
1599     ///       Specifies the name of the queue to consume from.  If the queue name
1600     ///       is null, refers to the current queue for the channel, which is the
1601     ///       last declared queue.
1602     ///
1603     /// </summary>
1604     string Queue { get; }
1605     /// <summary>
1606     ///
1607     ///       Specifies the identifier for the consumer. The consumer tag is
1608     ///       local to a connection, so two clients can use the same consumer
1609     ///       tags. If this field is empty the server will generate a unique
1610     ///       tag.
1611     ///
1612     /// </summary>
1613     string ConsumerTag { get; }
1614     // (no documentation)
1615     bool NoLocal { get; }
1616     // (no documentation)
1617     bool NoAck { get; }
1618     /// <summary>
1619     ///
1620     ///       Request exclusive consumer access, meaning only this consumer can
1621     ///       access the queue.
1622     ///
1623     /// </summary>
1624     bool Exclusive { get; }
1625     /// <summary>
1626     ///
1627     ///     If set, the server will not respond to the method. The client should
1628     ///     not wait for a reply method.  If the server could not complete the
1629     ///     method it will raise a channel or connection exception.
1630     ///
1631     /// </summary>
1632     bool Nowait { get; }
1633   }
1634   /// <summary>Autogenerated type. AMQP specification method "basic.consume-ok".</summary>
1635   /// <remarks>
1636   ///
1637   ///     The server provides the client with a consumer tag, which is used
1638   ///     by the client for methods called on the consumer at a later stage.
1639   ///
1640   /// </remarks>
1641   public interface IBasicConsumeOk: IMethod {
1642     /// <summary>
1643     ///
1644     ///       Holds the consumer tag specified by the client or provided by
1645     ///       the server.
1646     ///
1647     /// </summary>
1648     string ConsumerTag { get; }
1649   }
1650   /// <summary>Autogenerated type. AMQP specification method "basic.cancel".</summary>
1651   /// <remarks>
1652   ///
1653   ///     This method cancels a consumer. This does not affect already
1654   ///     delivered messages, but it does mean the server will not send any
1655   ///     more messages for that consumer.  The client may receive an
1656   ///     abitrary number of messages in between sending the cancel method
1657   ///     and receiving the cancel-ok reply.
1658   ///
1659   /// </remarks>
1660   public interface IBasicCancel: IMethod {
1661     // (no documentation)
1662     string ConsumerTag { get; }
1663     /// <summary>
1664     ///
1665     ///     If set, the server will not respond to the method. The client should
1666     ///     not wait for a reply method.  If the server could not complete the
1667     ///     method it will raise a channel or connection exception.
1668     ///
1669     /// </summary>
1670     bool Nowait { get; }
1671   }
1672   /// <summary>Autogenerated type. AMQP specification method "basic.cancel-ok".</summary>
1673   /// <remarks>
1674   ///
1675   ///     This method confirms that the cancellation was completed.
1676   ///
1677   /// </remarks>
1678   public interface IBasicCancelOk: IMethod {
1679     // (no documentation)
1680     string ConsumerTag { get; }
1681   }
1682   /// <summary>Autogenerated type. AMQP specification method "basic.publish".</summary>
1683   /// <remarks>
1684   ///
1685   ///     This method publishes a message to a specific exchange. The message
1686   ///     will be routed to queues as defined by the exchange configuration
1687   ///     and distributed to any active consumers when the transaction, if any,
1688   ///     is committed.
1689   ///
1690   /// </remarks>
1691   public interface IBasicPublish: IMethod {
1692     /// <summary>
1693     ///
1694     ///       The client MUST provide a valid access ticket giving "write"
1695     ///       access rights to the access realm for the exchange.
1696     ///
1697     /// </summary>
1698     ushort Ticket { get; }
1699     /// <summary>
1700     ///
1701     ///       Specifies the name of the exchange to publish to.  The exchange
1702     ///       name can be empty, meaning the default exchange.  If the exchange
1703     ///       name is specified, and that exchange does not exist, the server
1704     ///       will raise a channel exception.
1705     ///
1706     /// </summary>
1707     string Exchange { get; }
1708     /// <summary>
1709     ///
1710     ///       Specifies the routing key for the message.  The routing key is
1711     ///       used for routing messages depending on the exchange configuration.
1712     ///
1713     /// </summary>
1714     string RoutingKey { get; }
1715     /// <summary>
1716     ///
1717     ///       This flag tells the server how to react if the message cannot be
1718     ///       routed to a queue.  If this flag is set, the server will return an
1719     ///       unroutable message with a Return method.  If this flag is zero, the
1720     ///       server silently drops the message.
1721     ///
1722     /// </summary>
1723     bool Mandatory { get; }
1724     /// <summary>
1725     ///
1726     ///       This flag tells the server how to react if the message cannot be
1727     ///       routed to a queue consumer immediately.  If this flag is set, the
1728     ///       server will return an undeliverable message with a Return method.
1729     ///       If this flag is zero, the server will queue the message, but with
1730     ///       no guarantee that it will ever be consumed.
1731     ///
1732     /// </summary>
1733     bool Immediate { get; }
1734   }
1735   /// <summary>Autogenerated type. AMQP specification method "basic.return".</summary>
1736   /// <remarks>
1737   ///
1738   ///     This method returns an undeliverable message that was published
1739   ///     with the "immediate" flag set, or an unroutable message published
1740   ///     with the "mandatory" flag set. The reply code and text provide
1741   ///     information about the reason that the message was undeliverable.
1742   ///
1743   /// </remarks>
1744   public interface IBasicReturn: IMethod {
1745     // (no documentation)
1746     ushort ReplyCode { get; }
1747     // (no documentation)
1748     string ReplyText { get; }
1749     /// <summary>
1750     ///
1751     ///       Specifies the name of the exchange that the message was
1752     ///       originally published to.
1753     ///
1754     /// </summary>
1755     string Exchange { get; }
1756     /// <summary>
1757     ///
1758     ///       Specifies the routing key name specified when the message was
1759     ///       published.
1760     ///
1761     /// </summary>
1762     string RoutingKey { get; }
1763   }
1764   /// <summary>Autogenerated type. AMQP specification method "basic.deliver".</summary>
1765   /// <remarks>
1766   ///
1767   ///     This method delivers a message to the client, via a consumer.  In
1768   ///     the asynchronous message delivery model, the client starts a
1769   ///     consumer using the Consume method, then the server responds with
1770   ///     Deliver methods as and when messages arrive for that consumer.
1771   ///
1772   /// </remarks>
1773   public interface IBasicDeliver: IMethod {
1774     // (no documentation)
1775     string ConsumerTag { get; }
1776     // (no documentation)
1777     ulong DeliveryTag { get; }
1778     // (no documentation)
1779     bool Redelivered { get; }
1780     /// <summary>
1781     ///
1782     ///       Specifies the name of the exchange that the message was
1783     ///       originally published to.
1784     ///
1785     /// </summary>
1786     string Exchange { get; }
1787     /// <summary>
1788     ///
1789     ///       Specifies the routing key name specified when the message was
1790     ///       published.
1791     ///
1792     /// </summary>
1793     string RoutingKey { get; }
1794   }
1795   /// <summary>Autogenerated type. AMQP specification method "basic.get".</summary>
1796   /// <remarks>
1797   ///
1798   ///     This method provides a direct access to the messages in a queue
1799   ///     using a synchronous dialogue that is designed for specific types of
1800   ///     application where synchronous functionality is more important than
1801   ///     performance.
1802   ///
1803   /// </remarks>
1804   public interface IBasicGet: IMethod {
1805     /// <summary>
1806     ///
1807     ///       The client MUST provide a valid access ticket giving "read"
1808     ///       access rights to the realm for the queue.
1809     ///
1810     /// </summary>
1811     ushort Ticket { get; }
1812     /// <summary>
1813     ///
1814     ///       Specifies the name of the queue to consume from.  If the queue name
1815     ///       is null, refers to the current queue for the channel, which is the
1816     ///       last declared queue.
1817     ///
1818     /// </summary>
1819     string Queue { get; }
1820     // (no documentation)
1821     bool NoAck { get; }
1822   }
1823   /// <summary>Autogenerated type. AMQP specification method "basic.get-ok".</summary>
1824   /// <remarks>
1825   ///
1826   ///     This method delivers a message to the client following a get
1827   ///     method.  A message delivered by 'get-ok' must be acknowledged
1828   ///     unless the no-ack option was set in the get method.
1829   ///
1830   /// </remarks>
1831   public interface IBasicGetOk: IMethod {
1832     // (no documentation)
1833     ulong DeliveryTag { get; }
1834     // (no documentation)
1835     bool Redelivered { get; }
1836     /// <summary>
1837     ///
1838     ///       Specifies the name of the exchange that the message was originally
1839     ///       published to.  If empty, the message was published to the default
1840     ///       exchange.
1841     ///
1842     /// </summary>
1843     string Exchange { get; }
1844     /// <summary>
1845     ///
1846     ///       Specifies the routing key name specified when the message was
1847     ///       published.
1848     ///
1849     /// </summary>
1850     string RoutingKey { get; }
1851     /// <summary>
1852     ///
1853     ///       This field reports the number of messages pending on the queue,
1854     ///       excluding the message being delivered.  Note that this figure is
1855     ///       indicative, not reliable, and can change arbitrarily as messages
1856     ///       are added to the queue and removed by other clients.
1857     ///
1858     /// </summary>
1859     uint MessageCount { get; }
1860   }
1861   /// <summary>Autogenerated type. AMQP specification method "basic.get-empty".</summary>
1862   /// <remarks>
1863   ///
1864   ///     This method tells the client that the queue has no messages
1865   ///     available for the client.
1866   ///
1867   /// </remarks>
1868   public interface IBasicGetEmpty: IMethod {
1869     /// <summary>
1870     ///
1871     ///       For use by cluster applications, should not be used by
1872     ///       client applications.
1873     ///
1874     /// </summary>
1875     string ClusterId { get; }
1876   }
1877   /// <summary>Autogenerated type. AMQP specification method "basic.ack".</summary>
1878   /// <remarks>
1879   ///
1880   ///     This method acknowledges one or more messages delivered via the
1881   ///     Deliver or Get-Ok methods.  The client can ask to confirm a
1882   ///     single message or a set of messages up to and including a specific
1883   ///     message.
1884   ///
1885   /// </remarks>
1886   public interface IBasicAck: IMethod {
1887     // (no documentation)
1888     ulong DeliveryTag { get; }
1889     /// <summary>
1890     ///
1891     ///       If set to 1, the delivery tag is treated as "up to and including",
1892     ///       so that the client can acknowledge multiple messages with a single
1893     ///       method.  If set to zero, the delivery tag refers to a single
1894     ///       message.  If the multiple field is 1, and the delivery tag is zero,
1895     ///       tells the server to acknowledge all outstanding mesages.
1896     ///
1897     /// </summary>
1898     bool Multiple { get; }
1899   }
1900   /// <summary>Autogenerated type. AMQP specification method "basic.reject".</summary>
1901   /// <remarks>
1902   ///
1903   ///     This method allows a client to reject a message.  It can be used to
1904   ///     interrupt and cancel large incoming messages, or return untreatable
1905   ///     messages to their original queue.
1906   ///
1907   /// </remarks>
1908   public interface IBasicReject: IMethod {
1909     // (no documentation)
1910     ulong DeliveryTag { get; }
1911     /// <summary>
1912     ///
1913     ///       If this field is zero, the message will be discarded.  If this bit
1914     ///       is 1, the server will attempt to requeue the message.
1915     ///
1916     /// </summary>
1917     bool Requeue { get; }
1918   }
1919   /// <summary>Autogenerated type. AMQP specification method "basic.recover".</summary>
1920   /// <remarks>
1921   ///
1922   ///     This method asks the broker to redeliver all unacknowledged messages on a
1923   ///     specifieid channel. Zero or more messages may be redelivered.
1924   ///
1925   /// </remarks>
1926   public interface IBasicRecover: IMethod {
1927     /// <summary>
1928     ///
1929     ///       If this field is zero, the message will be redelivered to the original recipient.  If this bit
1930     ///       is 1, the server will attempt to requeue the message, potentially then delivering it to an
1931     ///       alternative subscriber.
1932     ///
1933     /// </summary>
1934     bool Requeue { get; }
1935   }
1936   /// <summary>Autogenerated type. AMQP specification method "file.qos".</summary>
1937   /// <remarks>
1938   ///
1939   ///     This method requests a specific quality of service.  The QoS can
1940   ///     be specified for the current channel or for all channels on the
1941   ///     connection.  The particular properties and semantics of a qos method
1942   ///     always depend on the content class semantics.  Though the qos method
1943   ///     could in principle apply to both peers, it is currently meaningful
1944   ///     only for the server.
1945   ///
1946   /// </remarks>
1947   public interface IFileQos: IMethod {
1948     /// <summary>
1949     ///
1950     ///       The client can request that messages be sent in advance so that
1951     ///       when the client finishes processing a message, the following
1952     ///       message is already held locally, rather than needing to be sent
1953     ///       down the channel.  Prefetching gives a performance improvement.
1954     ///       This field specifies the prefetch window size in octets. May be
1955     ///       set to zero, meaning "no specific limit".  Note that other
1956     ///       prefetch limits may still apply. The prefetch-size is ignored
1957     ///       if the no-ack option is set.
1958     ///
1959     /// </summary>
1960     uint PrefetchSize { get; }
1961     /// <summary>
1962     ///
1963     ///       Specifies a prefetch window in terms of whole messages.  This
1964     ///       is compatible with some file API implementations.  This field
1965     ///       may be used in combination with the prefetch-size field; a
1966     ///       message will only be sent in advance if both prefetch windows
1967     ///       (and those at the channel and connection level) allow it.
1968     ///       The prefetch-count is ignored if the no-ack option is set.
1969     ///
1970     /// </summary>
1971     ushort PrefetchCount { get; }
1972     /// <summary>
1973     ///
1974     ///       By default the QoS settings apply to the current channel only.  If
1975     ///       this field is set, they are applied to the entire connection.
1976     ///
1977     /// </summary>
1978     bool Global { get; }
1979   }
1980   /// <summary>Autogenerated type. AMQP specification method "file.qos-ok".</summary>
1981   /// <remarks>
1982   ///
1983   ///     This method tells the client that the requested QoS levels could
1984   ///     be handled by the server.  The requested QoS applies to all active
1985   ///     consumers until a new QoS is defined.
1986   ///
1987   /// </remarks>
1988   public interface IFileQosOk: IMethod {
1989   }
1990   /// <summary>Autogenerated type. AMQP specification method "file.consume".</summary>
1991   /// <remarks>
1992   ///
1993   ///     This method asks the server to start a "consumer", which is a
1994   ///     transient request for messages from a specific queue. Consumers
1995   ///     last as long as the channel they were created on, or until the
1996   ///     client cancels them.
1997   ///
1998   /// </remarks>
1999   public interface IFileConsume: IMethod {
2000     /// <summary>
2001     ///
2002     ///       The client MUST provide a valid access ticket giving "read" access
2003     ///       rights to the realm for the queue.
2004     ///
2005     /// </summary>
2006     ushort Ticket { get; }
2007     /// <summary>
2008     ///
2009     ///       Specifies the name of the queue to consume from.  If the queue name
2010     ///       is null, refers to the current queue for the channel, which is the
2011     ///       last declared queue.
2012     ///
2013     /// </summary>
2014     string Queue { get; }
2015     /// <summary>
2016     ///
2017     ///       Specifies the identifier for the consumer. The consumer tag is
2018     ///       local to a connection, so two clients can use the same consumer
2019     ///       tags. If this field is empty the server will generate a unique
2020     ///       tag.
2021     ///
2022     /// </summary>
2023     string ConsumerTag { get; }
2024     // (no documentation)
2025     bool NoLocal { get; }
2026     // (no documentation)
2027     bool NoAck { get; }
2028     /// <summary>
2029     ///
2030     ///       Request exclusive consumer access, meaning only this consumer can
2031     ///       access the queue.
2032     ///
2033     /// </summary>
2034     bool Exclusive { get; }
2035     /// <summary>
2036     ///
2037     ///     If set, the server will not respond to the method. The client should
2038     ///     not wait for a reply method.  If the server could not complete the
2039     ///     method it will raise a channel or connection exception.
2040     ///
2041     /// </summary>
2042     bool Nowait { get; }
2043   }
2044   /// <summary>Autogenerated type. AMQP specification method "file.consume-ok".</summary>
2045   /// <remarks>
2046   ///
2047   ///     This method provides the client with a consumer tag which it MUST
2048   ///     use in methods that work with the consumer.
2049   ///
2050   /// </remarks>
2051   public interface IFileConsumeOk: IMethod {
2052     /// <summary>
2053     ///
2054     ///       Holds the consumer tag specified by the client or provided by
2055     ///       the server.
2056     ///
2057     /// </summary>
2058     string ConsumerTag { get; }
2059   }
2060   /// <summary>Autogenerated type. AMQP specification method "file.cancel".</summary>
2061   /// <remarks>
2062   ///
2063   ///     This method cancels a consumer. This does not affect already
2064   ///     delivered messages, but it does mean the server will not send any
2065   ///     more messages for that consumer.
2066   ///
2067   /// </remarks>
2068   public interface IFileCancel: IMethod {
2069     // (no documentation)
2070     string ConsumerTag { get; }
2071     /// <summary>
2072     ///
2073     ///     If set, the server will not respond to the method. The client should
2074     ///     not wait for a reply method.  If the server could not complete the
2075     ///     method it will raise a channel or connection exception.
2076     ///
2077     /// </summary>
2078     bool Nowait { get; }
2079   }
2080   /// <summary>Autogenerated type. AMQP specification method "file.cancel-ok".</summary>
2081   /// <remarks>
2082   ///
2083   ///     This method confirms that the cancellation was completed.
2084   ///
2085   /// </remarks>
2086   public interface IFileCancelOk: IMethod {
2087     // (no documentation)
2088     string ConsumerTag { get; }
2089   }
2090   /// <summary>Autogenerated type. AMQP specification method "file.open".</summary>
2091   /// <remarks>
2092   ///
2093   ///     This method requests permission to start staging a message.  Staging
2094   ///     means sending the message into a temporary area at the recipient end
2095   ///     and then delivering the message by referring to this temporary area.
2096   ///     Staging is how the protocol handles partial file transfers - if a
2097   ///     message is partially staged and the connection breaks, the next time
2098   ///     the sender starts to stage it, it can restart from where it left off.
2099   ///
2100   /// </remarks>
2101   public interface IFileOpen: IMethod {
2102     /// <summary>
2103     ///
2104     ///       This is the staging identifier. This is an arbitrary string chosen
2105     ///       by the sender.  For staging to work correctly the sender must use
2106     ///       the same staging identifier when staging the same message a second
2107     ///       time after recovery from a failure.  A good choice for the staging
2108     ///       identifier would be the SHA1 hash of the message properties data
2109     ///       (including the original filename, revised time, etc.).
2110     ///
2111     /// </summary>
2112     string Identifier { get; }
2113     /// <summary>
2114     ///
2115     ///       The size of the content in octets.  The recipient may use this
2116     ///       information to allocate or check available space in advance, to
2117     ///       avoid "disk full" errors during staging of very large messages.
2118     ///
2119     /// </summary>
2120     ulong ContentSize { get; }
2121   }
2122   /// <summary>Autogenerated type. AMQP specification method "file.open-ok".</summary>
2123   /// <remarks>
2124   ///
2125   ///     This method confirms that the recipient is ready to accept staged
2126   ///     data.  If the message was already partially-staged at a previous
2127   ///     time the recipient will report the number of octets already staged.
2128   ///
2129   /// </remarks>
2130   public interface IFileOpenOk: IMethod {
2131     /// <summary>
2132     ///
2133     ///       The amount of previously-staged content in octets.  For a new
2134     ///       message this will be zero.
2135     ///
2136     /// </summary>
2137     ulong StagedSize { get; }
2138   }
2139   /// <summary>Autogenerated type. AMQP specification method "file.stage".</summary>
2140   /// <remarks>
2141   ///
2142   ///     This method stages the message, sending the message content to the
2143   ///     recipient from the octet offset specified in the Open-Ok method.
2144   ///
2145   /// </remarks>
2146   public interface IFileStage: IMethod {
2147   }
2148   /// <summary>Autogenerated type. AMQP specification method "file.publish".</summary>
2149   /// <remarks>
2150   ///
2151   ///     This method publishes a staged file message to a specific exchange.
2152   ///     The file message will be routed to queues as defined by the exchange
2153   ///     configuration and distributed to any active consumers when the
2154   ///     transaction, if any, is committed.
2155   ///
2156   /// </remarks>
2157   public interface IFilePublish: IMethod {
2158     /// <summary>
2159     ///
2160     ///       The client MUST provide a valid access ticket giving "write"
2161     ///       access rights to the access realm for the exchange.
2162     ///
2163     /// </summary>
2164     ushort Ticket { get; }
2165     /// <summary>
2166     ///
2167     ///       Specifies the name of the exchange to publish to.  The exchange
2168     ///       name can be empty, meaning the default exchange.  If the exchange
2169     ///       name is specified, and that exchange does not exist, the server
2170     ///       will raise a channel exception.
2171     ///
2172     /// </summary>
2173     string Exchange { get; }
2174     /// <summary>
2175     ///
2176     ///       Specifies the routing key for the message.  The routing key is
2177     ///       used for routing messages depending on the exchange configuration.
2178     ///
2179     /// </summary>
2180     string RoutingKey { get; }
2181     /// <summary>
2182     ///
2183     ///       This flag tells the server how to react if the message cannot be
2184     ///       routed to a queue.  If this flag is set, the server will return an
2185     ///       unroutable message with a Return method.  If this flag is zero, the
2186     ///       server silently drops the message.
2187     ///
2188     /// </summary>
2189     bool Mandatory { get; }
2190     /// <summary>
2191     ///
2192     ///       This flag tells the server how to react if the message cannot be
2193     ///       routed to a queue consumer immediately.  If this flag is set, the
2194     ///       server will return an undeliverable message with a Return method.
2195     ///       If this flag is zero, the server will queue the message, but with
2196     ///       no guarantee that it will ever be consumed.
2197     ///
2198     /// </summary>
2199     bool Immediate { get; }
2200     /// <summary>
2201     ///
2202     ///       This is the staging identifier of the message to publish.  The
2203     ///       message must have been staged.  Note that a client can send the
2204     ///       Publish method asynchronously without waiting for staging to
2205     ///       finish.
2206     ///
2207     /// </summary>
2208     string Identifier { get; }
2209   }
2210   /// <summary>Autogenerated type. AMQP specification method "file.return".</summary>
2211   /// <remarks>
2212   ///
2213   ///     This method returns an undeliverable message that was published
2214   ///     with the "immediate" flag set, or an unroutable message published
2215   ///     with the "mandatory" flag set. The reply code and text provide
2216   ///     information about the reason that the message was undeliverable.
2217   ///
2218   /// </remarks>
2219   public interface IFileReturn: IMethod {
2220     // (no documentation)
2221     ushort ReplyCode { get; }
2222     // (no documentation)
2223     string ReplyText { get; }
2224     /// <summary>
2225     ///
2226     ///       Specifies the name of the exchange that the message was
2227     ///       originally published to.
2228     ///
2229     /// </summary>
2230     string Exchange { get; }
2231     /// <summary>
2232     ///
2233     ///       Specifies the routing key name specified when the message was
2234     ///       published.
2235     ///
2236     /// </summary>
2237     string RoutingKey { get; }
2238   }
2239   /// <summary>Autogenerated type. AMQP specification method "file.deliver".</summary>
2240   /// <remarks>
2241   ///
2242   ///     This method delivers a staged file message to the client, via a
2243   ///     consumer. In the asynchronous message delivery model, the client
2244   ///     starts a consumer using the Consume method, then the server
2245   ///     responds with Deliver methods as and when messages arrive for
2246   ///     that consumer.
2247   ///
2248   /// </remarks>
2249   public interface IFileDeliver: IMethod {
2250     // (no documentation)
2251     string ConsumerTag { get; }
2252     // (no documentation)
2253     ulong DeliveryTag { get; }
2254     // (no documentation)
2255     bool Redelivered { get; }
2256     /// <summary>
2257     ///
2258     ///       Specifies the name of the exchange that the message was originally
2259     ///       published to.
2260     ///
2261     /// </summary>
2262     string Exchange { get; }
2263     /// <summary>
2264     ///
2265     ///       Specifies the routing key name specified when the message was
2266     ///       published.
2267     ///
2268     /// </summary>
2269     string RoutingKey { get; }
2270     /// <summary>
2271     ///
2272     ///       This is the staging identifier of the message to deliver.  The
2273     ///       message must have been staged.  Note that a server can send the
2274     ///       Deliver method asynchronously without waiting for staging to
2275     ///       finish.
2276     ///
2277     /// </summary>
2278     string Identifier { get; }
2279   }
2280   /// <summary>Autogenerated type. AMQP specification method "file.ack".</summary>
2281   /// <remarks>
2282   ///
2283   ///     This method acknowledges one or more messages delivered via the
2284   ///     Deliver method.  The client can ask to confirm a single message or
2285   ///     a set of messages up to and including a specific message.
2286   ///
2287   /// </remarks>
2288   public interface IFileAck: IMethod {
2289     // (no documentation)
2290     ulong DeliveryTag { get; }
2291     /// <summary>
2292     ///
2293     ///       If set to 1, the delivery tag is treated as "up to and including",
2294     ///       so that the client can acknowledge multiple messages with a single
2295     ///       method.  If set to zero, the delivery tag refers to a single
2296     ///       message.  If the multiple field is 1, and the delivery tag is zero,
2297     ///       tells the server to acknowledge all outstanding mesages.
2298     ///
2299     /// </summary>
2300     bool Multiple { get; }
2301   }
2302   /// <summary>Autogenerated type. AMQP specification method "file.reject".</summary>
2303   /// <remarks>
2304   ///
2305   ///     This method allows a client to reject a message.  It can be used to
2306   ///     return untreatable messages to their original queue.  Note that file
2307   ///     content is staged before delivery, so the client will not use this
2308   ///     method to interrupt delivery of a large message.
2309   ///
2310   /// </remarks>
2311   public interface IFileReject: IMethod {
2312     // (no documentation)
2313     ulong DeliveryTag { get; }
2314     /// <summary>
2315     ///
2316     ///       If this field is zero, the message will be discarded.  If this bit
2317     ///       is 1, the server will attempt to requeue the message.
2318     ///
2319     /// </summary>
2320     bool Requeue { get; }
2321   }
2322   /// <summary>Autogenerated type. AMQP specification method "stream.qos".</summary>
2323   /// <remarks>
2324   ///
2325   ///     This method requests a specific quality of service.  The QoS can
2326   ///     be specified for the current channel or for all channels on the
2327   ///     connection.  The particular properties and semantics of a qos method
2328   ///     always depend on the content class semantics.  Though the qos method
2329   ///     could in principle apply to both peers, it is currently meaningful
2330   ///     only for the server.
2331   ///
2332   /// </remarks>
2333   public interface IStreamQos: IMethod {
2334     /// <summary>
2335     ///
2336     ///       The client can request that messages be sent in advance so that
2337     ///       when the client finishes processing a message, the following
2338     ///       message is already held locally, rather than needing to be sent
2339     ///       down the channel.  Prefetching gives a performance improvement.
2340     ///       This field specifies the prefetch window size in octets. May be
2341     ///       set to zero, meaning "no specific limit".  Note that other
2342     ///       prefetch limits may still apply.
2343     ///
2344     /// </summary>
2345     uint PrefetchSize { get; }
2346     /// <summary>
2347     ///
2348     ///       Specifies a prefetch window in terms of whole messages.  This
2349     ///       field may be used in combination with the prefetch-size field;
2350     ///       a message will only be sent in advance if both prefetch windows
2351     ///       (and those at the channel and connection level) allow it.
2352     ///
2353     /// </summary>
2354     ushort PrefetchCount { get; }
2355     /// <summary>
2356     ///
2357     ///       Specifies a desired transfer rate in octets per second. This is
2358     ///       usually determined by the application that uses the streaming
2359     ///       data.  A value of zero means "no limit", i.e. as rapidly as
2360     ///       possible.
2361     ///
2362     /// </summary>
2363     uint ConsumeRate { get; }
2364     /// <summary>
2365     ///
2366     ///       By default the QoS settings apply to the current channel only.  If
2367     ///       this field is set, they are applied to the entire connection.
2368     ///
2369     /// </summary>
2370     bool Global { get; }
2371   }
2372   /// <summary>Autogenerated type. AMQP specification method "stream.qos-ok".</summary>
2373   /// <remarks>
2374   ///
2375   ///     This method tells the client that the requested QoS levels could
2376   ///     be handled by the server.  The requested QoS applies to all active
2377   ///     consumers until a new QoS is defined.
2378   ///
2379   /// </remarks>
2380   public interface IStreamQosOk: IMethod {
2381   }
2382   /// <summary>Autogenerated type. AMQP specification method "stream.consume".</summary>
2383   /// <remarks>
2384   ///
2385   ///     This method asks the server to start a "consumer", which is a
2386   ///     transient request for messages from a specific queue. Consumers
2387   ///     last as long as the channel they were created on, or until the
2388   ///     client cancels them.
2389   ///
2390   /// </remarks>
2391   public interface IStreamConsume: IMethod {
2392     /// <summary>
2393     ///
2394     ///       The client MUST provide a valid access ticket giving "read" access
2395     ///       rights to the realm for the queue.
2396     ///
2397     /// </summary>
2398     ushort Ticket { get; }
2399     /// <summary>
2400     ///
2401     ///       Specifies the name of the queue to consume from.  If the queue name
2402     ///       is null, refers to the current queue for the channel, which is the
2403     ///       last declared queue.
2404     ///
2405     /// </summary>
2406     string Queue { get; }
2407     /// <summary>
2408     ///
2409     ///       Specifies the identifier for the consumer. The consumer tag is
2410     ///       local to a connection, so two clients can use the same consumer
2411     ///       tags. If this field is empty the server will generate a unique
2412     ///       tag.
2413     ///
2414     /// </summary>
2415     string ConsumerTag { get; }
2416     // (no documentation)
2417     bool NoLocal { get; }
2418     /// <summary>
2419     ///
2420     ///       Request exclusive consumer access, meaning only this consumer can
2421     ///       access the queue.
2422     ///
2423     /// </summary>
2424     bool Exclusive { get; }
2425     /// <summary>
2426     ///
2427     ///     If set, the server will not respond to the method. The client should
2428     ///     not wait for a reply method.  If the server could not complete the
2429     ///     method it will raise a channel or connection exception.
2430     ///
2431     /// </summary>
2432     bool Nowait { get; }
2433   }
2434   /// <summary>Autogenerated type. AMQP specification method "stream.consume-ok".</summary>
2435   /// <remarks>
2436   ///
2437   ///     This method provides the client with a consumer tag which it may
2438   ///     use in methods that work with the consumer.
2439   ///
2440   /// </remarks>
2441   public interface IStreamConsumeOk: IMethod {
2442     /// <summary>
2443     ///
2444     ///       Holds the consumer tag specified by the client or provided by
2445     ///       the server.
2446     ///
2447     /// </summary>
2448     string ConsumerTag { get; }
2449   }
2450   /// <summary>Autogenerated type. AMQP specification method "stream.cancel".</summary>
2451   /// <remarks>
2452   ///
2453   ///     This method cancels a consumer.  Since message delivery is
2454   ///     asynchronous the client may continue to receive messages for
2455   ///     a short while after canceling a consumer.  It may process or
2456   ///     discard these as appropriate.
2457   ///
2458   /// </remarks>
2459   public interface IStreamCancel: IMethod {
2460     // (no documentation)
2461     string ConsumerTag { get; }
2462     /// <summary>
2463     ///
2464     ///     If set, the server will not respond to the method. The client should
2465     ///     not wait for a reply method.  If the server could not complete the
2466     ///     method it will raise a channel or connection exception.
2467     ///
2468     /// </summary>
2469     bool Nowait { get; }
2470   }
2471   /// <summary>Autogenerated type. AMQP specification method "stream.cancel-ok".</summary>
2472   /// <remarks>
2473   ///
2474   ///     This method confirms that the cancellation was completed.
2475   ///
2476   /// </remarks>
2477   public interface IStreamCancelOk: IMethod {
2478     // (no documentation)
2479     string ConsumerTag { get; }
2480   }
2481   /// <summary>Autogenerated type. AMQP specification method "stream.publish".</summary>
2482   /// <remarks>
2483   ///
2484   ///     This method publishes a message to a specific exchange. The message
2485   ///     will be routed to queues as defined by the exchange configuration
2486   ///     and distributed to any active consumers as appropriate.
2487   ///
2488   /// </remarks>
2489   public interface IStreamPublish: IMethod {
2490     /// <summary>
2491     ///
2492     ///       The client MUST provide a valid access ticket giving "write"
2493     ///       access rights to the access realm for the exchange.
2494     ///
2495     /// </summary>
2496     ushort Ticket { get; }
2497     /// <summary>
2498     ///
2499     ///       Specifies the name of the exchange to publish to.  The exchange
2500     ///       name can be empty, meaning the default exchange.  If the exchange
2501     ///       name is specified, and that exchange does not exist, the server
2502     ///       will raise a channel exception.
2503     ///
2504     /// </summary>
2505     string Exchange { get; }
2506     /// <summary>
2507     ///
2508     ///       Specifies the routing key for the message.  The routing key is
2509     ///       used for routing messages depending on the exchange configuration.
2510     ///
2511     /// </summary>
2512     string RoutingKey { get; }
2513     /// <summary>
2514     ///
2515     ///       This flag tells the server how to react if the message cannot be
2516     ///       routed to a queue.  If this flag is set, the server will return an
2517     ///       unroutable message with a Return method.  If this flag is zero, the
2518     ///       server silently drops the message.
2519     ///
2520     /// </summary>
2521     bool Mandatory { get; }
2522     /// <summary>
2523     ///
2524     ///       This flag tells the server how to react if the message cannot be
2525     ///       routed to a queue consumer immediately.  If this flag is set, the
2526     ///       server will return an undeliverable message with a Return method.
2527     ///       If this flag is zero, the server will queue the message, but with
2528     ///       no guarantee that it will ever be consumed.
2529     ///
2530     /// </summary>
2531     bool Immediate { get; }
2532   }
2533   /// <summary>Autogenerated type. AMQP specification method "stream.return".</summary>
2534   /// <remarks>
2535   ///
2536   ///     This method returns an undeliverable message that was published
2537   ///     with the "immediate" flag set, or an unroutable message published
2538   ///     with the "mandatory" flag set. The reply code and text provide
2539   ///     information about the reason that the message was undeliverable.
2540   ///
2541   /// </remarks>
2542   public interface IStreamReturn: IMethod {
2543     // (no documentation)
2544     ushort ReplyCode { get; }
2545     // (no documentation)
2546     string ReplyText { get; }
2547     /// <summary>
2548     ///
2549     ///       Specifies the name of the exchange that the message was
2550     ///       originally published to.
2551     ///
2552     /// </summary>
2553     string Exchange { get; }
2554     /// <summary>
2555     ///
2556     ///       Specifies the routing key name specified when the message was
2557     ///       published.
2558     ///
2559     /// </summary>
2560     string RoutingKey { get; }
2561   }
2562   /// <summary>Autogenerated type. AMQP specification method "stream.deliver".</summary>
2563   /// <remarks>
2564   ///
2565   ///     This method delivers a message to the client, via a consumer.  In
2566   ///     the asynchronous message delivery model, the client starts a
2567   ///     consumer using the Consume method, then the server responds with
2568   ///     Deliver methods as and when messages arrive for that consumer.
2569   ///
2570   /// </remarks>
2571   public interface IStreamDeliver: IMethod {
2572     // (no documentation)
2573     string ConsumerTag { get; }
2574     // (no documentation)
2575     ulong DeliveryTag { get; }
2576     /// <summary>
2577     ///
2578     ///       Specifies the name of the exchange that the message was originally
2579     ///       published to.
2580     ///
2581     /// </summary>
2582     string Exchange { get; }
2583     /// <summary>
2584     ///
2585     ///       Specifies the name of the queue that the message came from. Note
2586     ///       that a single channel can start many consumers on different
2587     ///       queues.
2588     ///
2589     /// </summary>
2590     string Queue { get; }
2591   }
2592   /// <summary>Autogenerated type. AMQP specification method "tx.select".</summary>
2593   /// <remarks>
2594   ///
2595   ///     This method sets the channel to use standard transactions.  The
2596   ///     client must use this method at least once on a channel before
2597   ///     using the Commit or Rollback methods.
2598   ///
2599   /// </remarks>
2600   public interface ITxSelect: IMethod {
2601   }
2602   /// <summary>Autogenerated type. AMQP specification method "tx.select-ok".</summary>
2603   /// <remarks>
2604   ///
2605   ///     This method confirms to the client that the channel was successfully
2606   ///     set to use standard transactions.
2607   ///
2608   /// </remarks>
2609   public interface ITxSelectOk: IMethod {
2610   }
2611   /// <summary>Autogenerated type. AMQP specification method "tx.commit".</summary>
2612   /// <remarks>
2613   ///
2614   ///     This method commits all messages published and acknowledged in
2615   ///     the current transaction.  A new transaction starts immediately
2616   ///     after a commit.
2617   ///
2618   /// </remarks>
2619   public interface ITxCommit: IMethod {
2620   }
2621   /// <summary>Autogenerated type. AMQP specification method "tx.commit-ok".</summary>
2622   /// <remarks>
2623   ///
2624   ///     This method confirms to the client that the commit succeeded.
2625   ///     Note that if a commit fails, the server raises a channel exception.
2626   ///
2627   /// </remarks>
2628   public interface ITxCommitOk: IMethod {
2629   }
2630   /// <summary>Autogenerated type. AMQP specification method "tx.rollback".</summary>
2631   /// <remarks>
2632   ///
2633   ///     This method abandons all messages published and acknowledged in
2634   ///     the current transaction.  A new transaction starts immediately
2635   ///     after a rollback.
2636   ///
2637   /// </remarks>
2638   public interface ITxRollback: IMethod {
2639   }
2640   /// <summary>Autogenerated type. AMQP specification method "tx.rollback-ok".</summary>
2641   /// <remarks>
2642   ///
2643   ///     This method confirms to the client that the rollback succeeded.
2644   ///     Note that if an rollback fails, the server raises a channel exception.
2645   ///
2646   /// </remarks>
2647   public interface ITxRollbackOk: IMethod {
2648   }
2649   /// <summary>Autogenerated type. AMQP specification method "dtx.select".</summary>
2650   /// <remarks>
2651   ///
2652   ///     This method sets the channel to use distributed transactions.  The
2653   ///     client must use this method at least once on a channel before
2654   ///     using the Start method.
2655   ///
2656   /// </remarks>
2657   public interface IDtxSelect: IMethod {
2658   }
2659   /// <summary>Autogenerated type. AMQP specification method "dtx.select-ok".</summary>
2660   /// <remarks>
2661   ///
2662   ///     This method confirms to the client that the channel was successfully
2663   ///     set to use distributed transactions.
2664   ///
2665   /// </remarks>
2666   public interface IDtxSelectOk: IMethod {
2667   }
2668   /// <summary>Autogenerated type. AMQP specification method "dtx.start".</summary>
2669   /// <remarks>
2670   ///
2671   ///     This method starts a new distributed transaction.  This must be
2672   ///     the first method on a new channel that uses the distributed
2673   ///     transaction mode, before any methods that publish or consume
2674   ///     messages.
2675   ///
2676   /// </remarks>
2677   public interface IDtxStart: IMethod {
2678     /// <summary>
2679     ///
2680     ///       The distributed transaction key. This identifies the transaction
2681     ///       so that the AMQP server can coordinate with the distributed
2682     ///       transaction coordinator.
2683     ///
2684     /// </summary>
2685     string DtxIdentifier { get; }
2686   }
2687   /// <summary>Autogenerated type. AMQP specification method "dtx.start-ok".</summary>
2688   /// <remarks>
2689   ///
2690   ///     This method confirms to the client that the transaction started.
2691   ///     Note that if a start fails, the server raises a channel exception.
2692   ///
2693   /// </remarks>
2694   public interface IDtxStartOk: IMethod {
2695   }
2696   /// <summary>Autogenerated type. AMQP specification method "tunnel.request".</summary>
2697   /// <remarks>
2698   ///
2699   ///     This method tunnels a block of binary data, which can be an
2700   ///     encoded AMQP method or other data.  The binary data is sent
2701   ///     as the content for the Tunnel.Request method.
2702   ///
2703   /// </remarks>
2704   public interface ITunnelRequest: IMethod {
2705     /// <summary>
2706     ///
2707     ///     This field table holds arbitrary meta-data that the sender needs
2708     ///     to pass to the recipient.
2709     ///
2710     /// </summary>
2711     System.Collections.IDictionary MetaData { get; }
2712   }
2713   /// <summary>Autogenerated type. AMQP specification method "test.integer".</summary>
2714   /// <remarks>
2715   ///
2716   ///     This method tests the peer's capability to correctly marshal integer
2717   ///     data.
2718   ///
2719   /// </remarks>
2720   public interface ITestInteger: IMethod {
2721     /// <summary>
2722     ///
2723     ///       An octet integer test value.
2724     ///
2725     /// </summary>
2726     byte Integer1 { get; }
2727     /// <summary>
2728     ///
2729     ///       A short integer test value.
2730     ///
2731     /// </summary>
2732     ushort Integer2 { get; }
2733     /// <summary>
2734     ///
2735     ///       A long integer test value.
2736     ///
2737     /// </summary>
2738     uint Integer3 { get; }
2739     /// <summary>
2740     ///
2741     ///       A long long integer test value.
2742     ///
2743     /// </summary>
2744     ulong Integer4 { get; }
2745     /// <summary>
2746     ///
2747     ///       The client must execute this operation on the provided integer
2748     ///       test fields and return the result.
2749     ///
2750     /// </summary>
2751     byte Operation { get; }
2752   }
2753   /// <summary>Autogenerated type. AMQP specification method "test.integer-ok".</summary>
2754   /// <remarks>
2755   ///
2756   ///     This method reports the result of an Integer method.
2757   ///
2758   /// </remarks>
2759   public interface ITestIntegerOk: IMethod {
2760     /// <summary>
2761     ///
2762     ///       The result of the tested operation.
2763     ///
2764     /// </summary>
2765     ulong Result { get; }
2766   }
2767   /// <summary>Autogenerated type. AMQP specification method "test.string".</summary>
2768   /// <remarks>
2769   ///
2770   ///     This method tests the peer's capability to correctly marshal string
2771   ///     data.
2772   ///
2773   /// </remarks>
2774   public interface ITestString: IMethod {
2775     /// <summary>
2776     ///
2777     ///       An short string test value.
2778     ///
2779     /// </summary>
2780     string String1 { get; }
2781     /// <summary>
2782     ///
2783     ///       A long string test value.
2784     ///
2785     /// </summary>
2786     byte[] String2 { get; }
2787     /// <summary>
2788     ///
2789     ///       The client must execute this operation on the provided string
2790     ///       test fields and return the result.
2791     ///
2792     /// </summary>
2793     byte Operation { get; }
2794   }
2795   /// <summary>Autogenerated type. AMQP specification method "test.string-ok".</summary>
2796   /// <remarks>
2797   ///
2798   ///     This method reports the result of a String method.
2799   ///
2800   /// </remarks>
2801   public interface ITestStringOk: IMethod {
2802     /// <summary>
2803     ///
2804     ///       The result of the tested operation.
2805     ///
2806     /// </summary>
2807     byte[] Result { get; }
2808   }
2809   /// <summary>Autogenerated type. AMQP specification method "test.table".</summary>
2810   /// <remarks>
2811   ///
2812   ///     This method tests the peer's capability to correctly marshal field
2813   ///     table data.
2814   ///
2815   /// </remarks>
2816   public interface ITestTable: IMethod {
2817     /// <summary>
2818     ///
2819     ///       A field table of test values.
2820     ///
2821     /// </summary>
2822     System.Collections.IDictionary Table { get; }
2823     /// <summary>
2824     ///
2825     ///       The client must execute this operation on the provided field
2826     ///       table integer values and return the result.
2827     ///
2828     /// </summary>
2829     byte IntegerOp { get; }
2830     /// <summary>
2831     ///
2832     ///       The client must execute this operation on the provided field
2833     ///       table string values and return the result.
2834     ///
2835     /// </summary>
2836     byte StringOp { get; }
2837   }
2838   /// <summary>Autogenerated type. AMQP specification method "test.table-ok".</summary>
2839   /// <remarks>
2840   ///
2841   ///     This method reports the result of a Table method.
2842   ///
2843   /// </remarks>
2844   public interface ITestTableOk: IMethod {
2845     /// <summary>
2846     ///
2847     ///       The result of the tested integer operation.
2848     ///
2849     /// </summary>
2850     ulong IntegerResult { get; }
2851     /// <summary>
2852     ///
2853     ///       The result of the tested string operation.
2854     ///
2855     /// </summary>
2856     byte[] StringResult { get; }
2857   }
2858   /// <summary>Autogenerated type. AMQP specification method "test.content".</summary>
2859   /// <remarks>
2860   ///
2861   ///     This method tests the peer's capability to correctly marshal content.
2862   ///
2863   /// </remarks>
2864   public interface ITestContent: IMethod {
2865   }
2866   /// <summary>Autogenerated type. AMQP specification method "test.content-ok".</summary>
2867   /// <remarks>
2868   ///
2869   ///     This method reports the result of a Content method.  It contains the
2870   ///     content checksum and echoes the original content as provided.
2871   ///
2872   /// </remarks>
2873   public interface ITestContentOk: IMethod {
2874     /// <summary>
2875     ///
2876     ///       The 32-bit checksum of the content, calculated by adding the
2877     ///       content into a 32-bit accumulator.
2878     ///
2879     /// </summary>
2880     uint ContentChecksum { get; }
2881   }
2882   /// <summary>Autogenerated type. AMQP specification content header properties for content class "basic"</summary>
2883   /// <remarks>
2884   ///
2885   ///   The Basic class provides methods that support an industry-standard
2886   ///   messaging model.
2887   ///
2888   /// </remarks>
2889   public class BasicProperties: RabbitMQ.Client.Impl.BasicProperties {
2890     private string m_contentType;
2891     private string m_contentEncoding;
2892     private System.Collections.IDictionary m_headers;
2893     private byte m_deliveryMode;
2894     private byte m_priority;
2895     private string m_correlationId;
2896     private string m_replyTo;
2897     private string m_expiration;
2898     private string m_messageId;
2899     private AmqpTimestamp m_timestamp;
2900     private string m_type;
2901     private string m_userId;
2902     private string m_appId;
2903     private string m_clusterId;
2904
2905     private bool contentType_present = false;
2906     private bool contentEncoding_present = false;
2907     private bool headers_present = false;
2908     private bool deliveryMode_present = false;
2909     private bool priority_present = false;
2910     private bool correlationId_present = false;
2911     private bool replyTo_present = false;
2912     private bool expiration_present = false;
2913     private bool messageId_present = false;
2914     private bool timestamp_present = false;
2915     private bool type_present = false;
2916     private bool userId_present = false;
2917     private bool appId_present = false;
2918     private bool clusterId_present = false;
2919
2920     // (no documentation)
2921     public override string ContentType {
2922       get {
2923         return m_contentType;
2924       }
2925       set {
2926         contentType_present = true;
2927         m_contentType = value;
2928       }
2929     }
2930     // (no documentation)
2931     public override string ContentEncoding {
2932       get {
2933         return m_contentEncoding;
2934       }
2935       set {
2936         contentEncoding_present = true;
2937         m_contentEncoding = value;
2938       }
2939     }
2940     // (no documentation)
2941     public override System.Collections.IDictionary Headers {
2942       get {
2943         return m_headers;
2944       }
2945       set {
2946         headers_present = true;
2947         m_headers = value;
2948       }
2949     }
2950     // (no documentation)
2951     public override byte DeliveryMode {
2952       get {
2953         return m_deliveryMode;
2954       }
2955       set {
2956         deliveryMode_present = true;
2957         m_deliveryMode = value;
2958       }
2959     }
2960     // (no documentation)
2961     public override byte Priority {
2962       get {
2963         return m_priority;
2964       }
2965       set {
2966         priority_present = true;
2967         m_priority = value;
2968       }
2969     }
2970     // (no documentation)
2971     public override string CorrelationId {
2972       get {
2973         return m_correlationId;
2974       }
2975       set {
2976         correlationId_present = true;
2977         m_correlationId = value;
2978       }
2979     }
2980     // (no documentation)
2981     public override string ReplyTo {
2982       get {
2983         return m_replyTo;
2984       }
2985       set {
2986         replyTo_present = true;
2987         m_replyTo = value;
2988       }
2989     }
2990     // (no documentation)
2991     public override string Expiration {
2992       get {
2993         return m_expiration;
2994       }
2995       set {
2996         expiration_present = true;
2997         m_expiration = value;
2998       }
2999     }
3000     // (no documentation)
3001     public override string MessageId {
3002       get {
3003         return m_messageId;
3004       }
3005       set {
3006         messageId_present = true;
3007         m_messageId = value;
3008       }
3009     }
3010     // (no documentation)
3011     public override AmqpTimestamp Timestamp {
3012       get {
3013         return m_timestamp;
3014       }
3015       set {
3016         timestamp_present = true;
3017         m_timestamp = value;
3018       }
3019     }
3020     // (no documentation)
3021     public override string Type {
3022       get {
3023         return m_type;
3024       }
3025       set {
3026         type_present = true;
3027         m_type = value;
3028       }
3029     }
3030     // (no documentation)
3031     public override string UserId {
3032       get {
3033         return m_userId;
3034       }
3035       set {
3036         userId_present = true;
3037         m_userId = value;
3038       }
3039     }
3040     // (no documentation)
3041     public override string AppId {
3042       get {
3043         return m_appId;
3044       }
3045       set {
3046         appId_present = true;
3047         m_appId = value;
3048       }
3049     }
3050     // (no documentation)
3051     public override string ClusterId {
3052       get {
3053         return m_clusterId;
3054       }
3055       set {
3056         clusterId_present = true;
3057         m_clusterId = value;
3058       }
3059     }
3060
3061     public override void ClearContentType() { contentType_present = false; }
3062     public override void ClearContentEncoding() { contentEncoding_present = false; }
3063     public override void ClearHeaders() { headers_present = false; }
3064     public override void ClearDeliveryMode() { deliveryMode_present = false; }
3065     public override void ClearPriority() { priority_present = false; }
3066     public override void ClearCorrelationId() { correlationId_present = false; }
3067     public override void ClearReplyTo() { replyTo_present = false; }
3068     public override void ClearExpiration() { expiration_present = false; }
3069     public override void ClearMessageId() { messageId_present = false; }
3070     public override void ClearTimestamp() { timestamp_present = false; }
3071     public override void ClearType() { type_present = false; }
3072     public override void ClearUserId() { userId_present = false; }
3073     public override void ClearAppId() { appId_present = false; }
3074     public override void ClearClusterId() { clusterId_present = false; }
3075
3076     public BasicProperties() {}
3077     public override int ProtocolClassId { get { return 60; } }
3078     public override string ProtocolClassName { get { return "basic"; } }
3079
3080     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
3081       contentType_present = reader.ReadPresence();
3082       contentEncoding_present = reader.ReadPresence();
3083       headers_present = reader.ReadPresence();
3084       deliveryMode_present = reader.ReadPresence();
3085       priority_present = reader.ReadPresence();
3086       correlationId_present = reader.ReadPresence();
3087       replyTo_present = reader.ReadPresence();
3088       expiration_present = reader.ReadPresence();
3089       messageId_present = reader.ReadPresence();
3090       timestamp_present = reader.ReadPresence();
3091       type_present = reader.ReadPresence();
3092       userId_present = reader.ReadPresence();
3093       appId_present = reader.ReadPresence();
3094       clusterId_present = reader.ReadPresence();
3095       reader.FinishPresence();
3096       if (contentType_present) { m_contentType = reader.ReadShortstr(); }
3097       if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
3098       if (headers_present) { m_headers = reader.ReadTable(); }
3099       if (deliveryMode_present) { m_deliveryMode = reader.ReadOctet(); }
3100       if (priority_present) { m_priority = reader.ReadOctet(); }
3101       if (correlationId_present) { m_correlationId = reader.ReadShortstr(); }
3102       if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
3103       if (expiration_present) { m_expiration = reader.ReadShortstr(); }
3104       if (messageId_present) { m_messageId = reader.ReadShortstr(); }
3105       if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
3106       if (type_present) { m_type = reader.ReadShortstr(); }
3107       if (userId_present) { m_userId = reader.ReadShortstr(); }
3108       if (appId_present) { m_appId = reader.ReadShortstr(); }
3109       if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
3110     }
3111
3112     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
3113       writer.WritePresence(contentType_present);
3114       writer.WritePresence(contentEncoding_present);
3115       writer.WritePresence(headers_present);
3116       writer.WritePresence(deliveryMode_present);
3117       writer.WritePresence(priority_present);
3118       writer.WritePresence(correlationId_present);
3119       writer.WritePresence(replyTo_present);
3120       writer.WritePresence(expiration_present);
3121       writer.WritePresence(messageId_present);
3122       writer.WritePresence(timestamp_present);
3123       writer.WritePresence(type_present);
3124       writer.WritePresence(userId_present);
3125       writer.WritePresence(appId_present);
3126       writer.WritePresence(clusterId_present);
3127       writer.FinishPresence();
3128       if (contentType_present) { writer.WriteShortstr(m_contentType); }
3129       if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
3130       if (headers_present) { writer.WriteTable(m_headers); }
3131       if (deliveryMode_present) { writer.WriteOctet(m_deliveryMode); }
3132       if (priority_present) { writer.WriteOctet(m_priority); }
3133       if (correlationId_present) { writer.WriteShortstr(m_correlationId); }
3134       if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
3135       if (expiration_present) { writer.WriteShortstr(m_expiration); }
3136       if (messageId_present) { writer.WriteShortstr(m_messageId); }
3137       if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
3138       if (type_present) { writer.WriteShortstr(m_type); }
3139       if (userId_present) { writer.WriteShortstr(m_userId); }
3140       if (appId_present) { writer.WriteShortstr(m_appId); }
3141       if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
3142     }
3143
3144     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
3145       sb.Append("(");
3146       sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
3147       sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
3148       sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
3149       sb.Append("delivery mode="); sb.Append(deliveryMode_present ? m_deliveryMode.ToString() : "_"); sb.Append(", ");
3150       sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
3151       sb.Append("correlation id="); sb.Append(correlationId_present ? (m_correlationId == null ? "(null)" : m_correlationId.ToString()) : "_"); sb.Append(", ");
3152       sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
3153       sb.Append("expiration="); sb.Append(expiration_present ? (m_expiration == null ? "(null)" : m_expiration.ToString()) : "_"); sb.Append(", ");
3154       sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
3155       sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
3156       sb.Append("type="); sb.Append(type_present ? (m_type == null ? "(null)" : m_type.ToString()) : "_"); sb.Append(", ");
3157       sb.Append("user id="); sb.Append(userId_present ? (m_userId == null ? "(null)" : m_userId.ToString()) : "_"); sb.Append(", ");
3158       sb.Append("app id="); sb.Append(appId_present ? (m_appId == null ? "(null)" : m_appId.ToString()) : "_"); sb.Append(", ");
3159       sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
3160       sb.Append(")");
3161     }
3162   }
3163   /// <summary>Autogenerated type. AMQP specification content header properties for content class "file"</summary>
3164   /// <remarks>
3165   ///
3166   ///   The file class provides methods that support reliable file transfer.
3167   ///   File messages have a specific set of properties that are required for
3168   ///   interoperability with file transfer applications. File messages and
3169   ///   acknowledgements are subject to channel transactions.  Note that the
3170   ///   file class does not provide message browsing methods; these are not
3171   ///   compatible with the staging model.  Applications that need browsable
3172   ///   file transfer should use Basic content and the Basic class.
3173   ///
3174   /// </remarks>
3175   public class FileProperties: RabbitMQ.Client.Impl.FileProperties {
3176     private string m_contentType;
3177     private string m_contentEncoding;
3178     private System.Collections.IDictionary m_headers;
3179     private byte m_priority;
3180     private string m_replyTo;
3181     private string m_messageId;
3182     private string m_filename;
3183     private AmqpTimestamp m_timestamp;
3184     private string m_clusterId;
3185
3186     private bool contentType_present = false;
3187     private bool contentEncoding_present = false;
3188     private bool headers_present = false;
3189     private bool priority_present = false;
3190     private bool replyTo_present = false;
3191     private bool messageId_present = false;
3192     private bool filename_present = false;
3193     private bool timestamp_present = false;
3194     private bool clusterId_present = false;
3195
3196     // (no documentation)
3197     public override string ContentType {
3198       get {
3199         return m_contentType;
3200       }
3201       set {
3202         contentType_present = true;
3203         m_contentType = value;
3204       }
3205     }
3206     // (no documentation)
3207     public override string ContentEncoding {
3208       get {
3209         return m_contentEncoding;
3210       }
3211       set {
3212         contentEncoding_present = true;
3213         m_contentEncoding = value;
3214       }
3215     }
3216     // (no documentation)
3217     public override System.Collections.IDictionary Headers {
3218       get {
3219         return m_headers;
3220       }
3221       set {
3222         headers_present = true;
3223         m_headers = value;
3224       }
3225     }
3226     // (no documentation)
3227     public override byte Priority {
3228       get {
3229         return m_priority;
3230       }
3231       set {
3232         priority_present = true;
3233         m_priority = value;
3234       }
3235     }
3236     // (no documentation)
3237     public override string ReplyTo {
3238       get {
3239         return m_replyTo;
3240       }
3241       set {
3242         replyTo_present = true;
3243         m_replyTo = value;
3244       }
3245     }
3246     // (no documentation)
3247     public override string MessageId {
3248       get {
3249         return m_messageId;
3250       }
3251       set {
3252         messageId_present = true;
3253         m_messageId = value;
3254       }
3255     }
3256     // (no documentation)
3257     public override string Filename {
3258       get {
3259         return m_filename;
3260       }
3261       set {
3262         filename_present = true;
3263         m_filename = value;
3264       }
3265     }
3266     // (no documentation)
3267     public override AmqpTimestamp Timestamp {
3268       get {
3269         return m_timestamp;
3270       }
3271       set {
3272         timestamp_present = true;
3273         m_timestamp = value;
3274       }
3275     }
3276     // (no documentation)
3277     public override string ClusterId {
3278       get {
3279         return m_clusterId;
3280       }
3281       set {
3282         clusterId_present = true;
3283         m_clusterId = value;
3284       }
3285     }
3286
3287     public override void ClearContentType() { contentType_present = false; }
3288     public override void ClearContentEncoding() { contentEncoding_present = false; }
3289     public override void ClearHeaders() { headers_present = false; }
3290     public override void ClearPriority() { priority_present = false; }
3291     public override void ClearReplyTo() { replyTo_present = false; }
3292     public override void ClearMessageId() { messageId_present = false; }
3293     public override void ClearFilename() { filename_present = false; }
3294     public override void ClearTimestamp() { timestamp_present = false; }
3295     public override void ClearClusterId() { clusterId_present = false; }
3296
3297     public FileProperties() {}
3298     public override int ProtocolClassId { get { return 70; } }
3299     public override string ProtocolClassName { get { return "file"; } }
3300
3301     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
3302       contentType_present = reader.ReadPresence();
3303       contentEncoding_present = reader.ReadPresence();
3304       headers_present = reader.ReadPresence();
3305       priority_present = reader.ReadPresence();
3306       replyTo_present = reader.ReadPresence();
3307       messageId_present = reader.ReadPresence();
3308       filename_present = reader.ReadPresence();
3309       timestamp_present = reader.ReadPresence();
3310       clusterId_present = reader.ReadPresence();
3311       reader.FinishPresence();
3312       if (contentType_present) { m_contentType = reader.ReadShortstr(); }
3313       if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
3314       if (headers_present) { m_headers = reader.ReadTable(); }
3315       if (priority_present) { m_priority = reader.ReadOctet(); }
3316       if (replyTo_present) { m_replyTo = reader.ReadShortstr(); }
3317       if (messageId_present) { m_messageId = reader.ReadShortstr(); }
3318       if (filename_present) { m_filename = reader.ReadShortstr(); }
3319       if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
3320       if (clusterId_present) { m_clusterId = reader.ReadShortstr(); }
3321     }
3322
3323     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
3324       writer.WritePresence(contentType_present);
3325       writer.WritePresence(contentEncoding_present);
3326       writer.WritePresence(headers_present);
3327       writer.WritePresence(priority_present);
3328       writer.WritePresence(replyTo_present);
3329       writer.WritePresence(messageId_present);
3330       writer.WritePresence(filename_present);
3331       writer.WritePresence(timestamp_present);
3332       writer.WritePresence(clusterId_present);
3333       writer.FinishPresence();
3334       if (contentType_present) { writer.WriteShortstr(m_contentType); }
3335       if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
3336       if (headers_present) { writer.WriteTable(m_headers); }
3337       if (priority_present) { writer.WriteOctet(m_priority); }
3338       if (replyTo_present) { writer.WriteShortstr(m_replyTo); }
3339       if (messageId_present) { writer.WriteShortstr(m_messageId); }
3340       if (filename_present) { writer.WriteShortstr(m_filename); }
3341       if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
3342       if (clusterId_present) { writer.WriteShortstr(m_clusterId); }
3343     }
3344
3345     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
3346       sb.Append("(");
3347       sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
3348       sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
3349       sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
3350       sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
3351       sb.Append("reply to="); sb.Append(replyTo_present ? (m_replyTo == null ? "(null)" : m_replyTo.ToString()) : "_"); sb.Append(", ");
3352       sb.Append("message id="); sb.Append(messageId_present ? (m_messageId == null ? "(null)" : m_messageId.ToString()) : "_"); sb.Append(", ");
3353       sb.Append("filename="); sb.Append(filename_present ? (m_filename == null ? "(null)" : m_filename.ToString()) : "_"); sb.Append(", ");
3354       sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_"); sb.Append(", ");
3355       sb.Append("cluster id="); sb.Append(clusterId_present ? (m_clusterId == null ? "(null)" : m_clusterId.ToString()) : "_");
3356       sb.Append(")");
3357     }
3358   }
3359   /// <summary>Autogenerated type. AMQP specification content header properties for content class "stream"</summary>
3360   /// <remarks>
3361   ///
3362   ///   The stream class provides methods that support multimedia streaming.
3363   ///   The stream class uses the following semantics: one message is one
3364   ///   packet of data; delivery is unacknowleged and unreliable; the consumer
3365   ///   can specify quality of service parameters that the server can try to
3366   ///   adhere to; lower-priority messages may be discarded in favour of high
3367   ///   priority messages.
3368   ///
3369   /// </remarks>
3370   public class StreamProperties: RabbitMQ.Client.Impl.StreamProperties {
3371     private string m_contentType;
3372     private string m_contentEncoding;
3373     private System.Collections.IDictionary m_headers;
3374     private byte m_priority;
3375     private AmqpTimestamp m_timestamp;
3376
3377     private bool contentType_present = false;
3378     private bool contentEncoding_present = false;
3379     private bool headers_present = false;
3380     private bool priority_present = false;
3381     private bool timestamp_present = false;
3382
3383     // (no documentation)
3384     public override string ContentType {
3385       get {
3386         return m_contentType;
3387       }
3388       set {
3389         contentType_present = true;
3390         m_contentType = value;
3391       }
3392     }
3393     // (no documentation)
3394     public override string ContentEncoding {
3395       get {
3396         return m_contentEncoding;
3397       }
3398       set {
3399         contentEncoding_present = true;
3400         m_contentEncoding = value;
3401       }
3402     }
3403     // (no documentation)
3404     public override System.Collections.IDictionary Headers {
3405       get {
3406         return m_headers;
3407       }
3408       set {
3409         headers_present = true;
3410         m_headers = value;
3411       }
3412     }
3413     // (no documentation)
3414     public override byte Priority {
3415       get {
3416         return m_priority;
3417       }
3418       set {
3419         priority_present = true;
3420         m_priority = value;
3421       }
3422     }
3423     // (no documentation)
3424     public override AmqpTimestamp Timestamp {
3425       get {
3426         return m_timestamp;
3427       }
3428       set {
3429         timestamp_present = true;
3430         m_timestamp = value;
3431       }
3432     }
3433
3434     public override void ClearContentType() { contentType_present = false; }
3435     public override void ClearContentEncoding() { contentEncoding_present = false; }
3436     public override void ClearHeaders() { headers_present = false; }
3437     public override void ClearPriority() { priority_present = false; }
3438     public override void ClearTimestamp() { timestamp_present = false; }
3439
3440     public StreamProperties() {}
3441     public override int ProtocolClassId { get { return 80; } }
3442     public override string ProtocolClassName { get { return "stream"; } }
3443
3444     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
3445       contentType_present = reader.ReadPresence();
3446       contentEncoding_present = reader.ReadPresence();
3447       headers_present = reader.ReadPresence();
3448       priority_present = reader.ReadPresence();
3449       timestamp_present = reader.ReadPresence();
3450       reader.FinishPresence();
3451       if (contentType_present) { m_contentType = reader.ReadShortstr(); }
3452       if (contentEncoding_present) { m_contentEncoding = reader.ReadShortstr(); }
3453       if (headers_present) { m_headers = reader.ReadTable(); }
3454       if (priority_present) { m_priority = reader.ReadOctet(); }
3455       if (timestamp_present) { m_timestamp = reader.ReadTimestamp(); }
3456     }
3457
3458     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
3459       writer.WritePresence(contentType_present);
3460       writer.WritePresence(contentEncoding_present);
3461       writer.WritePresence(headers_present);
3462       writer.WritePresence(priority_present);
3463       writer.WritePresence(timestamp_present);
3464       writer.FinishPresence();
3465       if (contentType_present) { writer.WriteShortstr(m_contentType); }
3466       if (contentEncoding_present) { writer.WriteShortstr(m_contentEncoding); }
3467       if (headers_present) { writer.WriteTable(m_headers); }
3468       if (priority_present) { writer.WriteOctet(m_priority); }
3469       if (timestamp_present) { writer.WriteTimestamp(m_timestamp); }
3470     }
3471
3472     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
3473       sb.Append("(");
3474       sb.Append("content type="); sb.Append(contentType_present ? (m_contentType == null ? "(null)" : m_contentType.ToString()) : "_"); sb.Append(", ");
3475       sb.Append("content encoding="); sb.Append(contentEncoding_present ? (m_contentEncoding == null ? "(null)" : m_contentEncoding.ToString()) : "_"); sb.Append(", ");
3476       sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
3477       sb.Append("priority="); sb.Append(priority_present ? m_priority.ToString() : "_"); sb.Append(", ");
3478       sb.Append("timestamp="); sb.Append(timestamp_present ? m_timestamp.ToString() : "_");
3479       sb.Append(")");
3480     }
3481   }
3482   /// <summary>Autogenerated type. AMQP specification content header properties for content class "tunnel"</summary>
3483   /// <remarks>
3484   ///
3485   ///   The tunnel methods are used to send blocks of binary data - which
3486   ///   can be serialised AMQP methods or other protocol frames - between
3487   ///   AMQP peers.
3488   ///
3489   /// </remarks>
3490   public class TunnelProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
3491     private System.Collections.IDictionary m_headers;
3492     private string m_proxyName;
3493     private string m_dataName;
3494     private byte m_durable;
3495     private byte m_broadcast;
3496
3497     private bool headers_present = false;
3498     private bool proxyName_present = false;
3499     private bool dataName_present = false;
3500     private bool durable_present = false;
3501     private bool broadcast_present = false;
3502
3503     // (no documentation)
3504     public System.Collections.IDictionary Headers {
3505       get {
3506         return m_headers;
3507       }
3508       set {
3509         headers_present = true;
3510         m_headers = value;
3511       }
3512     }
3513     // (no documentation)
3514     public string ProxyName {
3515       get {
3516         return m_proxyName;
3517       }
3518       set {
3519         proxyName_present = true;
3520         m_proxyName = value;
3521       }
3522     }
3523     // (no documentation)
3524     public string DataName {
3525       get {
3526         return m_dataName;
3527       }
3528       set {
3529         dataName_present = true;
3530         m_dataName = value;
3531       }
3532     }
3533     // (no documentation)
3534     public byte Durable {
3535       get {
3536         return m_durable;
3537       }
3538       set {
3539         durable_present = true;
3540         m_durable = value;
3541       }
3542     }
3543     // (no documentation)
3544     public byte Broadcast {
3545       get {
3546         return m_broadcast;
3547       }
3548       set {
3549         broadcast_present = true;
3550         m_broadcast = value;
3551       }
3552     }
3553
3554     public void ClearHeaders() { headers_present = false; }
3555     public void ClearProxyName() { proxyName_present = false; }
3556     public void ClearDataName() { dataName_present = false; }
3557     public void ClearDurable() { durable_present = false; }
3558     public void ClearBroadcast() { broadcast_present = false; }
3559
3560     public TunnelProperties() {}
3561     public override int ProtocolClassId { get { return 110; } }
3562     public override string ProtocolClassName { get { return "tunnel"; } }
3563
3564     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
3565       headers_present = reader.ReadPresence();
3566       proxyName_present = reader.ReadPresence();
3567       dataName_present = reader.ReadPresence();
3568       durable_present = reader.ReadPresence();
3569       broadcast_present = reader.ReadPresence();
3570       reader.FinishPresence();
3571       if (headers_present) { m_headers = reader.ReadTable(); }
3572       if (proxyName_present) { m_proxyName = reader.ReadShortstr(); }
3573       if (dataName_present) { m_dataName = reader.ReadShortstr(); }
3574       if (durable_present) { m_durable = reader.ReadOctet(); }
3575       if (broadcast_present) { m_broadcast = reader.ReadOctet(); }
3576     }
3577
3578     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
3579       writer.WritePresence(headers_present);
3580       writer.WritePresence(proxyName_present);
3581       writer.WritePresence(dataName_present);
3582       writer.WritePresence(durable_present);
3583       writer.WritePresence(broadcast_present);
3584       writer.FinishPresence();
3585       if (headers_present) { writer.WriteTable(m_headers); }
3586       if (proxyName_present) { writer.WriteShortstr(m_proxyName); }
3587       if (dataName_present) { writer.WriteShortstr(m_dataName); }
3588       if (durable_present) { writer.WriteOctet(m_durable); }
3589       if (broadcast_present) { writer.WriteOctet(m_broadcast); }
3590     }
3591
3592     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
3593       sb.Append("(");
3594       sb.Append("headers="); sb.Append(headers_present ? (m_headers == null ? "(null)" : m_headers.ToString()) : "_"); sb.Append(", ");
3595       sb.Append("proxy name="); sb.Append(proxyName_present ? (m_proxyName == null ? "(null)" : m_proxyName.ToString()) : "_"); sb.Append(", ");
3596       sb.Append("data name="); sb.Append(dataName_present ? (m_dataName == null ? "(null)" : m_dataName.ToString()) : "_"); sb.Append(", ");
3597       sb.Append("durable="); sb.Append(durable_present ? m_durable.ToString() : "_"); sb.Append(", ");
3598       sb.Append("broadcast="); sb.Append(broadcast_present ? m_broadcast.ToString() : "_");
3599       sb.Append(")");
3600     }
3601   }
3602   /// <summary>Autogenerated type. AMQP specification content header properties for content class "test"</summary>
3603   /// <remarks>
3604   ///
3605   ///   The test class provides methods for a peer to test the basic
3606   ///   operational correctness of another peer. The test methods are
3607   ///   intended to ensure that all peers respect at least the basic
3608   ///   elements of the protocol, such as frame and content organisation
3609   ///   and field types. We assume that a specially-designed peer, a
3610   ///   "monitor client" would perform such tests.
3611   ///
3612   /// </remarks>
3613   public class TestProperties: RabbitMQ.Client.Impl.ContentHeaderBase {
3614
3615
3616
3617
3618     public TestProperties() {}
3619     public override int ProtocolClassId { get { return 120; } }
3620     public override string ProtocolClassName { get { return "test"; } }
3621
3622     public override void ReadPropertiesFrom(RabbitMQ.Client.Impl.ContentHeaderPropertyReader reader) {
3623       reader.FinishPresence();
3624     }
3625
3626     public override void WritePropertiesTo(RabbitMQ.Client.Impl.ContentHeaderPropertyWriter writer) {
3627       writer.FinishPresence();
3628     }
3629
3630     public override void AppendPropertyDebugStringTo(System.Text.StringBuilder sb) {
3631       sb.Append("(");
3632       sb.Append(")");
3633     }
3634   }
3635 }
3636 namespace RabbitMQ.Client.Framing.Impl.v0_8 {
3637   using RabbitMQ.Client.Framing.v0_8;
3638   public enum ClassId {
3639     Connection = 10,
3640     Channel = 20,
3641     Access = 30,
3642     Exchange = 40,
3643     Queue = 50,
3644     Basic = 60,
3645     File = 70,
3646     Stream = 80,
3647     Tx = 90,
3648     Dtx = 100,
3649     Tunnel = 110,
3650     Test = 120,
3651     Invalid = -1
3652   }
3653   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3654   public class ConnectionStart: RabbitMQ.Client.Impl.MethodBase, IConnectionStart {
3655     public const int ClassId = 10;
3656     public const int MethodId = 10;
3657
3658     public byte m_versionMajor;
3659     public byte m_versionMinor;
3660     public System.Collections.IDictionary m_serverProperties;
3661     public byte[] m_mechanisms;
3662     public byte[] m_locales;
3663
3664     byte IConnectionStart.VersionMajor { get { return m_versionMajor; } }
3665     byte IConnectionStart.VersionMinor { get { return m_versionMinor; } }
3666     System.Collections.IDictionary IConnectionStart.ServerProperties { get { return m_serverProperties; } }
3667     byte[] IConnectionStart.Mechanisms { get { return m_mechanisms; } }
3668     byte[] IConnectionStart.Locales { get { return m_locales; } }
3669
3670     public ConnectionStart() {}
3671     public ConnectionStart(
3672       byte initVersionMajor,
3673       byte initVersionMinor,
3674       System.Collections.IDictionary initServerProperties,
3675       byte[] initMechanisms,
3676       byte[] initLocales)
3677     {
3678       m_versionMajor = initVersionMajor;
3679       m_versionMinor = initVersionMinor;
3680       m_serverProperties = initServerProperties;
3681       m_mechanisms = initMechanisms;
3682       m_locales = initLocales;
3683     }
3684
3685     public override int ProtocolClassId { get { return 10; } }
3686     public override int ProtocolMethodId { get { return 10; } }
3687     public override string ProtocolMethodName { get { return "connection.start"; } }
3688     public override bool HasContent { get { return false; } }
3689
3690     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3691       m_versionMajor = reader.ReadOctet();
3692       m_versionMinor = reader.ReadOctet();
3693       m_serverProperties = reader.ReadTable();
3694       m_mechanisms = reader.ReadLongstr();
3695       m_locales = reader.ReadLongstr();
3696     }
3697
3698     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3699       writer.WriteOctet(m_versionMajor);
3700       writer.WriteOctet(m_versionMinor);
3701       writer.WriteTable(m_serverProperties);
3702       writer.WriteLongstr(m_mechanisms);
3703       writer.WriteLongstr(m_locales);
3704     }
3705
3706     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3707       sb.Append("(");
3708       sb.Append(m_versionMajor); sb.Append(",");
3709       sb.Append(m_versionMinor); sb.Append(",");
3710       sb.Append(m_serverProperties); sb.Append(",");
3711       sb.Append(m_mechanisms); sb.Append(",");
3712       sb.Append(m_locales);
3713       sb.Append(")");
3714     }
3715   }
3716   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3717   public class ConnectionStartOk: RabbitMQ.Client.Impl.MethodBase, IConnectionStartOk {
3718     public const int ClassId = 10;
3719     public const int MethodId = 11;
3720
3721     public System.Collections.IDictionary m_clientProperties;
3722     public string m_mechanism;
3723     public byte[] m_response;
3724     public string m_locale;
3725
3726     System.Collections.IDictionary IConnectionStartOk.ClientProperties { get { return m_clientProperties; } }
3727     string IConnectionStartOk.Mechanism { get { return m_mechanism; } }
3728     byte[] IConnectionStartOk.Response { get { return m_response; } }
3729     string IConnectionStartOk.Locale { get { return m_locale; } }
3730
3731     public ConnectionStartOk() {}
3732     public ConnectionStartOk(
3733       System.Collections.IDictionary initClientProperties,
3734       string initMechanism,
3735       byte[] initResponse,
3736       string initLocale)
3737     {
3738       m_clientProperties = initClientProperties;
3739       m_mechanism = initMechanism;
3740       m_response = initResponse;
3741       m_locale = initLocale;
3742     }
3743
3744     public override int ProtocolClassId { get { return 10; } }
3745     public override int ProtocolMethodId { get { return 11; } }
3746     public override string ProtocolMethodName { get { return "connection.start-ok"; } }
3747     public override bool HasContent { get { return false; } }
3748
3749     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3750       m_clientProperties = reader.ReadTable();
3751       m_mechanism = reader.ReadShortstr();
3752       m_response = reader.ReadLongstr();
3753       m_locale = reader.ReadShortstr();
3754     }
3755
3756     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3757       writer.WriteTable(m_clientProperties);
3758       writer.WriteShortstr(m_mechanism);
3759       writer.WriteLongstr(m_response);
3760       writer.WriteShortstr(m_locale);
3761     }
3762
3763     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3764       sb.Append("(");
3765       sb.Append(m_clientProperties); sb.Append(",");
3766       sb.Append(m_mechanism); sb.Append(",");
3767       sb.Append(m_response); sb.Append(",");
3768       sb.Append(m_locale);
3769       sb.Append(")");
3770     }
3771   }
3772   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3773   public class ConnectionSecure: RabbitMQ.Client.Impl.MethodBase, IConnectionSecure {
3774     public const int ClassId = 10;
3775     public const int MethodId = 20;
3776
3777     public byte[] m_challenge;
3778
3779     byte[] IConnectionSecure.Challenge { get { return m_challenge; } }
3780
3781     public ConnectionSecure() {}
3782     public ConnectionSecure(
3783       byte[] initChallenge)
3784     {
3785       m_challenge = initChallenge;
3786     }
3787
3788     public override int ProtocolClassId { get { return 10; } }
3789     public override int ProtocolMethodId { get { return 20; } }
3790     public override string ProtocolMethodName { get { return "connection.secure"; } }
3791     public override bool HasContent { get { return false; } }
3792
3793     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3794       m_challenge = reader.ReadLongstr();
3795     }
3796
3797     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3798       writer.WriteLongstr(m_challenge);
3799     }
3800
3801     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3802       sb.Append("(");
3803       sb.Append(m_challenge);
3804       sb.Append(")");
3805     }
3806   }
3807   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3808   public class ConnectionSecureOk: RabbitMQ.Client.Impl.MethodBase, IConnectionSecureOk {
3809     public const int ClassId = 10;
3810     public const int MethodId = 21;
3811
3812     public byte[] m_response;
3813
3814     byte[] IConnectionSecureOk.Response { get { return m_response; } }
3815
3816     public ConnectionSecureOk() {}
3817     public ConnectionSecureOk(
3818       byte[] initResponse)
3819     {
3820       m_response = initResponse;
3821     }
3822
3823     public override int ProtocolClassId { get { return 10; } }
3824     public override int ProtocolMethodId { get { return 21; } }
3825     public override string ProtocolMethodName { get { return "connection.secure-ok"; } }
3826     public override bool HasContent { get { return false; } }
3827
3828     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3829       m_response = reader.ReadLongstr();
3830     }
3831
3832     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3833       writer.WriteLongstr(m_response);
3834     }
3835
3836     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3837       sb.Append("(");
3838       sb.Append(m_response);
3839       sb.Append(")");
3840     }
3841   }
3842   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3843   public class ConnectionTune: RabbitMQ.Client.Impl.MethodBase, IConnectionTune {
3844     public const int ClassId = 10;
3845     public const int MethodId = 30;
3846
3847     public ushort m_channelMax;
3848     public uint m_frameMax;
3849     public ushort m_heartbeat;
3850
3851     ushort IConnectionTune.ChannelMax { get { return m_channelMax; } }
3852     uint IConnectionTune.FrameMax { get { return m_frameMax; } }
3853     ushort IConnectionTune.Heartbeat { get { return m_heartbeat; } }
3854
3855     public ConnectionTune() {}
3856     public ConnectionTune(
3857       ushort initChannelMax,
3858       uint initFrameMax,
3859       ushort initHeartbeat)
3860     {
3861       m_channelMax = initChannelMax;
3862       m_frameMax = initFrameMax;
3863       m_heartbeat = initHeartbeat;
3864     }
3865
3866     public override int ProtocolClassId { get { return 10; } }
3867     public override int ProtocolMethodId { get { return 30; } }
3868     public override string ProtocolMethodName { get { return "connection.tune"; } }
3869     public override bool HasContent { get { return false; } }
3870
3871     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3872       m_channelMax = reader.ReadShort();
3873       m_frameMax = reader.ReadLong();
3874       m_heartbeat = reader.ReadShort();
3875     }
3876
3877     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3878       writer.WriteShort(m_channelMax);
3879       writer.WriteLong(m_frameMax);
3880       writer.WriteShort(m_heartbeat);
3881     }
3882
3883     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3884       sb.Append("(");
3885       sb.Append(m_channelMax); sb.Append(",");
3886       sb.Append(m_frameMax); sb.Append(",");
3887       sb.Append(m_heartbeat);
3888       sb.Append(")");
3889     }
3890   }
3891   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3892   public class ConnectionTuneOk: RabbitMQ.Client.Impl.MethodBase, IConnectionTuneOk {
3893     public const int ClassId = 10;
3894     public const int MethodId = 31;
3895
3896     public ushort m_channelMax;
3897     public uint m_frameMax;
3898     public ushort m_heartbeat;
3899
3900     ushort IConnectionTuneOk.ChannelMax { get { return m_channelMax; } }
3901     uint IConnectionTuneOk.FrameMax { get { return m_frameMax; } }
3902     ushort IConnectionTuneOk.Heartbeat { get { return m_heartbeat; } }
3903
3904     public ConnectionTuneOk() {}
3905     public ConnectionTuneOk(
3906       ushort initChannelMax,
3907       uint initFrameMax,
3908       ushort initHeartbeat)
3909     {
3910       m_channelMax = initChannelMax;
3911       m_frameMax = initFrameMax;
3912       m_heartbeat = initHeartbeat;
3913     }
3914
3915     public override int ProtocolClassId { get { return 10; } }
3916     public override int ProtocolMethodId { get { return 31; } }
3917     public override string ProtocolMethodName { get { return "connection.tune-ok"; } }
3918     public override bool HasContent { get { return false; } }
3919
3920     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3921       m_channelMax = reader.ReadShort();
3922       m_frameMax = reader.ReadLong();
3923       m_heartbeat = reader.ReadShort();
3924     }
3925
3926     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3927       writer.WriteShort(m_channelMax);
3928       writer.WriteLong(m_frameMax);
3929       writer.WriteShort(m_heartbeat);
3930     }
3931
3932     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3933       sb.Append("(");
3934       sb.Append(m_channelMax); sb.Append(",");
3935       sb.Append(m_frameMax); sb.Append(",");
3936       sb.Append(m_heartbeat);
3937       sb.Append(")");
3938     }
3939   }
3940   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3941   public class ConnectionOpen: RabbitMQ.Client.Impl.MethodBase, IConnectionOpen {
3942     public const int ClassId = 10;
3943     public const int MethodId = 40;
3944
3945     public string m_virtualHost;
3946     public string m_capabilities;
3947     public bool m_insist;
3948
3949     string IConnectionOpen.VirtualHost { get { return m_virtualHost; } }
3950     string IConnectionOpen.Capabilities { get { return m_capabilities; } }
3951     bool IConnectionOpen.Insist { get { return m_insist; } }
3952
3953     public ConnectionOpen() {}
3954     public ConnectionOpen(
3955       string initVirtualHost,
3956       string initCapabilities,
3957       bool initInsist)
3958     {
3959       m_virtualHost = initVirtualHost;
3960       m_capabilities = initCapabilities;
3961       m_insist = initInsist;
3962     }
3963
3964     public override int ProtocolClassId { get { return 10; } }
3965     public override int ProtocolMethodId { get { return 40; } }
3966     public override string ProtocolMethodName { get { return "connection.open"; } }
3967     public override bool HasContent { get { return false; } }
3968
3969     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
3970       m_virtualHost = reader.ReadShortstr();
3971       m_capabilities = reader.ReadShortstr();
3972       m_insist = reader.ReadBit();
3973     }
3974
3975     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
3976       writer.WriteShortstr(m_virtualHost);
3977       writer.WriteShortstr(m_capabilities);
3978       writer.WriteBit(m_insist);
3979     }
3980
3981     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
3982       sb.Append("(");
3983       sb.Append(m_virtualHost); sb.Append(",");
3984       sb.Append(m_capabilities); sb.Append(",");
3985       sb.Append(m_insist);
3986       sb.Append(")");
3987     }
3988   }
3989   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
3990   public class ConnectionOpenOk: RabbitMQ.Client.Impl.MethodBase, IConnectionOpenOk {
3991     public const int ClassId = 10;
3992     public const int MethodId = 41;
3993
3994     public string m_knownHosts;
3995
3996     string IConnectionOpenOk.KnownHosts { get { return m_knownHosts; } }
3997
3998     public ConnectionOpenOk() {}
3999     public ConnectionOpenOk(
4000       string initKnownHosts)
4001     {
4002       m_knownHosts = initKnownHosts;
4003     }
4004
4005     public override int ProtocolClassId { get { return 10; } }
4006     public override int ProtocolMethodId { get { return 41; } }
4007     public override string ProtocolMethodName { get { return "connection.open-ok"; } }
4008     public override bool HasContent { get { return false; } }
4009
4010     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4011       m_knownHosts = reader.ReadShortstr();
4012     }
4013
4014     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4015       writer.WriteShortstr(m_knownHosts);
4016     }
4017
4018     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4019       sb.Append("(");
4020       sb.Append(m_knownHosts);
4021       sb.Append(")");
4022     }
4023   }
4024   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4025   public class ConnectionRedirect: RabbitMQ.Client.Impl.MethodBase, IConnectionRedirect {
4026     public const int ClassId = 10;
4027     public const int MethodId = 50;
4028
4029     public string m_host;
4030     public string m_knownHosts;
4031
4032     string IConnectionRedirect.Host { get { return m_host; } }
4033     string IConnectionRedirect.KnownHosts { get { return m_knownHosts; } }
4034
4035     public ConnectionRedirect() {}
4036     public ConnectionRedirect(
4037       string initHost,
4038       string initKnownHosts)
4039     {
4040       m_host = initHost;
4041       m_knownHosts = initKnownHosts;
4042     }
4043
4044     public override int ProtocolClassId { get { return 10; } }
4045     public override int ProtocolMethodId { get { return 50; } }
4046     public override string ProtocolMethodName { get { return "connection.redirect"; } }
4047     public override bool HasContent { get { return false; } }
4048
4049     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4050       m_host = reader.ReadShortstr();
4051       m_knownHosts = reader.ReadShortstr();
4052     }
4053
4054     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4055       writer.WriteShortstr(m_host);
4056       writer.WriteShortstr(m_knownHosts);
4057     }
4058
4059     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4060       sb.Append("(");
4061       sb.Append(m_host); sb.Append(",");
4062       sb.Append(m_knownHosts);
4063       sb.Append(")");
4064     }
4065   }
4066   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4067   public class ConnectionClose: RabbitMQ.Client.Impl.MethodBase, IConnectionClose {
4068     public const int ClassId = 10;
4069     public const int MethodId = 60;
4070
4071     public ushort m_replyCode;
4072     public string m_replyText;
4073     public ushort m_classId;
4074     public ushort m_methodId;
4075
4076     ushort IConnectionClose.ReplyCode { get { return m_replyCode; } }
4077     string IConnectionClose.ReplyText { get { return m_replyText; } }
4078     ushort IConnectionClose.ClassId { get { return m_classId; } }
4079     ushort IConnectionClose.MethodId { get { return m_methodId; } }
4080
4081     public ConnectionClose() {}
4082     public ConnectionClose(
4083       ushort initReplyCode,
4084       string initReplyText,
4085       ushort initClassId,
4086       ushort initMethodId)
4087     {
4088       m_replyCode = initReplyCode;
4089       m_replyText = initReplyText;
4090       m_classId = initClassId;
4091       m_methodId = initMethodId;
4092     }
4093
4094     public override int ProtocolClassId { get { return 10; } }
4095     public override int ProtocolMethodId { get { return 60; } }
4096     public override string ProtocolMethodName { get { return "connection.close"; } }
4097     public override bool HasContent { get { return false; } }
4098
4099     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4100       m_replyCode = reader.ReadShort();
4101       m_replyText = reader.ReadShortstr();
4102       m_classId = reader.ReadShort();
4103       m_methodId = reader.ReadShort();
4104     }
4105
4106     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4107       writer.WriteShort(m_replyCode);
4108       writer.WriteShortstr(m_replyText);
4109       writer.WriteShort(m_classId);
4110       writer.WriteShort(m_methodId);
4111     }
4112
4113     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4114       sb.Append("(");
4115       sb.Append(m_replyCode); sb.Append(",");
4116       sb.Append(m_replyText); sb.Append(",");
4117       sb.Append(m_classId); sb.Append(",");
4118       sb.Append(m_methodId);
4119       sb.Append(")");
4120     }
4121   }
4122   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4123   public class ConnectionCloseOk: RabbitMQ.Client.Impl.MethodBase, IConnectionCloseOk {
4124     public const int ClassId = 10;
4125     public const int MethodId = 61;
4126
4127
4128
4129     public ConnectionCloseOk(
4130 )
4131     {
4132     }
4133
4134     public override int ProtocolClassId { get { return 10; } }
4135     public override int ProtocolMethodId { get { return 61; } }
4136     public override string ProtocolMethodName { get { return "connection.close-ok"; } }
4137     public override bool HasContent { get { return false; } }
4138
4139     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4140     }
4141
4142     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4143     }
4144
4145     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4146       sb.Append("(");
4147       sb.Append(")");
4148     }
4149   }
4150   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4151   public class ChannelOpen: RabbitMQ.Client.Impl.MethodBase, IChannelOpen {
4152     public const int ClassId = 20;
4153     public const int MethodId = 10;
4154
4155     public string m_outOfBand;
4156
4157     string IChannelOpen.OutOfBand { get { return m_outOfBand; } }
4158
4159     public ChannelOpen() {}
4160     public ChannelOpen(
4161       string initOutOfBand)
4162     {
4163       m_outOfBand = initOutOfBand;
4164     }
4165
4166     public override int ProtocolClassId { get { return 20; } }
4167     public override int ProtocolMethodId { get { return 10; } }
4168     public override string ProtocolMethodName { get { return "channel.open"; } }
4169     public override bool HasContent { get { return false; } }
4170
4171     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4172       m_outOfBand = reader.ReadShortstr();
4173     }
4174
4175     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4176       writer.WriteShortstr(m_outOfBand);
4177     }
4178
4179     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4180       sb.Append("(");
4181       sb.Append(m_outOfBand);
4182       sb.Append(")");
4183     }
4184   }
4185   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4186   public class ChannelOpenOk: RabbitMQ.Client.Impl.MethodBase, IChannelOpenOk {
4187     public const int ClassId = 20;
4188     public const int MethodId = 11;
4189
4190
4191
4192     public ChannelOpenOk(
4193 )
4194     {
4195     }
4196
4197     public override int ProtocolClassId { get { return 20; } }
4198     public override int ProtocolMethodId { get { return 11; } }
4199     public override string ProtocolMethodName { get { return "channel.open-ok"; } }
4200     public override bool HasContent { get { return false; } }
4201
4202     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4203     }
4204
4205     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4206     }
4207
4208     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4209       sb.Append("(");
4210       sb.Append(")");
4211     }
4212   }
4213   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4214   public class ChannelFlow: RabbitMQ.Client.Impl.MethodBase, IChannelFlow {
4215     public const int ClassId = 20;
4216     public const int MethodId = 20;
4217
4218     public bool m_active;
4219
4220     bool IChannelFlow.Active { get { return m_active; } }
4221
4222     public ChannelFlow() {}
4223     public ChannelFlow(
4224       bool initActive)
4225     {
4226       m_active = initActive;
4227     }
4228
4229     public override int ProtocolClassId { get { return 20; } }
4230     public override int ProtocolMethodId { get { return 20; } }
4231     public override string ProtocolMethodName { get { return "channel.flow"; } }
4232     public override bool HasContent { get { return false; } }
4233
4234     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4235       m_active = reader.ReadBit();
4236     }
4237
4238     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4239       writer.WriteBit(m_active);
4240     }
4241
4242     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4243       sb.Append("(");
4244       sb.Append(m_active);
4245       sb.Append(")");
4246     }
4247   }
4248   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4249   public class ChannelFlowOk: RabbitMQ.Client.Impl.MethodBase, IChannelFlowOk {
4250     public const int ClassId = 20;
4251     public const int MethodId = 21;
4252
4253     public bool m_active;
4254
4255     bool IChannelFlowOk.Active { get { return m_active; } }
4256
4257     public ChannelFlowOk() {}
4258     public ChannelFlowOk(
4259       bool initActive)
4260     {
4261       m_active = initActive;
4262     }
4263
4264     public override int ProtocolClassId { get { return 20; } }
4265     public override int ProtocolMethodId { get { return 21; } }
4266     public override string ProtocolMethodName { get { return "channel.flow-ok"; } }
4267     public override bool HasContent { get { return false; } }
4268
4269     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4270       m_active = reader.ReadBit();
4271     }
4272
4273     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4274       writer.WriteBit(m_active);
4275     }
4276
4277     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4278       sb.Append("(");
4279       sb.Append(m_active);
4280       sb.Append(")");
4281     }
4282   }
4283   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4284   public class ChannelAlert: RabbitMQ.Client.Impl.MethodBase, IChannelAlert {
4285     public const int ClassId = 20;
4286     public const int MethodId = 30;
4287
4288     public ushort m_replyCode;
4289     public string m_replyText;
4290     public System.Collections.IDictionary m_details;
4291
4292     ushort IChannelAlert.ReplyCode { get { return m_replyCode; } }
4293     string IChannelAlert.ReplyText { get { return m_replyText; } }
4294     System.Collections.IDictionary IChannelAlert.Details { get { return m_details; } }
4295
4296     public ChannelAlert() {}
4297     public ChannelAlert(
4298       ushort initReplyCode,
4299       string initReplyText,
4300       System.Collections.IDictionary initDetails)
4301     {
4302       m_replyCode = initReplyCode;
4303       m_replyText = initReplyText;
4304       m_details = initDetails;
4305     }
4306
4307     public override int ProtocolClassId { get { return 20; } }
4308     public override int ProtocolMethodId { get { return 30; } }
4309     public override string ProtocolMethodName { get { return "channel.alert"; } }
4310     public override bool HasContent { get { return false; } }
4311
4312     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4313       m_replyCode = reader.ReadShort();
4314       m_replyText = reader.ReadShortstr();
4315       m_details = reader.ReadTable();
4316     }
4317
4318     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4319       writer.WriteShort(m_replyCode);
4320       writer.WriteShortstr(m_replyText);
4321       writer.WriteTable(m_details);
4322     }
4323
4324     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4325       sb.Append("(");
4326       sb.Append(m_replyCode); sb.Append(",");
4327       sb.Append(m_replyText); sb.Append(",");
4328       sb.Append(m_details);
4329       sb.Append(")");
4330     }
4331   }
4332   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4333   public class ChannelClose: RabbitMQ.Client.Impl.MethodBase, IChannelClose {
4334     public const int ClassId = 20;
4335     public const int MethodId = 40;
4336
4337     public ushort m_replyCode;
4338     public string m_replyText;
4339     public ushort m_classId;
4340     public ushort m_methodId;
4341
4342     ushort IChannelClose.ReplyCode { get { return m_replyCode; } }
4343     string IChannelClose.ReplyText { get { return m_replyText; } }
4344     ushort IChannelClose.ClassId { get { return m_classId; } }
4345     ushort IChannelClose.MethodId { get { return m_methodId; } }
4346
4347     public ChannelClose() {}
4348     public ChannelClose(
4349       ushort initReplyCode,
4350       string initReplyText,
4351       ushort initClassId,
4352       ushort initMethodId)
4353     {
4354       m_replyCode = initReplyCode;
4355       m_replyText = initReplyText;
4356       m_classId = initClassId;
4357       m_methodId = initMethodId;
4358     }
4359
4360     public override int ProtocolClassId { get { return 20; } }
4361     public override int ProtocolMethodId { get { return 40; } }
4362     public override string ProtocolMethodName { get { return "channel.close"; } }
4363     public override bool HasContent { get { return false; } }
4364
4365     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4366       m_replyCode = reader.ReadShort();
4367       m_replyText = reader.ReadShortstr();
4368       m_classId = reader.ReadShort();
4369       m_methodId = reader.ReadShort();
4370     }
4371
4372     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4373       writer.WriteShort(m_replyCode);
4374       writer.WriteShortstr(m_replyText);
4375       writer.WriteShort(m_classId);
4376       writer.WriteShort(m_methodId);
4377     }
4378
4379     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4380       sb.Append("(");
4381       sb.Append(m_replyCode); sb.Append(",");
4382       sb.Append(m_replyText); sb.Append(",");
4383       sb.Append(m_classId); sb.Append(",");
4384       sb.Append(m_methodId);
4385       sb.Append(")");
4386     }
4387   }
4388   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4389   public class ChannelCloseOk: RabbitMQ.Client.Impl.MethodBase, IChannelCloseOk {
4390     public const int ClassId = 20;
4391     public const int MethodId = 41;
4392
4393
4394
4395     public ChannelCloseOk(
4396 )
4397     {
4398     }
4399
4400     public override int ProtocolClassId { get { return 20; } }
4401     public override int ProtocolMethodId { get { return 41; } }
4402     public override string ProtocolMethodName { get { return "channel.close-ok"; } }
4403     public override bool HasContent { get { return false; } }
4404
4405     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4406     }
4407
4408     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4409     }
4410
4411     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4412       sb.Append("(");
4413       sb.Append(")");
4414     }
4415   }
4416   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4417   public class AccessRequest: RabbitMQ.Client.Impl.MethodBase, IAccessRequest {
4418     public const int ClassId = 30;
4419     public const int MethodId = 10;
4420
4421     public string m_realm;
4422     public bool m_exclusive;
4423     public bool m_passive;
4424     public bool m_active;
4425     public bool m_write;
4426     public bool m_read;
4427
4428     string IAccessRequest.Realm { get { return m_realm; } }
4429     bool IAccessRequest.Exclusive { get { return m_exclusive; } }
4430     bool IAccessRequest.Passive { get { return m_passive; } }
4431     bool IAccessRequest.Active { get { return m_active; } }
4432     bool IAccessRequest.Write { get { return m_write; } }
4433     bool IAccessRequest.Read { get { return m_read; } }
4434
4435     public AccessRequest() {}
4436     public AccessRequest(
4437       string initRealm,
4438       bool initExclusive,
4439       bool initPassive,
4440       bool initActive,
4441       bool initWrite,
4442       bool initRead)
4443     {
4444       m_realm = initRealm;
4445       m_exclusive = initExclusive;
4446       m_passive = initPassive;
4447       m_active = initActive;
4448       m_write = initWrite;
4449       m_read = initRead;
4450     }
4451
4452     public override int ProtocolClassId { get { return 30; } }
4453     public override int ProtocolMethodId { get { return 10; } }
4454     public override string ProtocolMethodName { get { return "access.request"; } }
4455     public override bool HasContent { get { return false; } }
4456
4457     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4458       m_realm = reader.ReadShortstr();
4459       m_exclusive = reader.ReadBit();
4460       m_passive = reader.ReadBit();
4461       m_active = reader.ReadBit();
4462       m_write = reader.ReadBit();
4463       m_read = reader.ReadBit();
4464     }
4465
4466     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4467       writer.WriteShortstr(m_realm);
4468       writer.WriteBit(m_exclusive);
4469       writer.WriteBit(m_passive);
4470       writer.WriteBit(m_active);
4471       writer.WriteBit(m_write);
4472       writer.WriteBit(m_read);
4473     }
4474
4475     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4476       sb.Append("(");
4477       sb.Append(m_realm); sb.Append(",");
4478       sb.Append(m_exclusive); sb.Append(",");
4479       sb.Append(m_passive); sb.Append(",");
4480       sb.Append(m_active); sb.Append(",");
4481       sb.Append(m_write); sb.Append(",");
4482       sb.Append(m_read);
4483       sb.Append(")");
4484     }
4485   }
4486   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4487   public class AccessRequestOk: RabbitMQ.Client.Impl.MethodBase, IAccessRequestOk {
4488     public const int ClassId = 30;
4489     public const int MethodId = 11;
4490
4491     public ushort m_ticket;
4492
4493     ushort IAccessRequestOk.Ticket { get { return m_ticket; } }
4494
4495     public AccessRequestOk() {}
4496     public AccessRequestOk(
4497       ushort initTicket)
4498     {
4499       m_ticket = initTicket;
4500     }
4501
4502     public override int ProtocolClassId { get { return 30; } }
4503     public override int ProtocolMethodId { get { return 11; } }
4504     public override string ProtocolMethodName { get { return "access.request-ok"; } }
4505     public override bool HasContent { get { return false; } }
4506
4507     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4508       m_ticket = reader.ReadShort();
4509     }
4510
4511     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4512       writer.WriteShort(m_ticket);
4513     }
4514
4515     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4516       sb.Append("(");
4517       sb.Append(m_ticket);
4518       sb.Append(")");
4519     }
4520   }
4521   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4522   public class ExchangeDeclare: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclare {
4523     public const int ClassId = 40;
4524     public const int MethodId = 10;
4525
4526     public ushort m_ticket;
4527     public string m_exchange;
4528     public string m_type;
4529     public bool m_passive;
4530     public bool m_durable;
4531     public bool m_autoDelete;
4532     public bool m_internal;
4533     public bool m_nowait;
4534     public System.Collections.IDictionary m_arguments;
4535
4536     ushort IExchangeDeclare.Ticket { get { return m_ticket; } }
4537     string IExchangeDeclare.Exchange { get { return m_exchange; } }
4538     string IExchangeDeclare.Type { get { return m_type; } }
4539     bool IExchangeDeclare.Passive { get { return m_passive; } }
4540     bool IExchangeDeclare.Durable { get { return m_durable; } }
4541     bool IExchangeDeclare.AutoDelete { get { return m_autoDelete; } }
4542     bool IExchangeDeclare.Internal { get { return m_internal; } }
4543     bool IExchangeDeclare.Nowait { get { return m_nowait; } }
4544     System.Collections.IDictionary IExchangeDeclare.Arguments { get { return m_arguments; } }
4545
4546     public ExchangeDeclare() {}
4547     public ExchangeDeclare(
4548       ushort initTicket,
4549       string initExchange,
4550       string initType,
4551       bool initPassive,
4552       bool initDurable,
4553       bool initAutoDelete,
4554       bool initInternal,
4555       bool initNowait,
4556       System.Collections.IDictionary initArguments)
4557     {
4558       m_ticket = initTicket;
4559       m_exchange = initExchange;
4560       m_type = initType;
4561       m_passive = initPassive;
4562       m_durable = initDurable;
4563       m_autoDelete = initAutoDelete;
4564       m_internal = initInternal;
4565       m_nowait = initNowait;
4566       m_arguments = initArguments;
4567     }
4568
4569     public override int ProtocolClassId { get { return 40; } }
4570     public override int ProtocolMethodId { get { return 10; } }
4571     public override string ProtocolMethodName { get { return "exchange.declare"; } }
4572     public override bool HasContent { get { return false; } }
4573
4574     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4575       m_ticket = reader.ReadShort();
4576       m_exchange = reader.ReadShortstr();
4577       m_type = reader.ReadShortstr();
4578       m_passive = reader.ReadBit();
4579       m_durable = reader.ReadBit();
4580       m_autoDelete = reader.ReadBit();
4581       m_internal = reader.ReadBit();
4582       m_nowait = reader.ReadBit();
4583       m_arguments = reader.ReadTable();
4584     }
4585
4586     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4587       writer.WriteShort(m_ticket);
4588       writer.WriteShortstr(m_exchange);
4589       writer.WriteShortstr(m_type);
4590       writer.WriteBit(m_passive);
4591       writer.WriteBit(m_durable);
4592       writer.WriteBit(m_autoDelete);
4593       writer.WriteBit(m_internal);
4594       writer.WriteBit(m_nowait);
4595       writer.WriteTable(m_arguments);
4596     }
4597
4598     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4599       sb.Append("(");
4600       sb.Append(m_ticket); sb.Append(",");
4601       sb.Append(m_exchange); sb.Append(",");
4602       sb.Append(m_type); sb.Append(",");
4603       sb.Append(m_passive); sb.Append(",");
4604       sb.Append(m_durable); sb.Append(",");
4605       sb.Append(m_autoDelete); sb.Append(",");
4606       sb.Append(m_internal); sb.Append(",");
4607       sb.Append(m_nowait); sb.Append(",");
4608       sb.Append(m_arguments);
4609       sb.Append(")");
4610     }
4611   }
4612   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4613   public class ExchangeDeclareOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeclareOk {
4614     public const int ClassId = 40;
4615     public const int MethodId = 11;
4616
4617
4618
4619     public ExchangeDeclareOk(
4620 )
4621     {
4622     }
4623
4624     public override int ProtocolClassId { get { return 40; } }
4625     public override int ProtocolMethodId { get { return 11; } }
4626     public override string ProtocolMethodName { get { return "exchange.declare-ok"; } }
4627     public override bool HasContent { get { return false; } }
4628
4629     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4630     }
4631
4632     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4633     }
4634
4635     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4636       sb.Append("(");
4637       sb.Append(")");
4638     }
4639   }
4640   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4641   public class ExchangeDelete: RabbitMQ.Client.Impl.MethodBase, IExchangeDelete {
4642     public const int ClassId = 40;
4643     public const int MethodId = 20;
4644
4645     public ushort m_ticket;
4646     public string m_exchange;
4647     public bool m_ifUnused;
4648     public bool m_nowait;
4649
4650     ushort IExchangeDelete.Ticket { get { return m_ticket; } }
4651     string IExchangeDelete.Exchange { get { return m_exchange; } }
4652     bool IExchangeDelete.IfUnused { get { return m_ifUnused; } }
4653     bool IExchangeDelete.Nowait { get { return m_nowait; } }
4654
4655     public ExchangeDelete() {}
4656     public ExchangeDelete(
4657       ushort initTicket,
4658       string initExchange,
4659       bool initIfUnused,
4660       bool initNowait)
4661     {
4662       m_ticket = initTicket;
4663       m_exchange = initExchange;
4664       m_ifUnused = initIfUnused;
4665       m_nowait = initNowait;
4666     }
4667
4668     public override int ProtocolClassId { get { return 40; } }
4669     public override int ProtocolMethodId { get { return 20; } }
4670     public override string ProtocolMethodName { get { return "exchange.delete"; } }
4671     public override bool HasContent { get { return false; } }
4672
4673     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4674       m_ticket = reader.ReadShort();
4675       m_exchange = reader.ReadShortstr();
4676       m_ifUnused = reader.ReadBit();
4677       m_nowait = reader.ReadBit();
4678     }
4679
4680     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4681       writer.WriteShort(m_ticket);
4682       writer.WriteShortstr(m_exchange);
4683       writer.WriteBit(m_ifUnused);
4684       writer.WriteBit(m_nowait);
4685     }
4686
4687     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4688       sb.Append("(");
4689       sb.Append(m_ticket); sb.Append(",");
4690       sb.Append(m_exchange); sb.Append(",");
4691       sb.Append(m_ifUnused); sb.Append(",");
4692       sb.Append(m_nowait);
4693       sb.Append(")");
4694     }
4695   }
4696   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4697   public class ExchangeDeleteOk: RabbitMQ.Client.Impl.MethodBase, IExchangeDeleteOk {
4698     public const int ClassId = 40;
4699     public const int MethodId = 21;
4700
4701
4702
4703     public ExchangeDeleteOk(
4704 )
4705     {
4706     }
4707
4708     public override int ProtocolClassId { get { return 40; } }
4709     public override int ProtocolMethodId { get { return 21; } }
4710     public override string ProtocolMethodName { get { return "exchange.delete-ok"; } }
4711     public override bool HasContent { get { return false; } }
4712
4713     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4714     }
4715
4716     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4717     }
4718
4719     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4720       sb.Append("(");
4721       sb.Append(")");
4722     }
4723   }
4724   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4725   public class QueueDeclare: RabbitMQ.Client.Impl.MethodBase, IQueueDeclare {
4726     public const int ClassId = 50;
4727     public const int MethodId = 10;
4728
4729     public ushort m_ticket;
4730     public string m_queue;
4731     public bool m_passive;
4732     public bool m_durable;
4733     public bool m_exclusive;
4734     public bool m_autoDelete;
4735     public bool m_nowait;
4736     public System.Collections.IDictionary m_arguments;
4737
4738     ushort IQueueDeclare.Ticket { get { return m_ticket; } }
4739     string IQueueDeclare.Queue { get { return m_queue; } }
4740     bool IQueueDeclare.Passive { get { return m_passive; } }
4741     bool IQueueDeclare.Durable { get { return m_durable; } }
4742     bool IQueueDeclare.Exclusive { get { return m_exclusive; } }
4743     bool IQueueDeclare.AutoDelete { get { return m_autoDelete; } }
4744     bool IQueueDeclare.Nowait { get { return m_nowait; } }
4745     System.Collections.IDictionary IQueueDeclare.Arguments { get { return m_arguments; } }
4746
4747     public QueueDeclare() {}
4748     public QueueDeclare(
4749       ushort initTicket,
4750       string initQueue,
4751       bool initPassive,
4752       bool initDurable,
4753       bool initExclusive,
4754       bool initAutoDelete,
4755       bool initNowait,
4756       System.Collections.IDictionary initArguments)
4757     {
4758       m_ticket = initTicket;
4759       m_queue = initQueue;
4760       m_passive = initPassive;
4761       m_durable = initDurable;
4762       m_exclusive = initExclusive;
4763       m_autoDelete = initAutoDelete;
4764       m_nowait = initNowait;
4765       m_arguments = initArguments;
4766     }
4767
4768     public override int ProtocolClassId { get { return 50; } }
4769     public override int ProtocolMethodId { get { return 10; } }
4770     public override string ProtocolMethodName { get { return "queue.declare"; } }
4771     public override bool HasContent { get { return false; } }
4772
4773     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4774       m_ticket = reader.ReadShort();
4775       m_queue = reader.ReadShortstr();
4776       m_passive = reader.ReadBit();
4777       m_durable = reader.ReadBit();
4778       m_exclusive = reader.ReadBit();
4779       m_autoDelete = reader.ReadBit();
4780       m_nowait = reader.ReadBit();
4781       m_arguments = reader.ReadTable();
4782     }
4783
4784     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4785       writer.WriteShort(m_ticket);
4786       writer.WriteShortstr(m_queue);
4787       writer.WriteBit(m_passive);
4788       writer.WriteBit(m_durable);
4789       writer.WriteBit(m_exclusive);
4790       writer.WriteBit(m_autoDelete);
4791       writer.WriteBit(m_nowait);
4792       writer.WriteTable(m_arguments);
4793     }
4794
4795     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4796       sb.Append("(");
4797       sb.Append(m_ticket); sb.Append(",");
4798       sb.Append(m_queue); sb.Append(",");
4799       sb.Append(m_passive); sb.Append(",");
4800       sb.Append(m_durable); sb.Append(",");
4801       sb.Append(m_exclusive); sb.Append(",");
4802       sb.Append(m_autoDelete); sb.Append(",");
4803       sb.Append(m_nowait); sb.Append(",");
4804       sb.Append(m_arguments);
4805       sb.Append(")");
4806     }
4807   }
4808   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4809   public class QueueDeclareOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeclareOk {
4810     public const int ClassId = 50;
4811     public const int MethodId = 11;
4812
4813     public string m_queue;
4814     public uint m_messageCount;
4815     public uint m_consumerCount;
4816
4817     string IQueueDeclareOk.Queue { get { return m_queue; } }
4818     uint IQueueDeclareOk.MessageCount { get { return m_messageCount; } }
4819     uint IQueueDeclareOk.ConsumerCount { get { return m_consumerCount; } }
4820
4821     public QueueDeclareOk() {}
4822     public QueueDeclareOk(
4823       string initQueue,
4824       uint initMessageCount,
4825       uint initConsumerCount)
4826     {
4827       m_queue = initQueue;
4828       m_messageCount = initMessageCount;
4829       m_consumerCount = initConsumerCount;
4830     }
4831
4832     public override int ProtocolClassId { get { return 50; } }
4833     public override int ProtocolMethodId { get { return 11; } }
4834     public override string ProtocolMethodName { get { return "queue.declare-ok"; } }
4835     public override bool HasContent { get { return false; } }
4836
4837     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4838       m_queue = reader.ReadShortstr();
4839       m_messageCount = reader.ReadLong();
4840       m_consumerCount = reader.ReadLong();
4841     }
4842
4843     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4844       writer.WriteShortstr(m_queue);
4845       writer.WriteLong(m_messageCount);
4846       writer.WriteLong(m_consumerCount);
4847     }
4848
4849     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4850       sb.Append("(");
4851       sb.Append(m_queue); sb.Append(",");
4852       sb.Append(m_messageCount); sb.Append(",");
4853       sb.Append(m_consumerCount);
4854       sb.Append(")");
4855     }
4856   }
4857   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4858   public class QueueBind: RabbitMQ.Client.Impl.MethodBase, IQueueBind {
4859     public const int ClassId = 50;
4860     public const int MethodId = 20;
4861
4862     public ushort m_ticket;
4863     public string m_queue;
4864     public string m_exchange;
4865     public string m_routingKey;
4866     public bool m_nowait;
4867     public System.Collections.IDictionary m_arguments;
4868
4869     ushort IQueueBind.Ticket { get { return m_ticket; } }
4870     string IQueueBind.Queue { get { return m_queue; } }
4871     string IQueueBind.Exchange { get { return m_exchange; } }
4872     string IQueueBind.RoutingKey { get { return m_routingKey; } }
4873     bool IQueueBind.Nowait { get { return m_nowait; } }
4874     System.Collections.IDictionary IQueueBind.Arguments { get { return m_arguments; } }
4875
4876     public QueueBind() {}
4877     public QueueBind(
4878       ushort initTicket,
4879       string initQueue,
4880       string initExchange,
4881       string initRoutingKey,
4882       bool initNowait,
4883       System.Collections.IDictionary initArguments)
4884     {
4885       m_ticket = initTicket;
4886       m_queue = initQueue;
4887       m_exchange = initExchange;
4888       m_routingKey = initRoutingKey;
4889       m_nowait = initNowait;
4890       m_arguments = initArguments;
4891     }
4892
4893     public override int ProtocolClassId { get { return 50; } }
4894     public override int ProtocolMethodId { get { return 20; } }
4895     public override string ProtocolMethodName { get { return "queue.bind"; } }
4896     public override bool HasContent { get { return false; } }
4897
4898     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4899       m_ticket = reader.ReadShort();
4900       m_queue = reader.ReadShortstr();
4901       m_exchange = reader.ReadShortstr();
4902       m_routingKey = reader.ReadShortstr();
4903       m_nowait = reader.ReadBit();
4904       m_arguments = reader.ReadTable();
4905     }
4906
4907     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4908       writer.WriteShort(m_ticket);
4909       writer.WriteShortstr(m_queue);
4910       writer.WriteShortstr(m_exchange);
4911       writer.WriteShortstr(m_routingKey);
4912       writer.WriteBit(m_nowait);
4913       writer.WriteTable(m_arguments);
4914     }
4915
4916     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4917       sb.Append("(");
4918       sb.Append(m_ticket); sb.Append(",");
4919       sb.Append(m_queue); sb.Append(",");
4920       sb.Append(m_exchange); sb.Append(",");
4921       sb.Append(m_routingKey); sb.Append(",");
4922       sb.Append(m_nowait); sb.Append(",");
4923       sb.Append(m_arguments);
4924       sb.Append(")");
4925     }
4926   }
4927   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4928   public class QueueBindOk: RabbitMQ.Client.Impl.MethodBase, IQueueBindOk {
4929     public const int ClassId = 50;
4930     public const int MethodId = 21;
4931
4932
4933
4934     public QueueBindOk(
4935 )
4936     {
4937     }
4938
4939     public override int ProtocolClassId { get { return 50; } }
4940     public override int ProtocolMethodId { get { return 21; } }
4941     public override string ProtocolMethodName { get { return "queue.bind-ok"; } }
4942     public override bool HasContent { get { return false; } }
4943
4944     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4945     }
4946
4947     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
4948     }
4949
4950     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
4951       sb.Append("(");
4952       sb.Append(")");
4953     }
4954   }
4955   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
4956   public class QueueUnbind: RabbitMQ.Client.Impl.MethodBase, IQueueUnbind {
4957     public const int ClassId = 50;
4958     public const int MethodId = 50;
4959
4960     public ushort m_ticket;
4961     public string m_queue;
4962     public string m_exchange;
4963     public string m_routingKey;
4964     public System.Collections.IDictionary m_arguments;
4965
4966     ushort IQueueUnbind.Ticket { get { return m_ticket; } }
4967     string IQueueUnbind.Queue { get { return m_queue; } }
4968     string IQueueUnbind.Exchange { get { return m_exchange; } }
4969     string IQueueUnbind.RoutingKey { get { return m_routingKey; } }
4970     System.Collections.IDictionary IQueueUnbind.Arguments { get { return m_arguments; } }
4971
4972     public QueueUnbind() {}
4973     public QueueUnbind(
4974       ushort initTicket,
4975       string initQueue,
4976       string initExchange,
4977       string initRoutingKey,
4978       System.Collections.IDictionary initArguments)
4979     {
4980       m_ticket = initTicket;
4981       m_queue = initQueue;
4982       m_exchange = initExchange;
4983       m_routingKey = initRoutingKey;
4984       m_arguments = initArguments;
4985     }
4986
4987     public override int ProtocolClassId { get { return 50; } }
4988     public override int ProtocolMethodId { get { return 50; } }
4989     public override string ProtocolMethodName { get { return "queue.unbind"; } }
4990     public override bool HasContent { get { return false; } }
4991
4992     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
4993       m_ticket = reader.ReadShort();
4994       m_queue = reader.ReadShortstr();
4995       m_exchange = reader.ReadShortstr();
4996       m_routingKey = reader.ReadShortstr();
4997       m_arguments = reader.ReadTable();
4998     }
4999
5000     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5001       writer.WriteShort(m_ticket);
5002       writer.WriteShortstr(m_queue);
5003       writer.WriteShortstr(m_exchange);
5004       writer.WriteShortstr(m_routingKey);
5005       writer.WriteTable(m_arguments);
5006     }
5007
5008     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5009       sb.Append("(");
5010       sb.Append(m_ticket); sb.Append(",");
5011       sb.Append(m_queue); sb.Append(",");
5012       sb.Append(m_exchange); sb.Append(",");
5013       sb.Append(m_routingKey); sb.Append(",");
5014       sb.Append(m_arguments);
5015       sb.Append(")");
5016     }
5017   }
5018   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5019   public class QueueUnbindOk: RabbitMQ.Client.Impl.MethodBase, IQueueUnbindOk {
5020     public const int ClassId = 50;
5021     public const int MethodId = 51;
5022
5023
5024
5025     public QueueUnbindOk(
5026 )
5027     {
5028     }
5029
5030     public override int ProtocolClassId { get { return 50; } }
5031     public override int ProtocolMethodId { get { return 51; } }
5032     public override string ProtocolMethodName { get { return "queue.unbind-ok"; } }
5033     public override bool HasContent { get { return false; } }
5034
5035     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5036     }
5037
5038     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5039     }
5040
5041     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5042       sb.Append("(");
5043       sb.Append(")");
5044     }
5045   }
5046   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5047   public class QueuePurge: RabbitMQ.Client.Impl.MethodBase, IQueuePurge {
5048     public const int ClassId = 50;
5049     public const int MethodId = 30;
5050
5051     public ushort m_ticket;
5052     public string m_queue;
5053     public bool m_nowait;
5054
5055     ushort IQueuePurge.Ticket { get { return m_ticket; } }
5056     string IQueuePurge.Queue { get { return m_queue; } }
5057     bool IQueuePurge.Nowait { get { return m_nowait; } }
5058
5059     public QueuePurge() {}
5060     public QueuePurge(
5061       ushort initTicket,
5062       string initQueue,
5063       bool initNowait)
5064     {
5065       m_ticket = initTicket;
5066       m_queue = initQueue;
5067       m_nowait = initNowait;
5068     }
5069
5070     public override int ProtocolClassId { get { return 50; } }
5071     public override int ProtocolMethodId { get { return 30; } }
5072     public override string ProtocolMethodName { get { return "queue.purge"; } }
5073     public override bool HasContent { get { return false; } }
5074
5075     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5076       m_ticket = reader.ReadShort();
5077       m_queue = reader.ReadShortstr();
5078       m_nowait = reader.ReadBit();
5079     }
5080
5081     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5082       writer.WriteShort(m_ticket);
5083       writer.WriteShortstr(m_queue);
5084       writer.WriteBit(m_nowait);
5085     }
5086
5087     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5088       sb.Append("(");
5089       sb.Append(m_ticket); sb.Append(",");
5090       sb.Append(m_queue); sb.Append(",");
5091       sb.Append(m_nowait);
5092       sb.Append(")");
5093     }
5094   }
5095   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5096   public class QueuePurgeOk: RabbitMQ.Client.Impl.MethodBase, IQueuePurgeOk {
5097     public const int ClassId = 50;
5098     public const int MethodId = 31;
5099
5100     public uint m_messageCount;
5101
5102     uint IQueuePurgeOk.MessageCount { get { return m_messageCount; } }
5103
5104     public QueuePurgeOk() {}
5105     public QueuePurgeOk(
5106       uint initMessageCount)
5107     {
5108       m_messageCount = initMessageCount;
5109     }
5110
5111     public override int ProtocolClassId { get { return 50; } }
5112     public override int ProtocolMethodId { get { return 31; } }
5113     public override string ProtocolMethodName { get { return "queue.purge-ok"; } }
5114     public override bool HasContent { get { return false; } }
5115
5116     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5117       m_messageCount = reader.ReadLong();
5118     }
5119
5120     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5121       writer.WriteLong(m_messageCount);
5122     }
5123
5124     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5125       sb.Append("(");
5126       sb.Append(m_messageCount);
5127       sb.Append(")");
5128     }
5129   }
5130   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5131   public class QueueDelete: RabbitMQ.Client.Impl.MethodBase, IQueueDelete {
5132     public const int ClassId = 50;
5133     public const int MethodId = 40;
5134
5135     public ushort m_ticket;
5136     public string m_queue;
5137     public bool m_ifUnused;
5138     public bool m_ifEmpty;
5139     public bool m_nowait;
5140
5141     ushort IQueueDelete.Ticket { get { return m_ticket; } }
5142     string IQueueDelete.Queue { get { return m_queue; } }
5143     bool IQueueDelete.IfUnused { get { return m_ifUnused; } }
5144     bool IQueueDelete.IfEmpty { get { return m_ifEmpty; } }
5145     bool IQueueDelete.Nowait { get { return m_nowait; } }
5146
5147     public QueueDelete() {}
5148     public QueueDelete(
5149       ushort initTicket,
5150       string initQueue,
5151       bool initIfUnused,
5152       bool initIfEmpty,
5153       bool initNowait)
5154     {
5155       m_ticket = initTicket;
5156       m_queue = initQueue;
5157       m_ifUnused = initIfUnused;
5158       m_ifEmpty = initIfEmpty;
5159       m_nowait = initNowait;
5160     }
5161
5162     public override int ProtocolClassId { get { return 50; } }
5163     public override int ProtocolMethodId { get { return 40; } }
5164     public override string ProtocolMethodName { get { return "queue.delete"; } }
5165     public override bool HasContent { get { return false; } }
5166
5167     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5168       m_ticket = reader.ReadShort();
5169       m_queue = reader.ReadShortstr();
5170       m_ifUnused = reader.ReadBit();
5171       m_ifEmpty = reader.ReadBit();
5172       m_nowait = reader.ReadBit();
5173     }
5174
5175     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5176       writer.WriteShort(m_ticket);
5177       writer.WriteShortstr(m_queue);
5178       writer.WriteBit(m_ifUnused);
5179       writer.WriteBit(m_ifEmpty);
5180       writer.WriteBit(m_nowait);
5181     }
5182
5183     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5184       sb.Append("(");
5185       sb.Append(m_ticket); sb.Append(",");
5186       sb.Append(m_queue); sb.Append(",");
5187       sb.Append(m_ifUnused); sb.Append(",");
5188       sb.Append(m_ifEmpty); sb.Append(",");
5189       sb.Append(m_nowait);
5190       sb.Append(")");
5191     }
5192   }
5193   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5194   public class QueueDeleteOk: RabbitMQ.Client.Impl.MethodBase, IQueueDeleteOk {
5195     public const int ClassId = 50;
5196     public const int MethodId = 41;
5197
5198     public uint m_messageCount;
5199
5200     uint IQueueDeleteOk.MessageCount { get { return m_messageCount; } }
5201
5202     public QueueDeleteOk() {}
5203     public QueueDeleteOk(
5204       uint initMessageCount)
5205     {
5206       m_messageCount = initMessageCount;
5207     }
5208
5209     public override int ProtocolClassId { get { return 50; } }
5210     public override int ProtocolMethodId { get { return 41; } }
5211     public override string ProtocolMethodName { get { return "queue.delete-ok"; } }
5212     public override bool HasContent { get { return false; } }
5213
5214     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5215       m_messageCount = reader.ReadLong();
5216     }
5217
5218     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5219       writer.WriteLong(m_messageCount);
5220     }
5221
5222     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5223       sb.Append("(");
5224       sb.Append(m_messageCount);
5225       sb.Append(")");
5226     }
5227   }
5228   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5229   public class BasicQos: RabbitMQ.Client.Impl.MethodBase, IBasicQos {
5230     public const int ClassId = 60;
5231     public const int MethodId = 10;
5232
5233     public uint m_prefetchSize;
5234     public ushort m_prefetchCount;
5235     public bool m_global;
5236
5237     uint IBasicQos.PrefetchSize { get { return m_prefetchSize; } }
5238     ushort IBasicQos.PrefetchCount { get { return m_prefetchCount; } }
5239     bool IBasicQos.Global { get { return m_global; } }
5240
5241     public BasicQos() {}
5242     public BasicQos(
5243       uint initPrefetchSize,
5244       ushort initPrefetchCount,
5245       bool initGlobal)
5246     {
5247       m_prefetchSize = initPrefetchSize;
5248       m_prefetchCount = initPrefetchCount;
5249       m_global = initGlobal;
5250     }
5251
5252     public override int ProtocolClassId { get { return 60; } }
5253     public override int ProtocolMethodId { get { return 10; } }
5254     public override string ProtocolMethodName { get { return "basic.qos"; } }
5255     public override bool HasContent { get { return false; } }
5256
5257     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5258       m_prefetchSize = reader.ReadLong();
5259       m_prefetchCount = reader.ReadShort();
5260       m_global = reader.ReadBit();
5261     }
5262
5263     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5264       writer.WriteLong(m_prefetchSize);
5265       writer.WriteShort(m_prefetchCount);
5266       writer.WriteBit(m_global);
5267     }
5268
5269     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5270       sb.Append("(");
5271       sb.Append(m_prefetchSize); sb.Append(",");
5272       sb.Append(m_prefetchCount); sb.Append(",");
5273       sb.Append(m_global);
5274       sb.Append(")");
5275     }
5276   }
5277   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5278   public class BasicQosOk: RabbitMQ.Client.Impl.MethodBase, IBasicQosOk {
5279     public const int ClassId = 60;
5280     public const int MethodId = 11;
5281
5282
5283
5284     public BasicQosOk(
5285 )
5286     {
5287     }
5288
5289     public override int ProtocolClassId { get { return 60; } }
5290     public override int ProtocolMethodId { get { return 11; } }
5291     public override string ProtocolMethodName { get { return "basic.qos-ok"; } }
5292     public override bool HasContent { get { return false; } }
5293
5294     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5295     }
5296
5297     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5298     }
5299
5300     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5301       sb.Append("(");
5302       sb.Append(")");
5303     }
5304   }
5305   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5306   public class BasicConsume: RabbitMQ.Client.Impl.MethodBase, IBasicConsume {
5307     public const int ClassId = 60;
5308     public const int MethodId = 20;
5309
5310     public ushort m_ticket;
5311     public string m_queue;
5312     public string m_consumerTag;
5313     public bool m_noLocal;
5314     public bool m_noAck;
5315     public bool m_exclusive;
5316     public bool m_nowait;
5317
5318     ushort IBasicConsume.Ticket { get { return m_ticket; } }
5319     string IBasicConsume.Queue { get { return m_queue; } }
5320     string IBasicConsume.ConsumerTag { get { return m_consumerTag; } }
5321     bool IBasicConsume.NoLocal { get { return m_noLocal; } }
5322     bool IBasicConsume.NoAck { get { return m_noAck; } }
5323     bool IBasicConsume.Exclusive { get { return m_exclusive; } }
5324     bool IBasicConsume.Nowait { get { return m_nowait; } }
5325
5326     public BasicConsume() {}
5327     public BasicConsume(
5328       ushort initTicket,
5329       string initQueue,
5330       string initConsumerTag,
5331       bool initNoLocal,
5332       bool initNoAck,
5333       bool initExclusive,
5334       bool initNowait)
5335     {
5336       m_ticket = initTicket;
5337       m_queue = initQueue;
5338       m_consumerTag = initConsumerTag;
5339       m_noLocal = initNoLocal;
5340       m_noAck = initNoAck;
5341       m_exclusive = initExclusive;
5342       m_nowait = initNowait;
5343     }
5344
5345     public override int ProtocolClassId { get { return 60; } }
5346     public override int ProtocolMethodId { get { return 20; } }
5347     public override string ProtocolMethodName { get { return "basic.consume"; } }
5348     public override bool HasContent { get { return false; } }
5349
5350     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5351       m_ticket = reader.ReadShort();
5352       m_queue = reader.ReadShortstr();
5353       m_consumerTag = reader.ReadShortstr();
5354       m_noLocal = reader.ReadBit();
5355       m_noAck = reader.ReadBit();
5356       m_exclusive = reader.ReadBit();
5357       m_nowait = reader.ReadBit();
5358     }
5359
5360     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5361       writer.WriteShort(m_ticket);
5362       writer.WriteShortstr(m_queue);
5363       writer.WriteShortstr(m_consumerTag);
5364       writer.WriteBit(m_noLocal);
5365       writer.WriteBit(m_noAck);
5366       writer.WriteBit(m_exclusive);
5367       writer.WriteBit(m_nowait);
5368     }
5369
5370     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5371       sb.Append("(");
5372       sb.Append(m_ticket); sb.Append(",");
5373       sb.Append(m_queue); sb.Append(",");
5374       sb.Append(m_consumerTag); sb.Append(",");
5375       sb.Append(m_noLocal); sb.Append(",");
5376       sb.Append(m_noAck); sb.Append(",");
5377       sb.Append(m_exclusive); sb.Append(",");
5378       sb.Append(m_nowait);
5379       sb.Append(")");
5380     }
5381   }
5382   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5383   public class BasicConsumeOk: RabbitMQ.Client.Impl.MethodBase, IBasicConsumeOk {
5384     public const int ClassId = 60;
5385     public const int MethodId = 21;
5386
5387     public string m_consumerTag;
5388
5389     string IBasicConsumeOk.ConsumerTag { get { return m_consumerTag; } }
5390
5391     public BasicConsumeOk() {}
5392     public BasicConsumeOk(
5393       string initConsumerTag)
5394     {
5395       m_consumerTag = initConsumerTag;
5396     }
5397
5398     public override int ProtocolClassId { get { return 60; } }
5399     public override int ProtocolMethodId { get { return 21; } }
5400     public override string ProtocolMethodName { get { return "basic.consume-ok"; } }
5401     public override bool HasContent { get { return false; } }
5402
5403     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5404       m_consumerTag = reader.ReadShortstr();
5405     }
5406
5407     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5408       writer.WriteShortstr(m_consumerTag);
5409     }
5410
5411     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5412       sb.Append("(");
5413       sb.Append(m_consumerTag);
5414       sb.Append(")");
5415     }
5416   }
5417   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5418   public class BasicCancel: RabbitMQ.Client.Impl.MethodBase, IBasicCancel {
5419     public const int ClassId = 60;
5420     public const int MethodId = 30;
5421
5422     public string m_consumerTag;
5423     public bool m_nowait;
5424
5425     string IBasicCancel.ConsumerTag { get { return m_consumerTag; } }
5426     bool IBasicCancel.Nowait { get { return m_nowait; } }
5427
5428     public BasicCancel() {}
5429     public BasicCancel(
5430       string initConsumerTag,
5431       bool initNowait)
5432     {
5433       m_consumerTag = initConsumerTag;
5434       m_nowait = initNowait;
5435     }
5436
5437     public override int ProtocolClassId { get { return 60; } }
5438     public override int ProtocolMethodId { get { return 30; } }
5439     public override string ProtocolMethodName { get { return "basic.cancel"; } }
5440     public override bool HasContent { get { return false; } }
5441
5442     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5443       m_consumerTag = reader.ReadShortstr();
5444       m_nowait = reader.ReadBit();
5445     }
5446
5447     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5448       writer.WriteShortstr(m_consumerTag);
5449       writer.WriteBit(m_nowait);
5450     }
5451
5452     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5453       sb.Append("(");
5454       sb.Append(m_consumerTag); sb.Append(",");
5455       sb.Append(m_nowait);
5456       sb.Append(")");
5457     }
5458   }
5459   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5460   public class BasicCancelOk: RabbitMQ.Client.Impl.MethodBase, IBasicCancelOk {
5461     public const int ClassId = 60;
5462     public const int MethodId = 31;
5463
5464     public string m_consumerTag;
5465
5466     string IBasicCancelOk.ConsumerTag { get { return m_consumerTag; } }
5467
5468     public BasicCancelOk() {}
5469     public BasicCancelOk(
5470       string initConsumerTag)
5471     {
5472       m_consumerTag = initConsumerTag;
5473     }
5474
5475     public override int ProtocolClassId { get { return 60; } }
5476     public override int ProtocolMethodId { get { return 31; } }
5477     public override string ProtocolMethodName { get { return "basic.cancel-ok"; } }
5478     public override bool HasContent { get { return false; } }
5479
5480     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5481       m_consumerTag = reader.ReadShortstr();
5482     }
5483
5484     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5485       writer.WriteShortstr(m_consumerTag);
5486     }
5487
5488     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5489       sb.Append("(");
5490       sb.Append(m_consumerTag);
5491       sb.Append(")");
5492     }
5493   }
5494   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5495   public class BasicPublish: RabbitMQ.Client.Impl.MethodBase, IBasicPublish {
5496     public const int ClassId = 60;
5497     public const int MethodId = 40;
5498
5499     public ushort m_ticket;
5500     public string m_exchange;
5501     public string m_routingKey;
5502     public bool m_mandatory;
5503     public bool m_immediate;
5504
5505     ushort IBasicPublish.Ticket { get { return m_ticket; } }
5506     string IBasicPublish.Exchange { get { return m_exchange; } }
5507     string IBasicPublish.RoutingKey { get { return m_routingKey; } }
5508     bool IBasicPublish.Mandatory { get { return m_mandatory; } }
5509     bool IBasicPublish.Immediate { get { return m_immediate; } }
5510
5511     public BasicPublish() {}
5512     public BasicPublish(
5513       ushort initTicket,
5514       string initExchange,
5515       string initRoutingKey,
5516       bool initMandatory,
5517       bool initImmediate)
5518     {
5519       m_ticket = initTicket;
5520       m_exchange = initExchange;
5521       m_routingKey = initRoutingKey;
5522       m_mandatory = initMandatory;
5523       m_immediate = initImmediate;
5524     }
5525
5526     public override int ProtocolClassId { get { return 60; } }
5527     public override int ProtocolMethodId { get { return 40; } }
5528     public override string ProtocolMethodName { get { return "basic.publish"; } }
5529     public override bool HasContent { get { return true; } }
5530
5531     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5532       m_ticket = reader.ReadShort();
5533       m_exchange = reader.ReadShortstr();
5534       m_routingKey = reader.ReadShortstr();
5535       m_mandatory = reader.ReadBit();
5536       m_immediate = reader.ReadBit();
5537     }
5538
5539     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5540       writer.WriteShort(m_ticket);
5541       writer.WriteShortstr(m_exchange);
5542       writer.WriteShortstr(m_routingKey);
5543       writer.WriteBit(m_mandatory);
5544       writer.WriteBit(m_immediate);
5545     }
5546
5547     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5548       sb.Append("(");
5549       sb.Append(m_ticket); sb.Append(",");
5550       sb.Append(m_exchange); sb.Append(",");
5551       sb.Append(m_routingKey); sb.Append(",");
5552       sb.Append(m_mandatory); sb.Append(",");
5553       sb.Append(m_immediate);
5554       sb.Append(")");
5555     }
5556   }
5557   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5558   public class BasicReturn: RabbitMQ.Client.Impl.MethodBase, IBasicReturn {
5559     public const int ClassId = 60;
5560     public const int MethodId = 50;
5561
5562     public ushort m_replyCode;
5563     public string m_replyText;
5564     public string m_exchange;
5565     public string m_routingKey;
5566
5567     ushort IBasicReturn.ReplyCode { get { return m_replyCode; } }
5568     string IBasicReturn.ReplyText { get { return m_replyText; } }
5569     string IBasicReturn.Exchange { get { return m_exchange; } }
5570     string IBasicReturn.RoutingKey { get { return m_routingKey; } }
5571
5572     public BasicReturn() {}
5573     public BasicReturn(
5574       ushort initReplyCode,
5575       string initReplyText,
5576       string initExchange,
5577       string initRoutingKey)
5578     {
5579       m_replyCode = initReplyCode;
5580       m_replyText = initReplyText;
5581       m_exchange = initExchange;
5582       m_routingKey = initRoutingKey;
5583     }
5584
5585     public override int ProtocolClassId { get { return 60; } }
5586     public override int ProtocolMethodId { get { return 50; } }
5587     public override string ProtocolMethodName { get { return "basic.return"; } }
5588     public override bool HasContent { get { return true; } }
5589
5590     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5591       m_replyCode = reader.ReadShort();
5592       m_replyText = reader.ReadShortstr();
5593       m_exchange = reader.ReadShortstr();
5594       m_routingKey = reader.ReadShortstr();
5595     }
5596
5597     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5598       writer.WriteShort(m_replyCode);
5599       writer.WriteShortstr(m_replyText);
5600       writer.WriteShortstr(m_exchange);
5601       writer.WriteShortstr(m_routingKey);
5602     }
5603
5604     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5605       sb.Append("(");
5606       sb.Append(m_replyCode); sb.Append(",");
5607       sb.Append(m_replyText); sb.Append(",");
5608       sb.Append(m_exchange); sb.Append(",");
5609       sb.Append(m_routingKey);
5610       sb.Append(")");
5611     }
5612   }
5613   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5614   public class BasicDeliver: RabbitMQ.Client.Impl.MethodBase, IBasicDeliver {
5615     public const int ClassId = 60;
5616     public const int MethodId = 60;
5617
5618     public string m_consumerTag;
5619     public ulong m_deliveryTag;
5620     public bool m_redelivered;
5621     public string m_exchange;
5622     public string m_routingKey;
5623
5624     string IBasicDeliver.ConsumerTag { get { return m_consumerTag; } }
5625     ulong IBasicDeliver.DeliveryTag { get { return m_deliveryTag; } }
5626     bool IBasicDeliver.Redelivered { get { return m_redelivered; } }
5627     string IBasicDeliver.Exchange { get { return m_exchange; } }
5628     string IBasicDeliver.RoutingKey { get { return m_routingKey; } }
5629
5630     public BasicDeliver() {}
5631     public BasicDeliver(
5632       string initConsumerTag,
5633       ulong initDeliveryTag,
5634       bool initRedelivered,
5635       string initExchange,
5636       string initRoutingKey)
5637     {
5638       m_consumerTag = initConsumerTag;
5639       m_deliveryTag = initDeliveryTag;
5640       m_redelivered = initRedelivered;
5641       m_exchange = initExchange;
5642       m_routingKey = initRoutingKey;
5643     }
5644
5645     public override int ProtocolClassId { get { return 60; } }
5646     public override int ProtocolMethodId { get { return 60; } }
5647     public override string ProtocolMethodName { get { return "basic.deliver"; } }
5648     public override bool HasContent { get { return true; } }
5649
5650     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5651       m_consumerTag = reader.ReadShortstr();
5652       m_deliveryTag = reader.ReadLonglong();
5653       m_redelivered = reader.ReadBit();
5654       m_exchange = reader.ReadShortstr();
5655       m_routingKey = reader.ReadShortstr();
5656     }
5657
5658     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5659       writer.WriteShortstr(m_consumerTag);
5660       writer.WriteLonglong(m_deliveryTag);
5661       writer.WriteBit(m_redelivered);
5662       writer.WriteShortstr(m_exchange);
5663       writer.WriteShortstr(m_routingKey);
5664     }
5665
5666     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5667       sb.Append("(");
5668       sb.Append(m_consumerTag); sb.Append(",");
5669       sb.Append(m_deliveryTag); sb.Append(",");
5670       sb.Append(m_redelivered); sb.Append(",");
5671       sb.Append(m_exchange); sb.Append(",");
5672       sb.Append(m_routingKey);
5673       sb.Append(")");
5674     }
5675   }
5676   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5677   public class BasicGet: RabbitMQ.Client.Impl.MethodBase, IBasicGet {
5678     public const int ClassId = 60;
5679     public const int MethodId = 70;
5680
5681     public ushort m_ticket;
5682     public string m_queue;
5683     public bool m_noAck;
5684
5685     ushort IBasicGet.Ticket { get { return m_ticket; } }
5686     string IBasicGet.Queue { get { return m_queue; } }
5687     bool IBasicGet.NoAck { get { return m_noAck; } }
5688
5689     public BasicGet() {}
5690     public BasicGet(
5691       ushort initTicket,
5692       string initQueue,
5693       bool initNoAck)
5694     {
5695       m_ticket = initTicket;
5696       m_queue = initQueue;
5697       m_noAck = initNoAck;
5698     }
5699
5700     public override int ProtocolClassId { get { return 60; } }
5701     public override int ProtocolMethodId { get { return 70; } }
5702     public override string ProtocolMethodName { get { return "basic.get"; } }
5703     public override bool HasContent { get { return false; } }
5704
5705     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5706       m_ticket = reader.ReadShort();
5707       m_queue = reader.ReadShortstr();
5708       m_noAck = reader.ReadBit();
5709     }
5710
5711     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5712       writer.WriteShort(m_ticket);
5713       writer.WriteShortstr(m_queue);
5714       writer.WriteBit(m_noAck);
5715     }
5716
5717     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5718       sb.Append("(");
5719       sb.Append(m_ticket); sb.Append(",");
5720       sb.Append(m_queue); sb.Append(",");
5721       sb.Append(m_noAck);
5722       sb.Append(")");
5723     }
5724   }
5725   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5726   public class BasicGetOk: RabbitMQ.Client.Impl.MethodBase, IBasicGetOk {
5727     public const int ClassId = 60;
5728     public const int MethodId = 71;
5729
5730     public ulong m_deliveryTag;
5731     public bool m_redelivered;
5732     public string m_exchange;
5733     public string m_routingKey;
5734     public uint m_messageCount;
5735
5736     ulong IBasicGetOk.DeliveryTag { get { return m_deliveryTag; } }
5737     bool IBasicGetOk.Redelivered { get { return m_redelivered; } }
5738     string IBasicGetOk.Exchange { get { return m_exchange; } }
5739     string IBasicGetOk.RoutingKey { get { return m_routingKey; } }
5740     uint IBasicGetOk.MessageCount { get { return m_messageCount; } }
5741
5742     public BasicGetOk() {}
5743     public BasicGetOk(
5744       ulong initDeliveryTag,
5745       bool initRedelivered,
5746       string initExchange,
5747       string initRoutingKey,
5748       uint initMessageCount)
5749     {
5750       m_deliveryTag = initDeliveryTag;
5751       m_redelivered = initRedelivered;
5752       m_exchange = initExchange;
5753       m_routingKey = initRoutingKey;
5754       m_messageCount = initMessageCount;
5755     }
5756
5757     public override int ProtocolClassId { get { return 60; } }
5758     public override int ProtocolMethodId { get { return 71; } }
5759     public override string ProtocolMethodName { get { return "basic.get-ok"; } }
5760     public override bool HasContent { get { return true; } }
5761
5762     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5763       m_deliveryTag = reader.ReadLonglong();
5764       m_redelivered = reader.ReadBit();
5765       m_exchange = reader.ReadShortstr();
5766       m_routingKey = reader.ReadShortstr();
5767       m_messageCount = reader.ReadLong();
5768     }
5769
5770     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5771       writer.WriteLonglong(m_deliveryTag);
5772       writer.WriteBit(m_redelivered);
5773       writer.WriteShortstr(m_exchange);
5774       writer.WriteShortstr(m_routingKey);
5775       writer.WriteLong(m_messageCount);
5776     }
5777
5778     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5779       sb.Append("(");
5780       sb.Append(m_deliveryTag); sb.Append(",");
5781       sb.Append(m_redelivered); sb.Append(",");
5782       sb.Append(m_exchange); sb.Append(",");
5783       sb.Append(m_routingKey); sb.Append(",");
5784       sb.Append(m_messageCount);
5785       sb.Append(")");
5786     }
5787   }
5788   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5789   public class BasicGetEmpty: RabbitMQ.Client.Impl.MethodBase, IBasicGetEmpty {
5790     public const int ClassId = 60;
5791     public const int MethodId = 72;
5792
5793     public string m_clusterId;
5794
5795     string IBasicGetEmpty.ClusterId { get { return m_clusterId; } }
5796
5797     public BasicGetEmpty() {}
5798     public BasicGetEmpty(
5799       string initClusterId)
5800     {
5801       m_clusterId = initClusterId;
5802     }
5803
5804     public override int ProtocolClassId { get { return 60; } }
5805     public override int ProtocolMethodId { get { return 72; } }
5806     public override string ProtocolMethodName { get { return "basic.get-empty"; } }
5807     public override bool HasContent { get { return false; } }
5808
5809     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5810       m_clusterId = reader.ReadShortstr();
5811     }
5812
5813     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5814       writer.WriteShortstr(m_clusterId);
5815     }
5816
5817     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5818       sb.Append("(");
5819       sb.Append(m_clusterId);
5820       sb.Append(")");
5821     }
5822   }
5823   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5824   public class BasicAck: RabbitMQ.Client.Impl.MethodBase, IBasicAck {
5825     public const int ClassId = 60;
5826     public const int MethodId = 80;
5827
5828     public ulong m_deliveryTag;
5829     public bool m_multiple;
5830
5831     ulong IBasicAck.DeliveryTag { get { return m_deliveryTag; } }
5832     bool IBasicAck.Multiple { get { return m_multiple; } }
5833
5834     public BasicAck() {}
5835     public BasicAck(
5836       ulong initDeliveryTag,
5837       bool initMultiple)
5838     {
5839       m_deliveryTag = initDeliveryTag;
5840       m_multiple = initMultiple;
5841     }
5842
5843     public override int ProtocolClassId { get { return 60; } }
5844     public override int ProtocolMethodId { get { return 80; } }
5845     public override string ProtocolMethodName { get { return "basic.ack"; } }
5846     public override bool HasContent { get { return false; } }
5847
5848     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5849       m_deliveryTag = reader.ReadLonglong();
5850       m_multiple = reader.ReadBit();
5851     }
5852
5853     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5854       writer.WriteLonglong(m_deliveryTag);
5855       writer.WriteBit(m_multiple);
5856     }
5857
5858     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5859       sb.Append("(");
5860       sb.Append(m_deliveryTag); sb.Append(",");
5861       sb.Append(m_multiple);
5862       sb.Append(")");
5863     }
5864   }
5865   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5866   public class BasicReject: RabbitMQ.Client.Impl.MethodBase, IBasicReject {
5867     public const int ClassId = 60;
5868     public const int MethodId = 90;
5869
5870     public ulong m_deliveryTag;
5871     public bool m_requeue;
5872
5873     ulong IBasicReject.DeliveryTag { get { return m_deliveryTag; } }
5874     bool IBasicReject.Requeue { get { return m_requeue; } }
5875
5876     public BasicReject() {}
5877     public BasicReject(
5878       ulong initDeliveryTag,
5879       bool initRequeue)
5880     {
5881       m_deliveryTag = initDeliveryTag;
5882       m_requeue = initRequeue;
5883     }
5884
5885     public override int ProtocolClassId { get { return 60; } }
5886     public override int ProtocolMethodId { get { return 90; } }
5887     public override string ProtocolMethodName { get { return "basic.reject"; } }
5888     public override bool HasContent { get { return false; } }
5889
5890     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5891       m_deliveryTag = reader.ReadLonglong();
5892       m_requeue = reader.ReadBit();
5893     }
5894
5895     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5896       writer.WriteLonglong(m_deliveryTag);
5897       writer.WriteBit(m_requeue);
5898     }
5899
5900     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5901       sb.Append("(");
5902       sb.Append(m_deliveryTag); sb.Append(",");
5903       sb.Append(m_requeue);
5904       sb.Append(")");
5905     }
5906   }
5907   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5908   public class BasicRecover: RabbitMQ.Client.Impl.MethodBase, IBasicRecover {
5909     public const int ClassId = 60;
5910     public const int MethodId = 100;
5911
5912     public bool m_requeue;
5913
5914     bool IBasicRecover.Requeue { get { return m_requeue; } }
5915
5916     public BasicRecover() {}
5917     public BasicRecover(
5918       bool initRequeue)
5919     {
5920       m_requeue = initRequeue;
5921     }
5922
5923     public override int ProtocolClassId { get { return 60; } }
5924     public override int ProtocolMethodId { get { return 100; } }
5925     public override string ProtocolMethodName { get { return "basic.recover"; } }
5926     public override bool HasContent { get { return false; } }
5927
5928     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5929       m_requeue = reader.ReadBit();
5930     }
5931
5932     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5933       writer.WriteBit(m_requeue);
5934     }
5935
5936     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5937       sb.Append("(");
5938       sb.Append(m_requeue);
5939       sb.Append(")");
5940     }
5941   }
5942   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5943   public class FileQos: RabbitMQ.Client.Impl.MethodBase, IFileQos {
5944     public const int ClassId = 70;
5945     public const int MethodId = 10;
5946
5947     public uint m_prefetchSize;
5948     public ushort m_prefetchCount;
5949     public bool m_global;
5950
5951     uint IFileQos.PrefetchSize { get { return m_prefetchSize; } }
5952     ushort IFileQos.PrefetchCount { get { return m_prefetchCount; } }
5953     bool IFileQos.Global { get { return m_global; } }
5954
5955     public FileQos() {}
5956     public FileQos(
5957       uint initPrefetchSize,
5958       ushort initPrefetchCount,
5959       bool initGlobal)
5960     {
5961       m_prefetchSize = initPrefetchSize;
5962       m_prefetchCount = initPrefetchCount;
5963       m_global = initGlobal;
5964     }
5965
5966     public override int ProtocolClassId { get { return 70; } }
5967     public override int ProtocolMethodId { get { return 10; } }
5968     public override string ProtocolMethodName { get { return "file.qos"; } }
5969     public override bool HasContent { get { return false; } }
5970
5971     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
5972       m_prefetchSize = reader.ReadLong();
5973       m_prefetchCount = reader.ReadShort();
5974       m_global = reader.ReadBit();
5975     }
5976
5977     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
5978       writer.WriteLong(m_prefetchSize);
5979       writer.WriteShort(m_prefetchCount);
5980       writer.WriteBit(m_global);
5981     }
5982
5983     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
5984       sb.Append("(");
5985       sb.Append(m_prefetchSize); sb.Append(",");
5986       sb.Append(m_prefetchCount); sb.Append(",");
5987       sb.Append(m_global);
5988       sb.Append(")");
5989     }
5990   }
5991   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
5992   public class FileQosOk: RabbitMQ.Client.Impl.MethodBase, IFileQosOk {
5993     public const int ClassId = 70;
5994     public const int MethodId = 11;
5995
5996
5997
5998     public FileQosOk(
5999 )
6000     {
6001     }
6002
6003     public override int ProtocolClassId { get { return 70; } }
6004     public override int ProtocolMethodId { get { return 11; } }
6005     public override string ProtocolMethodName { get { return "file.qos-ok"; } }
6006     public override bool HasContent { get { return false; } }
6007
6008     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6009     }
6010
6011     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6012     }
6013
6014     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6015       sb.Append("(");
6016       sb.Append(")");
6017     }
6018   }
6019   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6020   public class FileConsume: RabbitMQ.Client.Impl.MethodBase, IFileConsume {
6021     public const int ClassId = 70;
6022     public const int MethodId = 20;
6023
6024     public ushort m_ticket;
6025     public string m_queue;
6026     public string m_consumerTag;
6027     public bool m_noLocal;
6028     public bool m_noAck;
6029     public bool m_exclusive;
6030     public bool m_nowait;
6031
6032     ushort IFileConsume.Ticket { get { return m_ticket; } }
6033     string IFileConsume.Queue { get { return m_queue; } }
6034     string IFileConsume.ConsumerTag { get { return m_consumerTag; } }
6035     bool IFileConsume.NoLocal { get { return m_noLocal; } }
6036     bool IFileConsume.NoAck { get { return m_noAck; } }
6037     bool IFileConsume.Exclusive { get { return m_exclusive; } }
6038     bool IFileConsume.Nowait { get { return m_nowait; } }
6039
6040     public FileConsume() {}
6041     public FileConsume(
6042       ushort initTicket,
6043       string initQueue,
6044       string initConsumerTag,
6045       bool initNoLocal,
6046       bool initNoAck,
6047       bool initExclusive,
6048       bool initNowait)
6049     {
6050       m_ticket = initTicket;
6051       m_queue = initQueue;
6052       m_consumerTag = initConsumerTag;
6053       m_noLocal = initNoLocal;
6054       m_noAck = initNoAck;
6055       m_exclusive = initExclusive;
6056       m_nowait = initNowait;
6057     }
6058
6059     public override int ProtocolClassId { get { return 70; } }
6060     public override int ProtocolMethodId { get { return 20; } }
6061     public override string ProtocolMethodName { get { return "file.consume"; } }
6062     public override bool HasContent { get { return false; } }
6063
6064     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6065       m_ticket = reader.ReadShort();
6066       m_queue = reader.ReadShortstr();
6067       m_consumerTag = reader.ReadShortstr();
6068       m_noLocal = reader.ReadBit();
6069       m_noAck = reader.ReadBit();
6070       m_exclusive = reader.ReadBit();
6071       m_nowait = reader.ReadBit();
6072     }
6073
6074     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6075       writer.WriteShort(m_ticket);
6076       writer.WriteShortstr(m_queue);
6077       writer.WriteShortstr(m_consumerTag);
6078       writer.WriteBit(m_noLocal);
6079       writer.WriteBit(m_noAck);
6080       writer.WriteBit(m_exclusive);
6081       writer.WriteBit(m_nowait);
6082     }
6083
6084     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6085       sb.Append("(");
6086       sb.Append(m_ticket); sb.Append(",");
6087       sb.Append(m_queue); sb.Append(",");
6088       sb.Append(m_consumerTag); sb.Append(",");
6089       sb.Append(m_noLocal); sb.Append(",");
6090       sb.Append(m_noAck); sb.Append(",");
6091       sb.Append(m_exclusive); sb.Append(",");
6092       sb.Append(m_nowait);
6093       sb.Append(")");
6094     }
6095   }
6096   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6097   public class FileConsumeOk: RabbitMQ.Client.Impl.MethodBase, IFileConsumeOk {
6098     public const int ClassId = 70;
6099     public const int MethodId = 21;
6100
6101     public string m_consumerTag;
6102
6103     string IFileConsumeOk.ConsumerTag { get { return m_consumerTag; } }
6104
6105     public FileConsumeOk() {}
6106     public FileConsumeOk(
6107       string initConsumerTag)
6108     {
6109       m_consumerTag = initConsumerTag;
6110     }
6111
6112     public override int ProtocolClassId { get { return 70; } }
6113     public override int ProtocolMethodId { get { return 21; } }
6114     public override string ProtocolMethodName { get { return "file.consume-ok"; } }
6115     public override bool HasContent { get { return false; } }
6116
6117     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6118       m_consumerTag = reader.ReadShortstr();
6119     }
6120
6121     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6122       writer.WriteShortstr(m_consumerTag);
6123     }
6124
6125     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6126       sb.Append("(");
6127       sb.Append(m_consumerTag);
6128       sb.Append(")");
6129     }
6130   }
6131   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6132   public class FileCancel: RabbitMQ.Client.Impl.MethodBase, IFileCancel {
6133     public const int ClassId = 70;
6134     public const int MethodId = 30;
6135
6136     public string m_consumerTag;
6137     public bool m_nowait;
6138
6139     string IFileCancel.ConsumerTag { get { return m_consumerTag; } }
6140     bool IFileCancel.Nowait { get { return m_nowait; } }
6141
6142     public FileCancel() {}
6143     public FileCancel(
6144       string initConsumerTag,
6145       bool initNowait)
6146     {
6147       m_consumerTag = initConsumerTag;
6148       m_nowait = initNowait;
6149     }
6150
6151     public override int ProtocolClassId { get { return 70; } }
6152     public override int ProtocolMethodId { get { return 30; } }
6153     public override string ProtocolMethodName { get { return "file.cancel"; } }
6154     public override bool HasContent { get { return false; } }
6155
6156     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6157       m_consumerTag = reader.ReadShortstr();
6158       m_nowait = reader.ReadBit();
6159     }
6160
6161     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6162       writer.WriteShortstr(m_consumerTag);
6163       writer.WriteBit(m_nowait);
6164     }
6165
6166     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6167       sb.Append("(");
6168       sb.Append(m_consumerTag); sb.Append(",");
6169       sb.Append(m_nowait);
6170       sb.Append(")");
6171     }
6172   }
6173   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6174   public class FileCancelOk: RabbitMQ.Client.Impl.MethodBase, IFileCancelOk {
6175     public const int ClassId = 70;
6176     public const int MethodId = 31;
6177
6178     public string m_consumerTag;
6179
6180     string IFileCancelOk.ConsumerTag { get { return m_consumerTag; } }
6181
6182     public FileCancelOk() {}
6183     public FileCancelOk(
6184       string initConsumerTag)
6185     {
6186       m_consumerTag = initConsumerTag;
6187     }
6188
6189     public override int ProtocolClassId { get { return 70; } }
6190     public override int ProtocolMethodId { get { return 31; } }
6191     public override string ProtocolMethodName { get { return "file.cancel-ok"; } }
6192     public override bool HasContent { get { return false; } }
6193
6194     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6195       m_consumerTag = reader.ReadShortstr();
6196     }
6197
6198     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6199       writer.WriteShortstr(m_consumerTag);
6200     }
6201
6202     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6203       sb.Append("(");
6204       sb.Append(m_consumerTag);
6205       sb.Append(")");
6206     }
6207   }
6208   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6209   public class FileOpen: RabbitMQ.Client.Impl.MethodBase, IFileOpen {
6210     public const int ClassId = 70;
6211     public const int MethodId = 40;
6212
6213     public string m_identifier;
6214     public ulong m_contentSize;
6215
6216     string IFileOpen.Identifier { get { return m_identifier; } }
6217     ulong IFileOpen.ContentSize { get { return m_contentSize; } }
6218
6219     public FileOpen() {}
6220     public FileOpen(
6221       string initIdentifier,
6222       ulong initContentSize)
6223     {
6224       m_identifier = initIdentifier;
6225       m_contentSize = initContentSize;
6226     }
6227
6228     public override int ProtocolClassId { get { return 70; } }
6229     public override int ProtocolMethodId { get { return 40; } }
6230     public override string ProtocolMethodName { get { return "file.open"; } }
6231     public override bool HasContent { get { return false; } }
6232
6233     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6234       m_identifier = reader.ReadShortstr();
6235       m_contentSize = reader.ReadLonglong();
6236     }
6237
6238     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6239       writer.WriteShortstr(m_identifier);
6240       writer.WriteLonglong(m_contentSize);
6241     }
6242
6243     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6244       sb.Append("(");
6245       sb.Append(m_identifier); sb.Append(",");
6246       sb.Append(m_contentSize);
6247       sb.Append(")");
6248     }
6249   }
6250   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6251   public class FileOpenOk: RabbitMQ.Client.Impl.MethodBase, IFileOpenOk {
6252     public const int ClassId = 70;
6253     public const int MethodId = 41;
6254
6255     public ulong m_stagedSize;
6256
6257     ulong IFileOpenOk.StagedSize { get { return m_stagedSize; } }
6258
6259     public FileOpenOk() {}
6260     public FileOpenOk(
6261       ulong initStagedSize)
6262     {
6263       m_stagedSize = initStagedSize;
6264     }
6265
6266     public override int ProtocolClassId { get { return 70; } }
6267     public override int ProtocolMethodId { get { return 41; } }
6268     public override string ProtocolMethodName { get { return "file.open-ok"; } }
6269     public override bool HasContent { get { return false; } }
6270
6271     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6272       m_stagedSize = reader.ReadLonglong();
6273     }
6274
6275     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6276       writer.WriteLonglong(m_stagedSize);
6277     }
6278
6279     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6280       sb.Append("(");
6281       sb.Append(m_stagedSize);
6282       sb.Append(")");
6283     }
6284   }
6285   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6286   public class FileStage: RabbitMQ.Client.Impl.MethodBase, IFileStage {
6287     public const int ClassId = 70;
6288     public const int MethodId = 50;
6289
6290
6291
6292     public FileStage(
6293 )
6294     {
6295     }
6296
6297     public override int ProtocolClassId { get { return 70; } }
6298     public override int ProtocolMethodId { get { return 50; } }
6299     public override string ProtocolMethodName { get { return "file.stage"; } }
6300     public override bool HasContent { get { return true; } }
6301
6302     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6303     }
6304
6305     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6306     }
6307
6308     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6309       sb.Append("(");
6310       sb.Append(")");
6311     }
6312   }
6313   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6314   public class FilePublish: RabbitMQ.Client.Impl.MethodBase, IFilePublish {
6315     public const int ClassId = 70;
6316     public const int MethodId = 60;
6317
6318     public ushort m_ticket;
6319     public string m_exchange;
6320     public string m_routingKey;
6321     public bool m_mandatory;
6322     public bool m_immediate;
6323     public string m_identifier;
6324
6325     ushort IFilePublish.Ticket { get { return m_ticket; } }
6326     string IFilePublish.Exchange { get { return m_exchange; } }
6327     string IFilePublish.RoutingKey { get { return m_routingKey; } }
6328     bool IFilePublish.Mandatory { get { return m_mandatory; } }
6329     bool IFilePublish.Immediate { get { return m_immediate; } }
6330     string IFilePublish.Identifier { get { return m_identifier; } }
6331
6332     public FilePublish() {}
6333     public FilePublish(
6334       ushort initTicket,
6335       string initExchange,
6336       string initRoutingKey,
6337       bool initMandatory,
6338       bool initImmediate,
6339       string initIdentifier)
6340     {
6341       m_ticket = initTicket;
6342       m_exchange = initExchange;
6343       m_routingKey = initRoutingKey;
6344       m_mandatory = initMandatory;
6345       m_immediate = initImmediate;
6346       m_identifier = initIdentifier;
6347     }
6348
6349     public override int ProtocolClassId { get { return 70; } }
6350     public override int ProtocolMethodId { get { return 60; } }
6351     public override string ProtocolMethodName { get { return "file.publish"; } }
6352     public override bool HasContent { get { return false; } }
6353
6354     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6355       m_ticket = reader.ReadShort();
6356       m_exchange = reader.ReadShortstr();
6357       m_routingKey = reader.ReadShortstr();
6358       m_mandatory = reader.ReadBit();
6359       m_immediate = reader.ReadBit();
6360       m_identifier = reader.ReadShortstr();
6361     }
6362
6363     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6364       writer.WriteShort(m_ticket);
6365       writer.WriteShortstr(m_exchange);
6366       writer.WriteShortstr(m_routingKey);
6367       writer.WriteBit(m_mandatory);
6368       writer.WriteBit(m_immediate);
6369       writer.WriteShortstr(m_identifier);
6370     }
6371
6372     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6373       sb.Append("(");
6374       sb.Append(m_ticket); sb.Append(",");
6375       sb.Append(m_exchange); sb.Append(",");
6376       sb.Append(m_routingKey); sb.Append(",");
6377       sb.Append(m_mandatory); sb.Append(",");
6378       sb.Append(m_immediate); sb.Append(",");
6379       sb.Append(m_identifier);
6380       sb.Append(")");
6381     }
6382   }
6383   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6384   public class FileReturn: RabbitMQ.Client.Impl.MethodBase, IFileReturn {
6385     public const int ClassId = 70;
6386     public const int MethodId = 70;
6387
6388     public ushort m_replyCode;
6389     public string m_replyText;
6390     public string m_exchange;
6391     public string m_routingKey;
6392
6393     ushort IFileReturn.ReplyCode { get { return m_replyCode; } }
6394     string IFileReturn.ReplyText { get { return m_replyText; } }
6395     string IFileReturn.Exchange { get { return m_exchange; } }
6396     string IFileReturn.RoutingKey { get { return m_routingKey; } }
6397
6398     public FileReturn() {}
6399     public FileReturn(
6400       ushort initReplyCode,
6401       string initReplyText,
6402       string initExchange,
6403       string initRoutingKey)
6404     {
6405       m_replyCode = initReplyCode;
6406       m_replyText = initReplyText;
6407       m_exchange = initExchange;
6408       m_routingKey = initRoutingKey;
6409     }
6410
6411     public override int ProtocolClassId { get { return 70; } }
6412     public override int ProtocolMethodId { get { return 70; } }
6413     public override string ProtocolMethodName { get { return "file.return"; } }
6414     public override bool HasContent { get { return true; } }
6415
6416     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6417       m_replyCode = reader.ReadShort();
6418       m_replyText = reader.ReadShortstr();
6419       m_exchange = reader.ReadShortstr();
6420       m_routingKey = reader.ReadShortstr();
6421     }
6422
6423     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6424       writer.WriteShort(m_replyCode);
6425       writer.WriteShortstr(m_replyText);
6426       writer.WriteShortstr(m_exchange);
6427       writer.WriteShortstr(m_routingKey);
6428     }
6429
6430     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6431       sb.Append("(");
6432       sb.Append(m_replyCode); sb.Append(",");
6433       sb.Append(m_replyText); sb.Append(",");
6434       sb.Append(m_exchange); sb.Append(",");
6435       sb.Append(m_routingKey);
6436       sb.Append(")");
6437     }
6438   }
6439   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6440   public class FileDeliver: RabbitMQ.Client.Impl.MethodBase, IFileDeliver {
6441     public const int ClassId = 70;
6442     public const int MethodId = 80;
6443
6444     public string m_consumerTag;
6445     public ulong m_deliveryTag;
6446     public bool m_redelivered;
6447     public string m_exchange;
6448     public string m_routingKey;
6449     public string m_identifier;
6450
6451     string IFileDeliver.ConsumerTag { get { return m_consumerTag; } }
6452     ulong IFileDeliver.DeliveryTag { get { return m_deliveryTag; } }
6453     bool IFileDeliver.Redelivered { get { return m_redelivered; } }
6454     string IFileDeliver.Exchange { get { return m_exchange; } }
6455     string IFileDeliver.RoutingKey { get { return m_routingKey; } }
6456     string IFileDeliver.Identifier { get { return m_identifier; } }
6457
6458     public FileDeliver() {}
6459     public FileDeliver(
6460       string initConsumerTag,
6461       ulong initDeliveryTag,
6462       bool initRedelivered,
6463       string initExchange,
6464       string initRoutingKey,
6465       string initIdentifier)
6466     {
6467       m_consumerTag = initConsumerTag;
6468       m_deliveryTag = initDeliveryTag;
6469       m_redelivered = initRedelivered;
6470       m_exchange = initExchange;
6471       m_routingKey = initRoutingKey;
6472       m_identifier = initIdentifier;
6473     }
6474
6475     public override int ProtocolClassId { get { return 70; } }
6476     public override int ProtocolMethodId { get { return 80; } }
6477     public override string ProtocolMethodName { get { return "file.deliver"; } }
6478     public override bool HasContent { get { return false; } }
6479
6480     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6481       m_consumerTag = reader.ReadShortstr();
6482       m_deliveryTag = reader.ReadLonglong();
6483       m_redelivered = reader.ReadBit();
6484       m_exchange = reader.ReadShortstr();
6485       m_routingKey = reader.ReadShortstr();
6486       m_identifier = reader.ReadShortstr();
6487     }
6488
6489     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6490       writer.WriteShortstr(m_consumerTag);
6491       writer.WriteLonglong(m_deliveryTag);
6492       writer.WriteBit(m_redelivered);
6493       writer.WriteShortstr(m_exchange);
6494       writer.WriteShortstr(m_routingKey);
6495       writer.WriteShortstr(m_identifier);
6496     }
6497
6498     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6499       sb.Append("(");
6500       sb.Append(m_consumerTag); sb.Append(",");
6501       sb.Append(m_deliveryTag); sb.Append(",");
6502       sb.Append(m_redelivered); sb.Append(",");
6503       sb.Append(m_exchange); sb.Append(",");
6504       sb.Append(m_routingKey); sb.Append(",");
6505       sb.Append(m_identifier);
6506       sb.Append(")");
6507     }
6508   }
6509   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6510   public class FileAck: RabbitMQ.Client.Impl.MethodBase, IFileAck {
6511     public const int ClassId = 70;
6512     public const int MethodId = 90;
6513
6514     public ulong m_deliveryTag;
6515     public bool m_multiple;
6516
6517     ulong IFileAck.DeliveryTag { get { return m_deliveryTag; } }
6518     bool IFileAck.Multiple { get { return m_multiple; } }
6519
6520     public FileAck() {}
6521     public FileAck(
6522       ulong initDeliveryTag,
6523       bool initMultiple)
6524     {
6525       m_deliveryTag = initDeliveryTag;
6526       m_multiple = initMultiple;
6527     }
6528
6529     public override int ProtocolClassId { get { return 70; } }
6530     public override int ProtocolMethodId { get { return 90; } }
6531     public override string ProtocolMethodName { get { return "file.ack"; } }
6532     public override bool HasContent { get { return false; } }
6533
6534     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6535       m_deliveryTag = reader.ReadLonglong();
6536       m_multiple = reader.ReadBit();
6537     }
6538
6539     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6540       writer.WriteLonglong(m_deliveryTag);
6541       writer.WriteBit(m_multiple);
6542     }
6543
6544     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6545       sb.Append("(");
6546       sb.Append(m_deliveryTag); sb.Append(",");
6547       sb.Append(m_multiple);
6548       sb.Append(")");
6549     }
6550   }
6551   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6552   public class FileReject: RabbitMQ.Client.Impl.MethodBase, IFileReject {
6553     public const int ClassId = 70;
6554     public const int MethodId = 100;
6555
6556     public ulong m_deliveryTag;
6557     public bool m_requeue;
6558
6559     ulong IFileReject.DeliveryTag { get { return m_deliveryTag; } }
6560     bool IFileReject.Requeue { get { return m_requeue; } }
6561
6562     public FileReject() {}
6563     public FileReject(
6564       ulong initDeliveryTag,
6565       bool initRequeue)
6566     {
6567       m_deliveryTag = initDeliveryTag;
6568       m_requeue = initRequeue;
6569     }
6570
6571     public override int ProtocolClassId { get { return 70; } }
6572     public override int ProtocolMethodId { get { return 100; } }
6573     public override string ProtocolMethodName { get { return "file.reject"; } }
6574     public override bool HasContent { get { return false; } }
6575
6576     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6577       m_deliveryTag = reader.ReadLonglong();
6578       m_requeue = reader.ReadBit();
6579     }
6580
6581     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6582       writer.WriteLonglong(m_deliveryTag);
6583       writer.WriteBit(m_requeue);
6584     }
6585
6586     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6587       sb.Append("(");
6588       sb.Append(m_deliveryTag); sb.Append(",");
6589       sb.Append(m_requeue);
6590       sb.Append(")");
6591     }
6592   }
6593   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6594   public class StreamQos: RabbitMQ.Client.Impl.MethodBase, IStreamQos {
6595     public const int ClassId = 80;
6596     public const int MethodId = 10;
6597
6598     public uint m_prefetchSize;
6599     public ushort m_prefetchCount;
6600     public uint m_consumeRate;
6601     public bool m_global;
6602
6603     uint IStreamQos.PrefetchSize { get { return m_prefetchSize; } }
6604     ushort IStreamQos.PrefetchCount { get { return m_prefetchCount; } }
6605     uint IStreamQos.ConsumeRate { get { return m_consumeRate; } }
6606     bool IStreamQos.Global { get { return m_global; } }
6607
6608     public StreamQos() {}
6609     public StreamQos(
6610       uint initPrefetchSize,
6611       ushort initPrefetchCount,
6612       uint initConsumeRate,
6613       bool initGlobal)
6614     {
6615       m_prefetchSize = initPrefetchSize;
6616       m_prefetchCount = initPrefetchCount;
6617       m_consumeRate = initConsumeRate;
6618       m_global = initGlobal;
6619     }
6620
6621     public override int ProtocolClassId { get { return 80; } }
6622     public override int ProtocolMethodId { get { return 10; } }
6623     public override string ProtocolMethodName { get { return "stream.qos"; } }
6624     public override bool HasContent { get { return false; } }
6625
6626     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6627       m_prefetchSize = reader.ReadLong();
6628       m_prefetchCount = reader.ReadShort();
6629       m_consumeRate = reader.ReadLong();
6630       m_global = reader.ReadBit();
6631     }
6632
6633     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6634       writer.WriteLong(m_prefetchSize);
6635       writer.WriteShort(m_prefetchCount);
6636       writer.WriteLong(m_consumeRate);
6637       writer.WriteBit(m_global);
6638     }
6639
6640     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6641       sb.Append("(");
6642       sb.Append(m_prefetchSize); sb.Append(",");
6643       sb.Append(m_prefetchCount); sb.Append(",");
6644       sb.Append(m_consumeRate); sb.Append(",");
6645       sb.Append(m_global);
6646       sb.Append(")");
6647     }
6648   }
6649   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6650   public class StreamQosOk: RabbitMQ.Client.Impl.MethodBase, IStreamQosOk {
6651     public const int ClassId = 80;
6652     public const int MethodId = 11;
6653
6654
6655
6656     public StreamQosOk(
6657 )
6658     {
6659     }
6660
6661     public override int ProtocolClassId { get { return 80; } }
6662     public override int ProtocolMethodId { get { return 11; } }
6663     public override string ProtocolMethodName { get { return "stream.qos-ok"; } }
6664     public override bool HasContent { get { return false; } }
6665
6666     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6667     }
6668
6669     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6670     }
6671
6672     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6673       sb.Append("(");
6674       sb.Append(")");
6675     }
6676   }
6677   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6678   public class StreamConsume: RabbitMQ.Client.Impl.MethodBase, IStreamConsume {
6679     public const int ClassId = 80;
6680     public const int MethodId = 20;
6681
6682     public ushort m_ticket;
6683     public string m_queue;
6684     public string m_consumerTag;
6685     public bool m_noLocal;
6686     public bool m_exclusive;
6687     public bool m_nowait;
6688
6689     ushort IStreamConsume.Ticket { get { return m_ticket; } }
6690     string IStreamConsume.Queue { get { return m_queue; } }
6691     string IStreamConsume.ConsumerTag { get { return m_consumerTag; } }
6692     bool IStreamConsume.NoLocal { get { return m_noLocal; } }
6693     bool IStreamConsume.Exclusive { get { return m_exclusive; } }
6694     bool IStreamConsume.Nowait { get { return m_nowait; } }
6695
6696     public StreamConsume() {}
6697     public StreamConsume(
6698       ushort initTicket,
6699       string initQueue,
6700       string initConsumerTag,
6701       bool initNoLocal,
6702       bool initExclusive,
6703       bool initNowait)
6704     {
6705       m_ticket = initTicket;
6706       m_queue = initQueue;
6707       m_consumerTag = initConsumerTag;
6708       m_noLocal = initNoLocal;
6709       m_exclusive = initExclusive;
6710       m_nowait = initNowait;
6711     }
6712
6713     public override int ProtocolClassId { get { return 80; } }
6714     public override int ProtocolMethodId { get { return 20; } }
6715     public override string ProtocolMethodName { get { return "stream.consume"; } }
6716     public override bool HasContent { get { return false; } }
6717
6718     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6719       m_ticket = reader.ReadShort();
6720       m_queue = reader.ReadShortstr();
6721       m_consumerTag = reader.ReadShortstr();
6722       m_noLocal = reader.ReadBit();
6723       m_exclusive = reader.ReadBit();
6724       m_nowait = reader.ReadBit();
6725     }
6726
6727     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6728       writer.WriteShort(m_ticket);
6729       writer.WriteShortstr(m_queue);
6730       writer.WriteShortstr(m_consumerTag);
6731       writer.WriteBit(m_noLocal);
6732       writer.WriteBit(m_exclusive);
6733       writer.WriteBit(m_nowait);
6734     }
6735
6736     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6737       sb.Append("(");
6738       sb.Append(m_ticket); sb.Append(",");
6739       sb.Append(m_queue); sb.Append(",");
6740       sb.Append(m_consumerTag); sb.Append(",");
6741       sb.Append(m_noLocal); sb.Append(",");
6742       sb.Append(m_exclusive); sb.Append(",");
6743       sb.Append(m_nowait);
6744       sb.Append(")");
6745     }
6746   }
6747   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6748   public class StreamConsumeOk: RabbitMQ.Client.Impl.MethodBase, IStreamConsumeOk {
6749     public const int ClassId = 80;
6750     public const int MethodId = 21;
6751
6752     public string m_consumerTag;
6753
6754     string IStreamConsumeOk.ConsumerTag { get { return m_consumerTag; } }
6755
6756     public StreamConsumeOk() {}
6757     public StreamConsumeOk(
6758       string initConsumerTag)
6759     {
6760       m_consumerTag = initConsumerTag;
6761     }
6762
6763     public override int ProtocolClassId { get { return 80; } }
6764     public override int ProtocolMethodId { get { return 21; } }
6765     public override string ProtocolMethodName { get { return "stream.consume-ok"; } }
6766     public override bool HasContent { get { return false; } }
6767
6768     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6769       m_consumerTag = reader.ReadShortstr();
6770     }
6771
6772     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6773       writer.WriteShortstr(m_consumerTag);
6774     }
6775
6776     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6777       sb.Append("(");
6778       sb.Append(m_consumerTag);
6779       sb.Append(")");
6780     }
6781   }
6782   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6783   public class StreamCancel: RabbitMQ.Client.Impl.MethodBase, IStreamCancel {
6784     public const int ClassId = 80;
6785     public const int MethodId = 30;
6786
6787     public string m_consumerTag;
6788     public bool m_nowait;
6789
6790     string IStreamCancel.ConsumerTag { get { return m_consumerTag; } }
6791     bool IStreamCancel.Nowait { get { return m_nowait; } }
6792
6793     public StreamCancel() {}
6794     public StreamCancel(
6795       string initConsumerTag,
6796       bool initNowait)
6797     {
6798       m_consumerTag = initConsumerTag;
6799       m_nowait = initNowait;
6800     }
6801
6802     public override int ProtocolClassId { get { return 80; } }
6803     public override int ProtocolMethodId { get { return 30; } }
6804     public override string ProtocolMethodName { get { return "stream.cancel"; } }
6805     public override bool HasContent { get { return false; } }
6806
6807     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6808       m_consumerTag = reader.ReadShortstr();
6809       m_nowait = reader.ReadBit();
6810     }
6811
6812     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6813       writer.WriteShortstr(m_consumerTag);
6814       writer.WriteBit(m_nowait);
6815     }
6816
6817     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6818       sb.Append("(");
6819       sb.Append(m_consumerTag); sb.Append(",");
6820       sb.Append(m_nowait);
6821       sb.Append(")");
6822     }
6823   }
6824   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6825   public class StreamCancelOk: RabbitMQ.Client.Impl.MethodBase, IStreamCancelOk {
6826     public const int ClassId = 80;
6827     public const int MethodId = 31;
6828
6829     public string m_consumerTag;
6830
6831     string IStreamCancelOk.ConsumerTag { get { return m_consumerTag; } }
6832
6833     public StreamCancelOk() {}
6834     public StreamCancelOk(
6835       string initConsumerTag)
6836     {
6837       m_consumerTag = initConsumerTag;
6838     }
6839
6840     public override int ProtocolClassId { get { return 80; } }
6841     public override int ProtocolMethodId { get { return 31; } }
6842     public override string ProtocolMethodName { get { return "stream.cancel-ok"; } }
6843     public override bool HasContent { get { return false; } }
6844
6845     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6846       m_consumerTag = reader.ReadShortstr();
6847     }
6848
6849     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6850       writer.WriteShortstr(m_consumerTag);
6851     }
6852
6853     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6854       sb.Append("(");
6855       sb.Append(m_consumerTag);
6856       sb.Append(")");
6857     }
6858   }
6859   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6860   public class StreamPublish: RabbitMQ.Client.Impl.MethodBase, IStreamPublish {
6861     public const int ClassId = 80;
6862     public const int MethodId = 40;
6863
6864     public ushort m_ticket;
6865     public string m_exchange;
6866     public string m_routingKey;
6867     public bool m_mandatory;
6868     public bool m_immediate;
6869
6870     ushort IStreamPublish.Ticket { get { return m_ticket; } }
6871     string IStreamPublish.Exchange { get { return m_exchange; } }
6872     string IStreamPublish.RoutingKey { get { return m_routingKey; } }
6873     bool IStreamPublish.Mandatory { get { return m_mandatory; } }
6874     bool IStreamPublish.Immediate { get { return m_immediate; } }
6875
6876     public StreamPublish() {}
6877     public StreamPublish(
6878       ushort initTicket,
6879       string initExchange,
6880       string initRoutingKey,
6881       bool initMandatory,
6882       bool initImmediate)
6883     {
6884       m_ticket = initTicket;
6885       m_exchange = initExchange;
6886       m_routingKey = initRoutingKey;
6887       m_mandatory = initMandatory;
6888       m_immediate = initImmediate;
6889     }
6890
6891     public override int ProtocolClassId { get { return 80; } }
6892     public override int ProtocolMethodId { get { return 40; } }
6893     public override string ProtocolMethodName { get { return "stream.publish"; } }
6894     public override bool HasContent { get { return true; } }
6895
6896     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6897       m_ticket = reader.ReadShort();
6898       m_exchange = reader.ReadShortstr();
6899       m_routingKey = reader.ReadShortstr();
6900       m_mandatory = reader.ReadBit();
6901       m_immediate = reader.ReadBit();
6902     }
6903
6904     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6905       writer.WriteShort(m_ticket);
6906       writer.WriteShortstr(m_exchange);
6907       writer.WriteShortstr(m_routingKey);
6908       writer.WriteBit(m_mandatory);
6909       writer.WriteBit(m_immediate);
6910     }
6911
6912     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6913       sb.Append("(");
6914       sb.Append(m_ticket); sb.Append(",");
6915       sb.Append(m_exchange); sb.Append(",");
6916       sb.Append(m_routingKey); sb.Append(",");
6917       sb.Append(m_mandatory); sb.Append(",");
6918       sb.Append(m_immediate);
6919       sb.Append(")");
6920     }
6921   }
6922   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6923   public class StreamReturn: RabbitMQ.Client.Impl.MethodBase, IStreamReturn {
6924     public const int ClassId = 80;
6925     public const int MethodId = 50;
6926
6927     public ushort m_replyCode;
6928     public string m_replyText;
6929     public string m_exchange;
6930     public string m_routingKey;
6931
6932     ushort IStreamReturn.ReplyCode { get { return m_replyCode; } }
6933     string IStreamReturn.ReplyText { get { return m_replyText; } }
6934     string IStreamReturn.Exchange { get { return m_exchange; } }
6935     string IStreamReturn.RoutingKey { get { return m_routingKey; } }
6936
6937     public StreamReturn() {}
6938     public StreamReturn(
6939       ushort initReplyCode,
6940       string initReplyText,
6941       string initExchange,
6942       string initRoutingKey)
6943     {
6944       m_replyCode = initReplyCode;
6945       m_replyText = initReplyText;
6946       m_exchange = initExchange;
6947       m_routingKey = initRoutingKey;
6948     }
6949
6950     public override int ProtocolClassId { get { return 80; } }
6951     public override int ProtocolMethodId { get { return 50; } }
6952     public override string ProtocolMethodName { get { return "stream.return"; } }
6953     public override bool HasContent { get { return true; } }
6954
6955     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
6956       m_replyCode = reader.ReadShort();
6957       m_replyText = reader.ReadShortstr();
6958       m_exchange = reader.ReadShortstr();
6959       m_routingKey = reader.ReadShortstr();
6960     }
6961
6962     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
6963       writer.WriteShort(m_replyCode);
6964       writer.WriteShortstr(m_replyText);
6965       writer.WriteShortstr(m_exchange);
6966       writer.WriteShortstr(m_routingKey);
6967     }
6968
6969     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
6970       sb.Append("(");
6971       sb.Append(m_replyCode); sb.Append(",");
6972       sb.Append(m_replyText); sb.Append(",");
6973       sb.Append(m_exchange); sb.Append(",");
6974       sb.Append(m_routingKey);
6975       sb.Append(")");
6976     }
6977   }
6978   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
6979   public class StreamDeliver: RabbitMQ.Client.Impl.MethodBase, IStreamDeliver {
6980     public const int ClassId = 80;
6981     public const int MethodId = 60;
6982
6983     public string m_consumerTag;
6984     public ulong m_deliveryTag;
6985     public string m_exchange;
6986     public string m_queue;
6987
6988     string IStreamDeliver.ConsumerTag { get { return m_consumerTag; } }
6989     ulong IStreamDeliver.DeliveryTag { get { return m_deliveryTag; } }
6990     string IStreamDeliver.Exchange { get { return m_exchange; } }
6991     string IStreamDeliver.Queue { get { return m_queue; } }
6992
6993     public StreamDeliver() {}
6994     public StreamDeliver(
6995       string initConsumerTag,
6996       ulong initDeliveryTag,
6997       string initExchange,
6998       string initQueue)
6999     {
7000       m_consumerTag = initConsumerTag;
7001       m_deliveryTag = initDeliveryTag;
7002       m_exchange = initExchange;
7003       m_queue = initQueue;
7004     }
7005
7006     public override int ProtocolClassId { get { return 80; } }
7007     public override int ProtocolMethodId { get { return 60; } }
7008     public override string ProtocolMethodName { get { return "stream.deliver"; } }
7009     public override bool HasContent { get { return true; } }
7010
7011     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7012       m_consumerTag = reader.ReadShortstr();
7013       m_deliveryTag = reader.ReadLonglong();
7014       m_exchange = reader.ReadShortstr();
7015       m_queue = reader.ReadShortstr();
7016     }
7017
7018     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7019       writer.WriteShortstr(m_consumerTag);
7020       writer.WriteLonglong(m_deliveryTag);
7021       writer.WriteShortstr(m_exchange);
7022       writer.WriteShortstr(m_queue);
7023     }
7024
7025     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7026       sb.Append("(");
7027       sb.Append(m_consumerTag); sb.Append(",");
7028       sb.Append(m_deliveryTag); sb.Append(",");
7029       sb.Append(m_exchange); sb.Append(",");
7030       sb.Append(m_queue);
7031       sb.Append(")");
7032     }
7033   }
7034   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7035   public class TxSelect: RabbitMQ.Client.Impl.MethodBase, ITxSelect {
7036     public const int ClassId = 90;
7037     public const int MethodId = 10;
7038
7039
7040
7041     public TxSelect(
7042 )
7043     {
7044     }
7045
7046     public override int ProtocolClassId { get { return 90; } }
7047     public override int ProtocolMethodId { get { return 10; } }
7048     public override string ProtocolMethodName { get { return "tx.select"; } }
7049     public override bool HasContent { get { return false; } }
7050
7051     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7052     }
7053
7054     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7055     }
7056
7057     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7058       sb.Append("(");
7059       sb.Append(")");
7060     }
7061   }
7062   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7063   public class TxSelectOk: RabbitMQ.Client.Impl.MethodBase, ITxSelectOk {
7064     public const int ClassId = 90;
7065     public const int MethodId = 11;
7066
7067
7068
7069     public TxSelectOk(
7070 )
7071     {
7072     }
7073
7074     public override int ProtocolClassId { get { return 90; } }
7075     public override int ProtocolMethodId { get { return 11; } }
7076     public override string ProtocolMethodName { get { return "tx.select-ok"; } }
7077     public override bool HasContent { get { return false; } }
7078
7079     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7080     }
7081
7082     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7083     }
7084
7085     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7086       sb.Append("(");
7087       sb.Append(")");
7088     }
7089   }
7090   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7091   public class TxCommit: RabbitMQ.Client.Impl.MethodBase, ITxCommit {
7092     public const int ClassId = 90;
7093     public const int MethodId = 20;
7094
7095
7096
7097     public TxCommit(
7098 )
7099     {
7100     }
7101
7102     public override int ProtocolClassId { get { return 90; } }
7103     public override int ProtocolMethodId { get { return 20; } }
7104     public override string ProtocolMethodName { get { return "tx.commit"; } }
7105     public override bool HasContent { get { return false; } }
7106
7107     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7108     }
7109
7110     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7111     }
7112
7113     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7114       sb.Append("(");
7115       sb.Append(")");
7116     }
7117   }
7118   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7119   public class TxCommitOk: RabbitMQ.Client.Impl.MethodBase, ITxCommitOk {
7120     public const int ClassId = 90;
7121     public const int MethodId = 21;
7122
7123
7124
7125     public TxCommitOk(
7126 )
7127     {
7128     }
7129
7130     public override int ProtocolClassId { get { return 90; } }
7131     public override int ProtocolMethodId { get { return 21; } }
7132     public override string ProtocolMethodName { get { return "tx.commit-ok"; } }
7133     public override bool HasContent { get { return false; } }
7134
7135     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7136     }
7137
7138     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7139     }
7140
7141     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7142       sb.Append("(");
7143       sb.Append(")");
7144     }
7145   }
7146   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7147   public class TxRollback: RabbitMQ.Client.Impl.MethodBase, ITxRollback {
7148     public const int ClassId = 90;
7149     public const int MethodId = 30;
7150
7151
7152
7153     public TxRollback(
7154 )
7155     {
7156     }
7157
7158     public override int ProtocolClassId { get { return 90; } }
7159     public override int ProtocolMethodId { get { return 30; } }
7160     public override string ProtocolMethodName { get { return "tx.rollback"; } }
7161     public override bool HasContent { get { return false; } }
7162
7163     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7164     }
7165
7166     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7167     }
7168
7169     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7170       sb.Append("(");
7171       sb.Append(")");
7172     }
7173   }
7174   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7175   public class TxRollbackOk: RabbitMQ.Client.Impl.MethodBase, ITxRollbackOk {
7176     public const int ClassId = 90;
7177     public const int MethodId = 31;
7178
7179
7180
7181     public TxRollbackOk(
7182 )
7183     {
7184     }
7185
7186     public override int ProtocolClassId { get { return 90; } }
7187     public override int ProtocolMethodId { get { return 31; } }
7188     public override string ProtocolMethodName { get { return "tx.rollback-ok"; } }
7189     public override bool HasContent { get { return false; } }
7190
7191     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7192     }
7193
7194     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7195     }
7196
7197     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7198       sb.Append("(");
7199       sb.Append(")");
7200     }
7201   }
7202   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7203   public class DtxSelect: RabbitMQ.Client.Impl.MethodBase, IDtxSelect {
7204     public const int ClassId = 100;
7205     public const int MethodId = 10;
7206
7207
7208
7209     public DtxSelect(
7210 )
7211     {
7212     }
7213
7214     public override int ProtocolClassId { get { return 100; } }
7215     public override int ProtocolMethodId { get { return 10; } }
7216     public override string ProtocolMethodName { get { return "dtx.select"; } }
7217     public override bool HasContent { get { return false; } }
7218
7219     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7220     }
7221
7222     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7223     }
7224
7225     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7226       sb.Append("(");
7227       sb.Append(")");
7228     }
7229   }
7230   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7231   public class DtxSelectOk: RabbitMQ.Client.Impl.MethodBase, IDtxSelectOk {
7232     public const int ClassId = 100;
7233     public const int MethodId = 11;
7234
7235
7236
7237     public DtxSelectOk(
7238 )
7239     {
7240     }
7241
7242     public override int ProtocolClassId { get { return 100; } }
7243     public override int ProtocolMethodId { get { return 11; } }
7244     public override string ProtocolMethodName { get { return "dtx.select-ok"; } }
7245     public override bool HasContent { get { return false; } }
7246
7247     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7248     }
7249
7250     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7251     }
7252
7253     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7254       sb.Append("(");
7255       sb.Append(")");
7256     }
7257   }
7258   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7259   public class DtxStart: RabbitMQ.Client.Impl.MethodBase, IDtxStart {
7260     public const int ClassId = 100;
7261     public const int MethodId = 20;
7262
7263     public string m_dtxIdentifier;
7264
7265     string IDtxStart.DtxIdentifier { get { return m_dtxIdentifier; } }
7266
7267     public DtxStart() {}
7268     public DtxStart(
7269       string initDtxIdentifier)
7270     {
7271       m_dtxIdentifier = initDtxIdentifier;
7272     }
7273
7274     public override int ProtocolClassId { get { return 100; } }
7275     public override int ProtocolMethodId { get { return 20; } }
7276     public override string ProtocolMethodName { get { return "dtx.start"; } }
7277     public override bool HasContent { get { return false; } }
7278
7279     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7280       m_dtxIdentifier = reader.ReadShortstr();
7281     }
7282
7283     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7284       writer.WriteShortstr(m_dtxIdentifier);
7285     }
7286
7287     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7288       sb.Append("(");
7289       sb.Append(m_dtxIdentifier);
7290       sb.Append(")");
7291     }
7292   }
7293   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7294   public class DtxStartOk: RabbitMQ.Client.Impl.MethodBase, IDtxStartOk {
7295     public const int ClassId = 100;
7296     public const int MethodId = 21;
7297
7298
7299
7300     public DtxStartOk(
7301 )
7302     {
7303     }
7304
7305     public override int ProtocolClassId { get { return 100; } }
7306     public override int ProtocolMethodId { get { return 21; } }
7307     public override string ProtocolMethodName { get { return "dtx.start-ok"; } }
7308     public override bool HasContent { get { return false; } }
7309
7310     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7311     }
7312
7313     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7314     }
7315
7316     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7317       sb.Append("(");
7318       sb.Append(")");
7319     }
7320   }
7321   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7322   public class TunnelRequest: RabbitMQ.Client.Impl.MethodBase, ITunnelRequest {
7323     public const int ClassId = 110;
7324     public const int MethodId = 10;
7325
7326     public System.Collections.IDictionary m_metaData;
7327
7328     System.Collections.IDictionary ITunnelRequest.MetaData { get { return m_metaData; } }
7329
7330     public TunnelRequest() {}
7331     public TunnelRequest(
7332       System.Collections.IDictionary initMetaData)
7333     {
7334       m_metaData = initMetaData;
7335     }
7336
7337     public override int ProtocolClassId { get { return 110; } }
7338     public override int ProtocolMethodId { get { return 10; } }
7339     public override string ProtocolMethodName { get { return "tunnel.request"; } }
7340     public override bool HasContent { get { return true; } }
7341
7342     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7343       m_metaData = reader.ReadTable();
7344     }
7345
7346     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7347       writer.WriteTable(m_metaData);
7348     }
7349
7350     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7351       sb.Append("(");
7352       sb.Append(m_metaData);
7353       sb.Append(")");
7354     }
7355   }
7356   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7357   public class TestInteger: RabbitMQ.Client.Impl.MethodBase, ITestInteger {
7358     public const int ClassId = 120;
7359     public const int MethodId = 10;
7360
7361     public byte m_integer1;
7362     public ushort m_integer2;
7363     public uint m_integer3;
7364     public ulong m_integer4;
7365     public byte m_operation;
7366
7367     byte ITestInteger.Integer1 { get { return m_integer1; } }
7368     ushort ITestInteger.Integer2 { get { return m_integer2; } }
7369     uint ITestInteger.Integer3 { get { return m_integer3; } }
7370     ulong ITestInteger.Integer4 { get { return m_integer4; } }
7371     byte ITestInteger.Operation { get { return m_operation; } }
7372
7373     public TestInteger() {}
7374     public TestInteger(
7375       byte initInteger1,
7376       ushort initInteger2,
7377       uint initInteger3,
7378       ulong initInteger4,
7379       byte initOperation)
7380     {
7381       m_integer1 = initInteger1;
7382       m_integer2 = initInteger2;
7383       m_integer3 = initInteger3;
7384       m_integer4 = initInteger4;
7385       m_operation = initOperation;
7386     }
7387
7388     public override int ProtocolClassId { get { return 120; } }
7389     public override int ProtocolMethodId { get { return 10; } }
7390     public override string ProtocolMethodName { get { return "test.integer"; } }
7391     public override bool HasContent { get { return false; } }
7392
7393     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7394       m_integer1 = reader.ReadOctet();
7395       m_integer2 = reader.ReadShort();
7396       m_integer3 = reader.ReadLong();
7397       m_integer4 = reader.ReadLonglong();
7398       m_operation = reader.ReadOctet();
7399     }
7400
7401     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7402       writer.WriteOctet(m_integer1);
7403       writer.WriteShort(m_integer2);
7404       writer.WriteLong(m_integer3);
7405       writer.WriteLonglong(m_integer4);
7406       writer.WriteOctet(m_operation);
7407     }
7408
7409     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7410       sb.Append("(");
7411       sb.Append(m_integer1); sb.Append(",");
7412       sb.Append(m_integer2); sb.Append(",");
7413       sb.Append(m_integer3); sb.Append(",");
7414       sb.Append(m_integer4); sb.Append(",");
7415       sb.Append(m_operation);
7416       sb.Append(")");
7417     }
7418   }
7419   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7420   public class TestIntegerOk: RabbitMQ.Client.Impl.MethodBase, ITestIntegerOk {
7421     public const int ClassId = 120;
7422     public const int MethodId = 11;
7423
7424     public ulong m_result;
7425
7426     ulong ITestIntegerOk.Result { get { return m_result; } }
7427
7428     public TestIntegerOk() {}
7429     public TestIntegerOk(
7430       ulong initResult)
7431     {
7432       m_result = initResult;
7433     }
7434
7435     public override int ProtocolClassId { get { return 120; } }
7436     public override int ProtocolMethodId { get { return 11; } }
7437     public override string ProtocolMethodName { get { return "test.integer-ok"; } }
7438     public override bool HasContent { get { return false; } }
7439
7440     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7441       m_result = reader.ReadLonglong();
7442     }
7443
7444     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7445       writer.WriteLonglong(m_result);
7446     }
7447
7448     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7449       sb.Append("(");
7450       sb.Append(m_result);
7451       sb.Append(")");
7452     }
7453   }
7454   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7455   public class TestString: RabbitMQ.Client.Impl.MethodBase, ITestString {
7456     public const int ClassId = 120;
7457     public const int MethodId = 20;
7458
7459     public string m_string1;
7460     public byte[] m_string2;
7461     public byte m_operation;
7462
7463     string ITestString.String1 { get { return m_string1; } }
7464     byte[] ITestString.String2 { get { return m_string2; } }
7465     byte ITestString.Operation { get { return m_operation; } }
7466
7467     public TestString() {}
7468     public TestString(
7469       string initString1,
7470       byte[] initString2,
7471       byte initOperation)
7472     {
7473       m_string1 = initString1;
7474       m_string2 = initString2;
7475       m_operation = initOperation;
7476     }
7477
7478     public override int ProtocolClassId { get { return 120; } }
7479     public override int ProtocolMethodId { get { return 20; } }
7480     public override string ProtocolMethodName { get { return "test.string"; } }
7481     public override bool HasContent { get { return false; } }
7482
7483     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7484       m_string1 = reader.ReadShortstr();
7485       m_string2 = reader.ReadLongstr();
7486       m_operation = reader.ReadOctet();
7487     }
7488
7489     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7490       writer.WriteShortstr(m_string1);
7491       writer.WriteLongstr(m_string2);
7492       writer.WriteOctet(m_operation);
7493     }
7494
7495     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7496       sb.Append("(");
7497       sb.Append(m_string1); sb.Append(",");
7498       sb.Append(m_string2); sb.Append(",");
7499       sb.Append(m_operation);
7500       sb.Append(")");
7501     }
7502   }
7503   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7504   public class TestStringOk: RabbitMQ.Client.Impl.MethodBase, ITestStringOk {
7505     public const int ClassId = 120;
7506     public const int MethodId = 21;
7507
7508     public byte[] m_result;
7509
7510     byte[] ITestStringOk.Result { get { return m_result; } }
7511
7512     public TestStringOk() {}
7513     public TestStringOk(
7514       byte[] initResult)
7515     {
7516       m_result = initResult;
7517     }
7518
7519     public override int ProtocolClassId { get { return 120; } }
7520     public override int ProtocolMethodId { get { return 21; } }
7521     public override string ProtocolMethodName { get { return "test.string-ok"; } }
7522     public override bool HasContent { get { return false; } }
7523
7524     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7525       m_result = reader.ReadLongstr();
7526     }
7527
7528     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7529       writer.WriteLongstr(m_result);
7530     }
7531
7532     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7533       sb.Append("(");
7534       sb.Append(m_result);
7535       sb.Append(")");
7536     }
7537   }
7538   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7539   public class TestTable: RabbitMQ.Client.Impl.MethodBase, ITestTable {
7540     public const int ClassId = 120;
7541     public const int MethodId = 30;
7542
7543     public System.Collections.IDictionary m_table;
7544     public byte m_integerOp;
7545     public byte m_stringOp;
7546
7547     System.Collections.IDictionary ITestTable.Table { get { return m_table; } }
7548     byte ITestTable.IntegerOp { get { return m_integerOp; } }
7549     byte ITestTable.StringOp { get { return m_stringOp; } }
7550
7551     public TestTable() {}
7552     public TestTable(
7553       System.Collections.IDictionary initTable,
7554       byte initIntegerOp,
7555       byte initStringOp)
7556     {
7557       m_table = initTable;
7558       m_integerOp = initIntegerOp;
7559       m_stringOp = initStringOp;
7560     }
7561
7562     public override int ProtocolClassId { get { return 120; } }
7563     public override int ProtocolMethodId { get { return 30; } }
7564     public override string ProtocolMethodName { get { return "test.table"; } }
7565     public override bool HasContent { get { return false; } }
7566
7567     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7568       m_table = reader.ReadTable();
7569       m_integerOp = reader.ReadOctet();
7570       m_stringOp = reader.ReadOctet();
7571     }
7572
7573     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7574       writer.WriteTable(m_table);
7575       writer.WriteOctet(m_integerOp);
7576       writer.WriteOctet(m_stringOp);
7577     }
7578
7579     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7580       sb.Append("(");
7581       sb.Append(m_table); sb.Append(",");
7582       sb.Append(m_integerOp); sb.Append(",");
7583       sb.Append(m_stringOp);
7584       sb.Append(")");
7585     }
7586   }
7587   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7588   public class TestTableOk: RabbitMQ.Client.Impl.MethodBase, ITestTableOk {
7589     public const int ClassId = 120;
7590     public const int MethodId = 31;
7591
7592     public ulong m_integerResult;
7593     public byte[] m_stringResult;
7594
7595     ulong ITestTableOk.IntegerResult { get { return m_integerResult; } }
7596     byte[] ITestTableOk.StringResult { get { return m_stringResult; } }
7597
7598     public TestTableOk() {}
7599     public TestTableOk(
7600       ulong initIntegerResult,
7601       byte[] initStringResult)
7602     {
7603       m_integerResult = initIntegerResult;
7604       m_stringResult = initStringResult;
7605     }
7606
7607     public override int ProtocolClassId { get { return 120; } }
7608     public override int ProtocolMethodId { get { return 31; } }
7609     public override string ProtocolMethodName { get { return "test.table-ok"; } }
7610     public override bool HasContent { get { return false; } }
7611
7612     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7613       m_integerResult = reader.ReadLonglong();
7614       m_stringResult = reader.ReadLongstr();
7615     }
7616
7617     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7618       writer.WriteLonglong(m_integerResult);
7619       writer.WriteLongstr(m_stringResult);
7620     }
7621
7622     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7623       sb.Append("(");
7624       sb.Append(m_integerResult); sb.Append(",");
7625       sb.Append(m_stringResult);
7626       sb.Append(")");
7627     }
7628   }
7629   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7630   public class TestContent: RabbitMQ.Client.Impl.MethodBase, ITestContent {
7631     public const int ClassId = 120;
7632     public const int MethodId = 40;
7633
7634
7635
7636     public TestContent(
7637 )
7638     {
7639     }
7640
7641     public override int ProtocolClassId { get { return 120; } }
7642     public override int ProtocolMethodId { get { return 40; } }
7643     public override string ProtocolMethodName { get { return "test.content"; } }
7644     public override bool HasContent { get { return true; } }
7645
7646     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7647     }
7648
7649     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7650     }
7651
7652     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7653       sb.Append("(");
7654       sb.Append(")");
7655     }
7656   }
7657   /// <summary>Autogenerated type. Private implementation class - do not use directly.</summary>
7658   public class TestContentOk: RabbitMQ.Client.Impl.MethodBase, ITestContentOk {
7659     public const int ClassId = 120;
7660     public const int MethodId = 41;
7661
7662     public uint m_contentChecksum;
7663
7664     uint ITestContentOk.ContentChecksum { get { return m_contentChecksum; } }
7665
7666     public TestContentOk() {}
7667     public TestContentOk(
7668       uint initContentChecksum)
7669     {
7670       m_contentChecksum = initContentChecksum;
7671     }
7672
7673     public override int ProtocolClassId { get { return 120; } }
7674     public override int ProtocolMethodId { get { return 41; } }
7675     public override string ProtocolMethodName { get { return "test.content-ok"; } }
7676     public override bool HasContent { get { return true; } }
7677
7678     public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader) {
7679       m_contentChecksum = reader.ReadLong();
7680     }
7681
7682     public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer) {
7683       writer.WriteLong(m_contentChecksum);
7684     }
7685
7686     public override void AppendArgumentDebugStringTo(System.Text.StringBuilder sb) {
7687       sb.Append("(");
7688       sb.Append(m_contentChecksum);
7689       sb.Append(")");
7690     }
7691   }
7692
7693   public class Model: RabbitMQ.Client.Impl.ModelBase {
7694     public Model(RabbitMQ.Client.Impl.ISession session): base(session) {}
7695     public override void _Private_BasicPublish(
7696       System.String @exchange,
7697       System.String @routingKey,
7698       System.Boolean @mandatory,
7699       System.Boolean @immediate,
7700       RabbitMQ.Client.IBasicProperties @basicProperties,
7701       System.Byte[] @body)
7702     {
7703       BasicPublish __req = new BasicPublish();
7704       __req.m_exchange = @exchange;
7705       __req.m_routingKey = @routingKey;
7706       __req.m_mandatory = @mandatory;
7707       __req.m_immediate = @immediate;
7708       ModelSend(__req, (BasicProperties) basicProperties,body);
7709     }
7710     public override void _Private_BasicConsume(
7711       System.String @queue,
7712       System.String @consumerTag,
7713       System.Boolean @noLocal,
7714       System.Boolean @noAck,
7715       System.Boolean @exclusive,
7716       System.Boolean @nowait,
7717       System.Collections.IDictionary @filter)
7718     {
7719       BasicConsume __req = new BasicConsume();
7720       __req.m_queue = @queue;
7721       __req.m_consumerTag = @consumerTag;
7722       __req.m_noLocal = @noLocal;
7723       __req.m_noAck = @noAck;
7724       __req.m_exclusive = @exclusive;
7725       __req.m_nowait = @nowait;
7726       if (@filter != null) {
7727         throw new UnsupportedMethodFieldException("_Private_BasicConsume","filter");
7728       }
7729       ModelSend(__req,null,null);
7730     }
7731     public override void _Private_BasicCancel(
7732       System.String @consumerTag,
7733       System.Boolean @nowait)
7734     {
7735       BasicCancel __req = new BasicCancel();
7736       __req.m_consumerTag = @consumerTag;
7737       __req.m_nowait = @nowait;
7738       ModelSend(__req,null,null);
7739     }
7740     public override void _Private_ChannelOpen(
7741       System.String @outOfBand)
7742     {
7743       ChannelOpen __req = new ChannelOpen();
7744       __req.m_outOfBand = @outOfBand;
7745       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7746       ChannelOpenOk __rep = __repBase as ChannelOpenOk;
7747       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7748     }
7749     public override void _Private_ChannelCloseOk()
7750     {
7751       ChannelCloseOk __req = new ChannelCloseOk();
7752       ModelSend(__req,null,null);
7753     }
7754     public override void _Private_ChannelClose(
7755       System.UInt16 @replyCode,
7756       System.String @replyText,
7757       System.UInt16 @classId,
7758       System.UInt16 @methodId)
7759     {
7760       ChannelClose __req = new ChannelClose();
7761       __req.m_replyCode = @replyCode;
7762       __req.m_replyText = @replyText;
7763       __req.m_classId = @classId;
7764       __req.m_methodId = @methodId;
7765       ModelSend(__req,null,null);
7766     }
7767     public override void _Private_BasicGet(
7768       System.String @queue,
7769       System.Boolean @noAck)
7770     {
7771       BasicGet __req = new BasicGet();
7772       __req.m_queue = @queue;
7773       __req.m_noAck = @noAck;
7774       ModelSend(__req,null,null);
7775     }
7776     public override void _Private_ChannelFlowOk()
7777     {
7778       ChannelFlowOk __req = new ChannelFlowOk();
7779       ModelSend(__req,null,null);
7780     }
7781     public override RabbitMQ.Client.Impl.ConnectionTuneDetails ConnectionStartOk(
7782       System.Collections.IDictionary @clientProperties,
7783       System.String @mechanism,
7784       System.Byte[] @response,
7785       System.String @locale)
7786     {
7787       ConnectionStartOk __req = new ConnectionStartOk();
7788       __req.m_clientProperties = @clientProperties;
7789       __req.m_mechanism = @mechanism;
7790       __req.m_response = @response;
7791       __req.m_locale = @locale;
7792       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7793       ConnectionTune __rep = __repBase as ConnectionTune;
7794       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7795       RabbitMQ.Client.Impl.ConnectionTuneDetails __result = new RabbitMQ.Client.Impl.ConnectionTuneDetails();
7796       __result.channelMax = __rep.m_channelMax;
7797       __result.frameMax = __rep.m_frameMax;
7798       __result.heartbeat = __rep.m_heartbeat;
7799       return __result;
7800     }
7801     public override void ConnectionTuneOk(
7802       System.UInt16 @channelMax,
7803       System.UInt32 @frameMax,
7804       System.UInt16 @heartbeat)
7805     {
7806       ConnectionTuneOk __req = new ConnectionTuneOk();
7807       __req.m_channelMax = @channelMax;
7808       __req.m_frameMax = @frameMax;
7809       __req.m_heartbeat = @heartbeat;
7810       ModelSend(__req,null,null);
7811     }
7812     public override void _Private_ConnectionOpen(
7813       System.String @virtualHost,
7814       System.String @capabilities,
7815       System.Boolean @insist)
7816     {
7817       ConnectionOpen __req = new ConnectionOpen();
7818       __req.m_virtualHost = @virtualHost;
7819       __req.m_capabilities = @capabilities;
7820       __req.m_insist = @insist;
7821       ModelSend(__req,null,null);
7822     }
7823     public override void _Private_ConnectionClose(
7824       System.UInt16 @replyCode,
7825       System.String @replyText,
7826       System.UInt16 @classId,
7827       System.UInt16 @methodId)
7828     {
7829       ConnectionClose __req = new ConnectionClose();
7830       __req.m_replyCode = @replyCode;
7831       __req.m_replyText = @replyText;
7832       __req.m_classId = @classId;
7833       __req.m_methodId = @methodId;
7834       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7835       ConnectionCloseOk __rep = __repBase as ConnectionCloseOk;
7836       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7837     }
7838     public override void _Private_ConnectionCloseOk()
7839     {
7840       ConnectionCloseOk __req = new ConnectionCloseOk();
7841       ModelSend(__req,null,null);
7842     }
7843     public override RabbitMQ.Client.IBasicProperties CreateBasicProperties()
7844     {
7845       return new BasicProperties();
7846     }
7847     public override RabbitMQ.Client.IFileProperties CreateFileProperties()
7848     {
7849       return new FileProperties();
7850     }
7851     public override RabbitMQ.Client.IStreamProperties CreateStreamProperties()
7852     {
7853       return new StreamProperties();
7854     }
7855     public override void ChannelFlow(
7856       System.Boolean @active)
7857     {
7858       ChannelFlow __req = new ChannelFlow();
7859       __req.m_active = @active;
7860       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7861       ChannelFlowOk __rep = __repBase as ChannelFlowOk;
7862       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7863     }
7864     public override void ExchangeDeclare(
7865       System.String @exchange,
7866       System.String @type,
7867       System.Boolean @passive,
7868       System.Boolean @durable,
7869       System.Boolean @autoDelete,
7870       System.Boolean @internal,
7871       System.Boolean @nowait,
7872       System.Collections.IDictionary @arguments)
7873     {
7874       ExchangeDeclare __req = new ExchangeDeclare();
7875       __req.m_exchange = @exchange;
7876       __req.m_type = @type;
7877       __req.m_passive = @passive;
7878       __req.m_durable = @durable;
7879       __req.m_autoDelete = @autoDelete;
7880       __req.m_internal = @internal;
7881       __req.m_nowait = @nowait;
7882       __req.m_arguments = @arguments;
7883       if (nowait) {
7884         ModelSend(__req,null,null);
7885       }
7886       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7887       ExchangeDeclareOk __rep = __repBase as ExchangeDeclareOk;
7888       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7889     }
7890     public override void ExchangeDelete(
7891       System.String @exchange,
7892       System.Boolean @ifUnused,
7893       System.Boolean @nowait)
7894     {
7895       ExchangeDelete __req = new ExchangeDelete();
7896       __req.m_exchange = @exchange;
7897       __req.m_ifUnused = @ifUnused;
7898       __req.m_nowait = @nowait;
7899       if (nowait) {
7900         ModelSend(__req,null,null);
7901       }
7902       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7903       ExchangeDeleteOk __rep = __repBase as ExchangeDeleteOk;
7904       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7905     }
7906     public override System.String QueueDeclare(
7907       System.String @queue,
7908       System.Boolean @passive,
7909       System.Boolean @durable,
7910       System.Boolean @exclusive,
7911       System.Boolean @autoDelete,
7912       System.Boolean @nowait,
7913       System.Collections.IDictionary @arguments)
7914     {
7915       QueueDeclare __req = new QueueDeclare();
7916       __req.m_queue = @queue;
7917       __req.m_passive = @passive;
7918       __req.m_durable = @durable;
7919       __req.m_exclusive = @exclusive;
7920       __req.m_autoDelete = @autoDelete;
7921       __req.m_nowait = @nowait;
7922       __req.m_arguments = @arguments;
7923       if (nowait) {
7924         ModelSend(__req,null,null);
7925         return null;
7926       }
7927       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7928       QueueDeclareOk __rep = __repBase as QueueDeclareOk;
7929       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7930       return __rep.m_queue;
7931     }
7932     public override void QueueBind(
7933       System.String @queue,
7934       System.String @exchange,
7935       System.String @routingKey,
7936       System.Boolean @nowait,
7937       System.Collections.IDictionary @arguments)
7938     {
7939       QueueBind __req = new QueueBind();
7940       __req.m_queue = @queue;
7941       __req.m_exchange = @exchange;
7942       __req.m_routingKey = @routingKey;
7943       __req.m_nowait = @nowait;
7944       __req.m_arguments = @arguments;
7945       if (nowait) {
7946         ModelSend(__req,null,null);
7947       }
7948       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7949       QueueBindOk __rep = __repBase as QueueBindOk;
7950       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7951     }
7952     public override void QueueUnbind(
7953       System.String @queue,
7954       System.String @exchange,
7955       System.String @routingKey,
7956       System.Collections.IDictionary @arguments)
7957     {
7958       QueueUnbind __req = new QueueUnbind();
7959       __req.m_queue = @queue;
7960       __req.m_exchange = @exchange;
7961       __req.m_routingKey = @routingKey;
7962       __req.m_arguments = @arguments;
7963       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7964       QueueUnbindOk __rep = __repBase as QueueUnbindOk;
7965       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7966     }
7967     public override System.UInt32 QueuePurge(
7968       System.String @queue,
7969       System.Boolean @nowait)
7970     {
7971       QueuePurge __req = new QueuePurge();
7972       __req.m_queue = @queue;
7973       __req.m_nowait = @nowait;
7974       if (nowait) {
7975         ModelSend(__req,null,null);
7976         return 0xFFFFFFFF;
7977       }
7978       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7979       QueuePurgeOk __rep = __repBase as QueuePurgeOk;
7980       if (__rep == null) throw new UnexpectedMethodException(__repBase);
7981       return __rep.m_messageCount;
7982     }
7983     public override System.UInt32 QueueDelete(
7984       System.String @queue,
7985       System.Boolean @ifUnused,
7986       System.Boolean @ifEmpty,
7987       System.Boolean @nowait)
7988     {
7989       QueueDelete __req = new QueueDelete();
7990       __req.m_queue = @queue;
7991       __req.m_ifUnused = @ifUnused;
7992       __req.m_ifEmpty = @ifEmpty;
7993       __req.m_nowait = @nowait;
7994       if (nowait) {
7995         ModelSend(__req,null,null);
7996         return 0xFFFFFFFF;
7997       }
7998       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
7999       QueueDeleteOk __rep = __repBase as QueueDeleteOk;
8000       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8001       return __rep.m_messageCount;
8002     }
8003     public override void BasicQos(
8004       System.UInt32 @prefetchSize,
8005       System.UInt16 @prefetchCount,
8006       System.Boolean @global)
8007     {
8008       BasicQos __req = new BasicQos();
8009       __req.m_prefetchSize = @prefetchSize;
8010       __req.m_prefetchCount = @prefetchCount;
8011       __req.m_global = @global;
8012       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8013       BasicQosOk __rep = __repBase as BasicQosOk;
8014       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8015     }
8016     public override void BasicAck(
8017       System.UInt64 @deliveryTag,
8018       System.Boolean @multiple)
8019     {
8020       BasicAck __req = new BasicAck();
8021       __req.m_deliveryTag = @deliveryTag;
8022       __req.m_multiple = @multiple;
8023       ModelSend(__req,null,null);
8024     }
8025     public override void BasicReject(
8026       System.UInt64 @deliveryTag,
8027       System.Boolean @requeue)
8028     {
8029       BasicReject __req = new BasicReject();
8030       __req.m_deliveryTag = @deliveryTag;
8031       __req.m_requeue = @requeue;
8032       ModelSend(__req,null,null);
8033     }
8034     public override void BasicRecover(
8035       System.Boolean @requeue)
8036     {
8037       BasicRecover __req = new BasicRecover();
8038       __req.m_requeue = @requeue;
8039       ModelSend(__req,null,null);
8040     }
8041     public override void TxSelect()
8042     {
8043       TxSelect __req = new TxSelect();
8044       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8045       TxSelectOk __rep = __repBase as TxSelectOk;
8046       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8047     }
8048     public override void TxCommit()
8049     {
8050       TxCommit __req = new TxCommit();
8051       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8052       TxCommitOk __rep = __repBase as TxCommitOk;
8053       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8054     }
8055     public override void TxRollback()
8056     {
8057       TxRollback __req = new TxRollback();
8058       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8059       TxRollbackOk __rep = __repBase as TxRollbackOk;
8060       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8061     }
8062     public override void DtxSelect()
8063     {
8064       DtxSelect __req = new DtxSelect();
8065       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8066       DtxSelectOk __rep = __repBase as DtxSelectOk;
8067       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8068     }
8069     public override void DtxStart(
8070       System.String @dtxIdentifier)
8071     {
8072       DtxStart __req = new DtxStart();
8073       __req.m_dtxIdentifier = @dtxIdentifier;
8074       RabbitMQ.Client.Impl.MethodBase __repBase = ModelRpc(__req,null,null);
8075       DtxStartOk __rep = __repBase as DtxStartOk;
8076       if (__rep == null) throw new UnexpectedMethodException(__repBase);
8077     }
8078     public override bool DispatchAsynchronous(RabbitMQ.Client.Impl.Command cmd) {
8079       RabbitMQ.Client.Impl.MethodBase __method = (RabbitMQ.Client.Impl.MethodBase) cmd.Method;
8080       switch ((__method.ProtocolClassId << 16) | __method.ProtocolMethodId) {
8081         case 3932181: {
8082           BasicConsumeOk __impl = (BasicConsumeOk) __method;
8083           HandleBasicConsumeOk(
8084             __impl.m_consumerTag);
8085           return true;
8086         }
8087         case 3932191: {
8088           BasicCancelOk __impl = (BasicCancelOk) __method;
8089           HandleBasicCancelOk(
8090             __impl.m_consumerTag);
8091           return true;
8092         }
8093         case 3932231: {
8094           BasicGetOk __impl = (BasicGetOk) __method;
8095           HandleBasicGetOk(
8096             __impl.m_deliveryTag,
8097             __impl.m_redelivered,
8098             __impl.m_exchange,
8099             __impl.m_routingKey,
8100             __impl.m_messageCount,
8101             (RabbitMQ.Client.IBasicProperties) cmd.Header,
8102             cmd.Body);
8103           return true;
8104         }
8105         case 3932232: {
8106           HandleBasicGetEmpty();
8107           return true;
8108         }
8109         case 3932220: {
8110           BasicDeliver __impl = (BasicDeliver) __method;
8111           HandleBasicDeliver(
8112             __impl.m_consumerTag,
8113             __impl.m_deliveryTag,
8114             __impl.m_redelivered,
8115             __impl.m_exchange,
8116             __impl.m_routingKey,
8117             (RabbitMQ.Client.IBasicProperties) cmd.Header,
8118             cmd.Body);
8119           return true;
8120         }
8121         case 3932210: {
8122           BasicReturn __impl = (BasicReturn) __method;
8123           HandleBasicReturn(
8124             __impl.m_replyCode,
8125             __impl.m_replyText,
8126             __impl.m_exchange,
8127             __impl.m_routingKey,
8128             (RabbitMQ.Client.IBasicProperties) cmd.Header,
8129             cmd.Body);
8130           return true;
8131         }
8132         case 1310740: {
8133           ChannelFlow __impl = (ChannelFlow) __method;
8134           HandleChannelFlow(
8135             __impl.m_active);
8136           return true;
8137         }
8138         case 1310760: {
8139           ChannelClose __impl = (ChannelClose) __method;
8140           HandleChannelClose(
8141             __impl.m_replyCode,
8142             __impl.m_replyText,
8143             __impl.m_classId,
8144             __impl.m_methodId);
8145           return true;
8146         }
8147         case 1310761: {
8148           HandleChannelCloseOk();
8149           return true;
8150         }
8151         case 655370: {
8152           ConnectionStart __impl = (ConnectionStart) __method;
8153           HandleConnectionStart(
8154             __impl.m_versionMajor,
8155             __impl.m_versionMinor,
8156             __impl.m_serverProperties,
8157             __impl.m_mechanisms,
8158             __impl.m_locales);
8159           return true;
8160         }
8161         case 655401: {
8162           ConnectionOpenOk __impl = (ConnectionOpenOk) __method;
8163           HandleConnectionOpenOk(
8164             __impl.m_knownHosts);
8165           return true;
8166         }
8167         case 655410: {
8168           ConnectionRedirect __impl = (ConnectionRedirect) __method;
8169           HandleConnectionRedirect(
8170             __impl.m_host,
8171             __impl.m_knownHosts);
8172           return true;
8173         }
8174         case 655420: {
8175           ConnectionClose __impl = (ConnectionClose) __method;
8176           HandleConnectionClose(
8177             __impl.m_replyCode,
8178             __impl.m_replyText,
8179             __impl.m_classId,
8180             __impl.m_methodId);
8181           return true;
8182         }
8183         default: return false;
8184       }
8185     }
8186   }
8187 }