// This source code is dual-licensed under the Mozilla Public License ("MPL"),
// version 1.1 and the Apache License ("ASL"), version 2.0.
//
// The ASL v2.0:
//
// ---------------------------------------------------------------------------
// Copyright 2016 Pivotal Software, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ---------------------------------------------------------------------------
//
// The MPL v1.1:
//
// ---------------------------------------------------------------------------
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// https://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
// License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is RabbitMQ
//
// The Initial Developer of the Original Code is Pivotal Software, Inc.
// All Rights Reserved.
//
// Alternatively, the contents of this file may be used under the terms
// of the Apache Standard license (the "ASL License"), in which case the
// provisions of the ASL License are applicable instead of those
// above. If you wish to allow use of your version of this file only
// under the terms of the ASL License and not to allow others to use
// your version of this file under the MPL, indicate your decision by
// deleting the provisions above and replace them with the notice and
// other provisions required by the ASL License. If you do not delete
// the provisions above, a recipient may use your version of this file
// under either the MPL or the ASL License.
// ---------------------------------------------------------------------------

// This file is generated. Do not edit.
#import <Foundation/Foundation.h>
#import "RMQTable.h"

@interface RMQConnectionStart : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQOctet *versionMajor;
@property (nonnull, copy, nonatomic, readonly) RMQOctet *versionMinor;
@property (nonnull, copy, nonatomic, readonly) RMQTable *serverProperties;
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *mechanisms;
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *locales;
- (nonnull instancetype)initWithVersionMajor:(nonnull RMQOctet *)versionMajor
                                versionMinor:(nonnull RMQOctet *)versionMinor
                            serverProperties:(nonnull RMQTable *)serverProperties
                                  mechanisms:(nonnull RMQLongstr *)mechanisms
                                     locales:(nonnull RMQLongstr *)locales;
@end

@interface RMQConnectionStartOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQTable *clientProperties;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *mechanism;
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *response;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *locale;
- (nonnull instancetype)initWithClientProperties:(nonnull RMQTable *)clientProperties
                                       mechanism:(nonnull RMQShortstr *)mechanism
                                        response:(nonnull RMQLongstr *)response
                                          locale:(nonnull RMQShortstr *)locale;
@end

@interface RMQConnectionSecure : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *challenge;
- (nonnull instancetype)initWithChallenge:(nonnull RMQLongstr *)challenge;
@end

@interface RMQConnectionSecureOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *response;
- (nonnull instancetype)initWithResponse:(nonnull RMQLongstr *)response;
@end

@interface RMQConnectionTune : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *channelMax;
@property (nonnull, copy, nonatomic, readonly) RMQLong *frameMax;
@property (nonnull, copy, nonatomic, readonly) RMQShort *heartbeat;
- (nonnull instancetype)initWithChannelMax:(nonnull RMQShort *)channelMax
                                  frameMax:(nonnull RMQLong *)frameMax
                                 heartbeat:(nonnull RMQShort *)heartbeat;
@end

@interface RMQConnectionTuneOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *channelMax;
@property (nonnull, copy, nonatomic, readonly) RMQLong *frameMax;
@property (nonnull, copy, nonatomic, readonly) RMQShort *heartbeat;
- (nonnull instancetype)initWithChannelMax:(nonnull RMQShort *)channelMax
                                  frameMax:(nonnull RMQLong *)frameMax
                                 heartbeat:(nonnull RMQShort *)heartbeat;
@end

typedef NS_OPTIONS(NSUInteger, RMQConnectionOpenOptions) {
    RMQConnectionOpenNoOptions = 0,
    /// @brief
    RMQConnectionOpenReserved2 = 1 << 0,
};

@interface RMQConnectionOpen : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *virtualHost;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *reserved1;
@property (nonatomic, readonly) RMQConnectionOpenOptions options;
- (nonnull instancetype)initWithVirtualHost:(nonnull RMQShortstr *)virtualHost
                                  reserved1:(nonnull RMQShortstr *)reserved1
                                    options:(RMQConnectionOpenOptions)options;
@end

@interface RMQConnectionOpenOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *reserved1;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShortstr *)reserved1;
@end

@interface RMQConnectionClose : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *replyCode;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *replyText;
@property (nonnull, copy, nonatomic, readonly) RMQShort *classId;
@property (nonnull, copy, nonatomic, readonly) RMQShort *methodId;
- (nonnull instancetype)initWithReplyCode:(nonnull RMQShort *)replyCode
                                replyText:(nonnull RMQShortstr *)replyText
                                  classId:(nonnull RMQShort *)classId
                                 methodId:(nonnull RMQShort *)methodId;
@end

@interface RMQConnectionCloseOk : RMQValue <RMQMethod>

@end

@interface RMQConnectionBlocked : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *reason;
- (nonnull instancetype)initWithReason:(nonnull RMQShortstr *)reason;
@end

@interface RMQConnectionUnblocked : RMQValue <RMQMethod>

@end

@interface RMQChannelOpen : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *reserved1;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShortstr *)reserved1;
@end

@interface RMQChannelOpenOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLongstr *reserved1;
- (nonnull instancetype)initWithReserved1:(nonnull RMQLongstr *)reserved1;
@end

typedef NS_OPTIONS(NSUInteger, RMQChannelFlowOptions) {
    RMQChannelFlowNoOptions = 0,
    /// @brief If 1, the peer starts sending content frames. If 0, the peer stops sending content frames.
    RMQChannelFlowActive    = 1 << 0,
};

@interface RMQChannelFlow : RMQValue <RMQMethod>
@property (nonatomic, readonly) RMQChannelFlowOptions options;
- (nonnull instancetype)initWithOptions:(RMQChannelFlowOptions)options;
@end

typedef NS_OPTIONS(NSUInteger, RMQChannelFlowOkOptions) {
    RMQChannelFlowOkNoOptions = 0,
    /// @brief Confirms the setting of the processed flow method: 1 means the peer will start sending or continue to send content frames; 0 means it will not.
    RMQChannelFlowOkActive    = 1 << 0,
};

@interface RMQChannelFlowOk : RMQValue <RMQMethod>
@property (nonatomic, readonly) RMQChannelFlowOkOptions options;
- (nonnull instancetype)initWithOptions:(RMQChannelFlowOkOptions)options;
@end

@interface RMQChannelClose : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *replyCode;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *replyText;
@property (nonnull, copy, nonatomic, readonly) RMQShort *classId;
@property (nonnull, copy, nonatomic, readonly) RMQShort *methodId;
- (nonnull instancetype)initWithReplyCode:(nonnull RMQShort *)replyCode
                                replyText:(nonnull RMQShortstr *)replyText
                                  classId:(nonnull RMQShort *)classId
                                 methodId:(nonnull RMQShort *)methodId;
@end

@interface RMQChannelCloseOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQExchangeDeclareOptions) {
    RMQExchangeDeclareNoOptions  = 0,
    /// @brief If set, the server will reply with Declare-Ok if the exchange already exists with the same name, and raise an error if not. The client can use this to check whether an exchange exists without modifying the server state. When set, all other method fields except name and no-wait are ignored. A declare with both passive and no-wait has no effect. Arguments are compared for semantic equivalence.
    RMQExchangeDeclarePassive    = 1 << 0,
    /// @brief If set when creating a new exchange, the exchange will be marked as durable. Durable exchanges remain active when a server restarts. Non-durable exchanges (transient exchanges) are purged if/when a server restarts.
    RMQExchangeDeclareDurable    = 1 << 1,
    /// @brief If set, the exchange is deleted when all queues have finished using it.
    RMQExchangeDeclareAutoDelete = 1 << 2,
    /// @brief If set, the exchange may not be used directly by publishers, but only when bound to other exchanges. Internal exchanges are used to construct wiring that is not visible to applications.
    RMQExchangeDeclareInternal   = 1 << 3,
    /// @brief
    RMQExchangeDeclareNoWait     = 1 << 4,
};

@interface RMQExchangeDeclare : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *type;
@property (nonatomic, readonly) RMQExchangeDeclareOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                 exchange:(nonnull RMQShortstr *)exchange
                                     type:(nonnull RMQShortstr *)type
                                  options:(RMQExchangeDeclareOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQExchangeDeclareOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQExchangeDeleteOptions) {
    RMQExchangeDeleteNoOptions = 0,
    /// @brief If set, the server will only delete the exchange if it has no queue bindings. If the exchange has queue bindings the server does not delete it but raises a channel exception instead.
    RMQExchangeDeleteIfUnused  = 1 << 0,
    /// @brief
    RMQExchangeDeleteNoWait    = 1 << 1,
};

@interface RMQExchangeDelete : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonatomic, readonly) RMQExchangeDeleteOptions options;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                 exchange:(nonnull RMQShortstr *)exchange
                                  options:(RMQExchangeDeleteOptions)options;
@end

@interface RMQExchangeDeleteOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQExchangeBindOptions) {
    RMQExchangeBindNoOptions = 0,
    /// @brief
    RMQExchangeBindNoWait    = 1 << 0,
};

@interface RMQExchangeBind : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *destination;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *source;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonatomic, readonly) RMQExchangeBindOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                              destination:(nonnull RMQShortstr *)destination
                                   source:(nonnull RMQShortstr *)source
                               routingKey:(nonnull RMQShortstr *)routingKey
                                  options:(RMQExchangeBindOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQExchangeBindOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQExchangeUnbindOptions) {
    RMQExchangeUnbindNoOptions = 0,
    /// @brief
    RMQExchangeUnbindNoWait    = 1 << 0,
};

@interface RMQExchangeUnbind : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *destination;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *source;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonatomic, readonly) RMQExchangeUnbindOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                              destination:(nonnull RMQShortstr *)destination
                                   source:(nonnull RMQShortstr *)source
                               routingKey:(nonnull RMQShortstr *)routingKey
                                  options:(RMQExchangeUnbindOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQExchangeUnbindOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQQueueDeclareOptions) {
    RMQQueueDeclareNoOptions  = 0,
    /// @brief If set, the server will reply with Declare-Ok if the queue already exists with the same name, and raise an error if not. The client can use this to check whether a queue exists without modifying the server state. When set, all other method fields except name and no-wait are ignored. A declare with both passive and no-wait has no effect. Arguments are compared for semantic equivalence.
    RMQQueueDeclarePassive    = 1 << 0,
    /// @brief If set when creating a new queue, the queue will be marked as durable. Durable queues remain active when a server restarts. Non-durable queues (transient queues) are purged if/when a server restarts. Note that durable queues do not necessarily hold persistent messages, although it does not make sense to send persistent messages to a transient queue.
    RMQQueueDeclareDurable    = 1 << 1,
    /// @brief Exclusive queues may only be accessed by the current connection, and are deleted when that connection closes. Passive declaration of an exclusive queue by other connections are not allowed.
    RMQQueueDeclareExclusive  = 1 << 2,
    /// @brief If set, the queue is deleted when all consumers have finished using it. The last consumer can be cancelled either explicitly or because its channel is closed. If there was no consumer ever on the queue, it won't be deleted. Applications can explicitly delete auto-delete queues using the Delete method as normal.
    RMQQueueDeclareAutoDelete = 1 << 3,
    /// @brief
    RMQQueueDeclareNoWait     = 1 << 4,
};

@interface RMQQueueDeclare : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonatomic, readonly) RMQQueueDeclareOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                  options:(RMQQueueDeclareOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQQueueDeclareOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonnull, copy, nonatomic, readonly) RMQLong *messageCount;
@property (nonnull, copy, nonatomic, readonly) RMQLong *consumerCount;
- (nonnull instancetype)initWithQueue:(nonnull RMQShortstr *)queue
                         messageCount:(nonnull RMQLong *)messageCount
                        consumerCount:(nonnull RMQLong *)consumerCount;
@end

typedef NS_OPTIONS(NSUInteger, RMQQueueBindOptions) {
    RMQQueueBindNoOptions = 0,
    /// @brief
    RMQQueueBindNoWait    = 1 << 0,
};

@interface RMQQueueBind : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonatomic, readonly) RMQQueueBindOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                 exchange:(nonnull RMQShortstr *)exchange
                               routingKey:(nonnull RMQShortstr *)routingKey
                                  options:(RMQQueueBindOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQQueueBindOk : RMQValue <RMQMethod>

@end

@interface RMQQueueUnbind : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                 exchange:(nonnull RMQShortstr *)exchange
                               routingKey:(nonnull RMQShortstr *)routingKey
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQQueueUnbindOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQQueuePurgeOptions) {
    RMQQueuePurgeNoOptions = 0,
    /// @brief
    RMQQueuePurgeNoWait    = 1 << 0,
};

@interface RMQQueuePurge : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonatomic, readonly) RMQQueuePurgeOptions options;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                  options:(RMQQueuePurgeOptions)options;
@end

@interface RMQQueuePurgeOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLong *messageCount;
- (nonnull instancetype)initWithMessageCount:(nonnull RMQLong *)messageCount;
@end

typedef NS_OPTIONS(NSUInteger, RMQQueueDeleteOptions) {
    RMQQueueDeleteNoOptions = 0,
    /// @brief If set, the server will only delete the queue if it has no consumers. If the queue has consumers the server does does not delete it but raises a channel exception instead.
    RMQQueueDeleteIfUnused  = 1 << 0,
    /// @brief If set, the server will only delete the queue if it has no messages.
    RMQQueueDeleteIfEmpty   = 1 << 1,
    /// @brief
    RMQQueueDeleteNoWait    = 1 << 2,
};

@interface RMQQueueDelete : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonatomic, readonly) RMQQueueDeleteOptions options;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                  options:(RMQQueueDeleteOptions)options;
@end

@interface RMQQueueDeleteOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLong *messageCount;
- (nonnull instancetype)initWithMessageCount:(nonnull RMQLong *)messageCount;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicQosOptions) {
    RMQBasicQosNoOptions = 0,
    /// @brief RabbitMQ has reinterpreted this field. The original specification said: "By default the QoS settings apply to the current channel only. If this field is set, they are applied to the entire connection." Instead, RabbitMQ takes global=false to mean that the QoS settings should apply per-consumer (for new consumers on the channel; existing ones being unaffected) and global=true to mean that the QoS settings should apply per-channel.
    RMQBasicQosGlobal    = 1 << 0,
};

@interface RMQBasicQos : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLong *prefetchSize;
@property (nonnull, copy, nonatomic, readonly) RMQShort *prefetchCount;
@property (nonatomic, readonly) RMQBasicQosOptions options;
- (nonnull instancetype)initWithPrefetchSize:(nonnull RMQLong *)prefetchSize
                               prefetchCount:(nonnull RMQShort *)prefetchCount
                                     options:(RMQBasicQosOptions)options;
@end

@interface RMQBasicQosOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQBasicConsumeOptions) {
    RMQBasicConsumeNoOptions = 0,
    /// @brief
    RMQBasicConsumeNoLocal   = 1 << 0,
    /// @brief
    RMQBasicConsumeNoAck     = 1 << 1,
    /// @brief Request exclusive consumer access, meaning only this consumer can access the queue.
    RMQBasicConsumeExclusive = 1 << 2,
    /// @brief
    RMQBasicConsumeNoWait    = 1 << 3,
};

@interface RMQBasicConsume : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *consumerTag;
@property (nonatomic, readonly) RMQBasicConsumeOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQTable *arguments;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                              consumerTag:(nonnull RMQShortstr *)consumerTag
                                  options:(RMQBasicConsumeOptions)options
                                arguments:(nonnull RMQTable *)arguments;
@end

@interface RMQBasicConsumeOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *consumerTag;
- (nonnull instancetype)initWithConsumerTag:(nonnull RMQShortstr *)consumerTag;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicCancelOptions) {
    RMQBasicCancelNoOptions = 0,
    /// @brief
    RMQBasicCancelNoWait    = 1 << 0,
};

@interface RMQBasicCancel : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *consumerTag;
@property (nonatomic, readonly) RMQBasicCancelOptions options;
- (nonnull instancetype)initWithConsumerTag:(nonnull RMQShortstr *)consumerTag
                                    options:(RMQBasicCancelOptions)options;
@end

@interface RMQBasicCancelOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *consumerTag;
- (nonnull instancetype)initWithConsumerTag:(nonnull RMQShortstr *)consumerTag;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicPublishOptions) {
    RMQBasicPublishNoOptions = 0,
    /// @brief This flag tells the server how to react if the message cannot be routed to a queue. If this flag is set, the server will return an unroutable message with a Return method. If this flag is zero, the server silently drops the message.
    RMQBasicPublishMandatory = 1 << 0,
};

@interface RMQBasicPublish : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonatomic, readonly) RMQBasicPublishOptions options;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                 exchange:(nonnull RMQShortstr *)exchange
                               routingKey:(nonnull RMQShortstr *)routingKey
                                  options:(RMQBasicPublishOptions)options;
@end

@interface RMQBasicReturn : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *replyCode;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *replyText;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
- (nonnull instancetype)initWithReplyCode:(nonnull RMQShort *)replyCode
                                replyText:(nonnull RMQShortstr *)replyText
                                 exchange:(nonnull RMQShortstr *)exchange
                               routingKey:(nonnull RMQShortstr *)routingKey;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicDeliverOptions) {
    RMQBasicDeliverNoOptions   = 0,
    /// @brief
    RMQBasicDeliverRedelivered = 1 << 0,
};

@interface RMQBasicDeliver : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *consumerTag;
@property (nonnull, copy, nonatomic, readonly) RMQLonglong *deliveryTag;
@property (nonatomic, readonly) RMQBasicDeliverOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
- (nonnull instancetype)initWithConsumerTag:(nonnull RMQShortstr *)consumerTag
                                deliveryTag:(nonnull RMQLonglong *)deliveryTag
                                    options:(RMQBasicDeliverOptions)options
                                   exchange:(nonnull RMQShortstr *)exchange
                                 routingKey:(nonnull RMQShortstr *)routingKey;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicGetOptions) {
    RMQBasicGetNoOptions = 0,
    /// @brief
    RMQBasicGetNoAck     = 1 << 0,
};

@interface RMQBasicGet : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShort *reserved1;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *queue;
@property (nonatomic, readonly) RMQBasicGetOptions options;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShort *)reserved1
                                    queue:(nonnull RMQShortstr *)queue
                                  options:(RMQBasicGetOptions)options;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicGetOkOptions) {
    RMQBasicGetOkNoOptions   = 0,
    /// @brief
    RMQBasicGetOkRedelivered = 1 << 0,
};

@interface RMQBasicGetOk : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLonglong *deliveryTag;
@property (nonatomic, readonly) RMQBasicGetOkOptions options;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *exchange;
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *routingKey;
@property (nonnull, copy, nonatomic, readonly) RMQLong *messageCount;
- (nonnull instancetype)initWithDeliveryTag:(nonnull RMQLonglong *)deliveryTag
                                    options:(RMQBasicGetOkOptions)options
                                   exchange:(nonnull RMQShortstr *)exchange
                                 routingKey:(nonnull RMQShortstr *)routingKey
                               messageCount:(nonnull RMQLong *)messageCount;
@end

@interface RMQBasicGetEmpty : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQShortstr *reserved1;
- (nonnull instancetype)initWithReserved1:(nonnull RMQShortstr *)reserved1;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicAckOptions) {
    RMQBasicAckNoOptions = 0,
    /// @brief If set to 1, the delivery tag is treated as "up to and including", so that multiple messages can be acknowledged with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, this indicates acknowledgement of all outstanding messages.
    RMQBasicAckMultiple  = 1 << 0,
};

@interface RMQBasicAck : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLonglong *deliveryTag;
@property (nonatomic, readonly) RMQBasicAckOptions options;
- (nonnull instancetype)initWithDeliveryTag:(nonnull RMQLonglong *)deliveryTag
                                    options:(RMQBasicAckOptions)options;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicRejectOptions) {
    RMQBasicRejectNoOptions = 0,
    /// @brief If requeue is true, the server will attempt to requeue the message. If requeue is false or the requeue attempt fails the messages are discarded or dead-lettered.
    RMQBasicRejectRequeue   = 1 << 0,
};

@interface RMQBasicReject : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLonglong *deliveryTag;
@property (nonatomic, readonly) RMQBasicRejectOptions options;
- (nonnull instancetype)initWithDeliveryTag:(nonnull RMQLonglong *)deliveryTag
                                    options:(RMQBasicRejectOptions)options;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicRecoverAsyncOptions) {
    RMQBasicRecoverAsyncNoOptions = 0,
    /// @brief If this field is zero, the message will be redelivered to the original recipient. If this bit is 1, the server will attempt to requeue the message, potentially then delivering it to an alternative subscriber.
    RMQBasicRecoverAsyncRequeue   = 1 << 0,
};

@interface RMQBasicRecoverAsync : RMQValue <RMQMethod>
@property (nonatomic, readonly) RMQBasicRecoverAsyncOptions options;
- (nonnull instancetype)initWithOptions:(RMQBasicRecoverAsyncOptions)options;
@end

typedef NS_OPTIONS(NSUInteger, RMQBasicRecoverOptions) {
    RMQBasicRecoverNoOptions = 0,
    /// @brief If this field is zero, the message will be redelivered to the original recipient. If this bit is 1, the server will attempt to requeue the message, potentially then delivering it to an alternative subscriber.
    RMQBasicRecoverRequeue   = 1 << 0,
};

@interface RMQBasicRecover : RMQValue <RMQMethod>
@property (nonatomic, readonly) RMQBasicRecoverOptions options;
- (nonnull instancetype)initWithOptions:(RMQBasicRecoverOptions)options;
@end

@interface RMQBasicRecoverOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQBasicNackOptions) {
    RMQBasicNackNoOptions = 0,
    /// @brief If set to 1, the delivery tag is treated as "up to and including", so that multiple messages can be rejected with a single method. If set to zero, the delivery tag refers to a single message. If the multiple field is 1, and the delivery tag is zero, this indicates rejection of all outstanding messages.
    RMQBasicNackMultiple  = 1 << 0,
    /// @brief If requeue is true, the server will attempt to requeue the message. If requeue is false or the requeue attempt fails the messages are discarded or dead-lettered. Clients receiving the Nack methods should ignore this flag.
    RMQBasicNackRequeue   = 1 << 1,
};

@interface RMQBasicNack : RMQValue <RMQMethod>
@property (nonnull, copy, nonatomic, readonly) RMQLonglong *deliveryTag;
@property (nonatomic, readonly) RMQBasicNackOptions options;
- (nonnull instancetype)initWithDeliveryTag:(nonnull RMQLonglong *)deliveryTag
                                    options:(RMQBasicNackOptions)options;
@end

@interface RMQTxSelect : RMQValue <RMQMethod>

@end

@interface RMQTxSelectOk : RMQValue <RMQMethod>

@end

@interface RMQTxCommit : RMQValue <RMQMethod>

@end

@interface RMQTxCommitOk : RMQValue <RMQMethod>

@end

@interface RMQTxRollback : RMQValue <RMQMethod>

@end

@interface RMQTxRollbackOk : RMQValue <RMQMethod>

@end

typedef NS_OPTIONS(NSUInteger, RMQConfirmSelectOptions) {
    RMQConfirmSelectNoOptions = 0,
    /// @brief If set, the server will not respond to the method. The client should not wait for a reply method. If the server could not complete the method it will raise a channel or connection exception.
    RMQConfirmSelectNowait    = 1 << 0,
};

@interface RMQConfirmSelect : RMQValue <RMQMethod>
@property (nonatomic, readonly) RMQConfirmSelectOptions options;
- (nonnull instancetype)initWithOptions:(RMQConfirmSelectOptions)options;
@end

@interface RMQConfirmSelectOk : RMQValue <RMQMethod>

@end