Source file spec.ml

(** Internal - Low level protocol description *)
(***********************************)
(* AUTOGENERATED FILE: DO NOT EDIT *)
(* ./gen_spec.exe -type specification amqp0-9-1.extended.xml *)
(***********************************)


(* spec/gen_spec.ml:439 *)
open Amqp_client_lib
open Types
open Protocol
open Protocol_helpers
(* Domains *)

(** 
      The localised reply text. This text can be logged as an aid to resolving
      issues.
     *)
(* spec/gen_spec.ml:177 *)
type reply_text = shortstr

(** 
      Unconstrained.
     *)
(* spec/gen_spec.ml:177 *)
type path = shortstr

(** 
      The reply code. The AMQ reply codes are defined as constants at the start
      of this formal specification.
     *)
(* spec/gen_spec.ml:177 *)
type reply_code = short
(* spec/gen_spec.ml:177 *)
type class_id = short

(** 
      The number of messages in the queue, which will be zero for newly-declared
      queues. This is the number of messages present in the queue, and committed
      if the channel on which they were published is transacted, that are not
      waiting acknowledgement.
     *)
(* spec/gen_spec.ml:177 *)
type message_count = long

(** 
      This table provides a set of peer properties, used for identification, debugging,
      and general information.
     *)
(* spec/gen_spec.ml:177 *)
type peer_properties = table
(* spec/gen_spec.ml:177 *)
type method_id = short

(** 
      The exchange name is a client-selected string that identifies the exchange for
      publish methods.
     *)
(* spec/gen_spec.ml:177 *)
type exchange_name = shortstr

(** 
      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.
     *)
(* spec/gen_spec.ml:177 *)
type no_wait = bit

(** 
      The server-assigned and channel-specific delivery tag
     *)
(* spec/gen_spec.ml:177 *)
type delivery_tag = longlong

(** 
      If this field is set the server does not expect acknowledgements for
      messages. That is, when a message is delivered to the client the server
      assumes the delivery will succeed and immediately dequeues it. This
      functionality may increase performance but at the cost of reliability.
      Messages can get lost if a client dies before they are delivered to the
      application.
     *)
(* spec/gen_spec.ml:177 *)
type no_ack = bit

(** 
      Identifier for the consumer, valid within the current channel.
     *)
(* spec/gen_spec.ml:177 *)
type consumer_tag = shortstr

(** 
      The queue name identifies the queue within the vhost.  In methods where the queue
      name may be blank, and that has no specific significance, this refers to the
      'current' queue for the channel, meaning the last queue that the client declared
      on the channel.  If the client did not declare a queue, and the method needs a
      queue name, this will result in a 502 (syntax error) channel exception.
     *)
(* spec/gen_spec.ml:177 *)
type queue_name = shortstr

(** 
      This indicates that the message has been previously delivered to this or
      another client.
     *)
(* spec/gen_spec.ml:177 *)
type redelivered = bit

(** 
      If the no-local field is set the server will not send messages to the connection that
      published them.
     *)
(* spec/gen_spec.ml:177 *)
type no_local = bit

(**/**)
(* spec/gen_spec.ml:182 *)
module Internal_alias = struct
  let reply_text = Shortstr
  let path = Shortstr
  let reply_code = Short
  let class_id = Short
  let message_count = Long
  let peer_properties = Table
  let method_id = Short
  let exchange_name = Shortstr
  let no_wait = Bit
  let delivery_tag = Longlong
  let no_ack = Bit
  let consumer_tag = Shortstr
  let queue_name = Shortstr
  let redelivered = Bit
  let no_local = Bit
end
(**/**)


(** 
      The Confirm class allows publishers to put the channel in
      confirm mode and subsequently be notified when messages have been
      handled by the broker.  The intention is that all messages
      published on a channel in confirm mode will be acknowledged at
      some point.  By acknowledging a message the broker assumes
      responsibility for it and indicates that it has done something
      it deems reasonable with it.

      Unroutable mandatory or immediate messages are acknowledged
      right after the Basic.Return method. Messages are acknowledged
      when all queues to which the message has been routed
      have either delivered the message and received an
      acknowledgement (if required), or enqueued the message (and
      persisted it if required).

      Published messages are assigned ascending sequence numbers,
      starting at 1 with the first Confirm.Select method. The server
      confirms messages by sending Basic.Ack methods referring to these
      sequence numbers.
     *)
(* spec/gen_spec.ml:396 *)
module Confirm = struct
  
  (** 
        This method confirms to the client that the channel was successfully
        set to use publisher acknowledgements.
       *)
  (* spec/gen_spec.ml:276 *)
  module Select_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((85, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method sets the channel to use publisher acknowledgements.
        The client can only use this method on a non-transactional
        channel.
       *)
  (* spec/gen_spec.ml:276 *)
  module Select = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      nowait: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Bit :: []
      let make nowait = { nowait }
      let apply f { nowait } = f nowait
      let def = ((85, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~nowait () = Internal.make nowait
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Select_ok.Internal.read 
  end
end

(** 
      The Tx class allows publish and ack operations to be batched into atomic
      units of work.  The intention is that all publish and ack requests issued
      within a transaction will complete successfully or none of them will.
      Servers SHOULD implement atomic transactions at least where all publish
      or ack requests affect a single queue.  Transactions that cover multiple
      queues may be non-atomic, given that queues can be created and destroyed
      asynchronously, and such events do not form part of any transaction.
      Further, the behaviour of transactions with respect to the immediate and
      mandatory flags on Basic.Publish methods is not defined.
     *)
(* spec/gen_spec.ml:396 *)
module Tx = struct
  
  (** 
        This method confirms to the client that the channel was successfully set to use
        standard transactions.
       *)
  (* spec/gen_spec.ml:276 *)
  module Select_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method sets the channel to use standard transactions. The client must use this
        method at least once on a channel before using the Commit or Rollback methods.
       *)
  (* spec/gen_spec.ml:276 *)
  module Select = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Select_ok.Internal.read 
  end
  
  (** 
        This method confirms to the client that the commit succeeded. Note that if a commit
        fails, the server raises a channel exception.
       *)
  (* spec/gen_spec.ml:276 *)
  module Commit_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method commits all message publications and acknowledgments performed in
        the current transaction.  A new transaction starts immediately after a commit.
       *)
  (* spec/gen_spec.ml:276 *)
  module Commit = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Commit_ok.Internal.read 
  end
  
  (** 
        This method confirms to the client that the rollback succeeded. Note that if an
        rollback fails, the server raises a channel exception.
       *)
  (* spec/gen_spec.ml:276 *)
  module Rollback_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 31), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method abandons all message publications and acknowledgments performed in
        the current transaction. A new transaction starts immediately after a rollback.
        Note that unacked messages will not be automatically redelivered by rollback;
        if that is required an explicit recover call should be issued.
       *)
  (* spec/gen_spec.ml:276 *)
  module Rollback = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((90, 30), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Rollback_ok.Internal.read 
  end
end

(** 
      The Basic class provides methods that support an industry-standard messaging model.
     *)
(* spec/gen_spec.ml:396 *)
module Basic = struct
  (* spec/gen_spec.ml:276 *)
  module Content = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      content_type: shortstr option; 
      content_encoding: shortstr option; 
      headers: table option; 
      delivery_mode: octet option; 
      priority: octet option; 
      correlation_id: shortstr option; 
      reply_to: shortstr option; 
      expiration: shortstr option; 
      message_id: shortstr option; 
      timestamp: timestamp option; 
      amqp_type: shortstr option; 
      user_id: shortstr option; 
      app_id: shortstr option; 
      reserved: shortstr option; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Content
      (* spec/gen_spec.ml:327 *)
      let spec = Shortstr :: Shortstr :: Table :: Octet :: Octet :: Shortstr :: Shortstr :: Shortstr :: Shortstr :: Timestamp :: Shortstr :: Shortstr :: Shortstr :: Shortstr :: []
      let make content_type content_encoding headers delivery_mode priority correlation_id reply_to expiration message_id timestamp amqp_type user_id app_id reserved = { content_type; content_encoding; headers; delivery_mode; priority; correlation_id; reply_to; expiration; message_id; timestamp; amqp_type; user_id; app_id; reserved }
      let apply f { content_type; content_encoding; headers; delivery_mode; priority; correlation_id; reply_to; expiration; message_id; timestamp; amqp_type; user_id; app_id; reserved } = f content_type content_encoding headers delivery_mode priority correlation_id reply_to expiration message_id timestamp amqp_type user_id app_id reserved
      let def = ((60, 0), spec, make, apply)
    end
    (**/**)
    
    (* spec/gen_spec.ml:352 *)
    let init ?content_type ?content_encoding ?headers ?delivery_mode ?priority ?correlation_id ?reply_to ?expiration ?message_id ?timestamp ?amqp_type ?user_id ?app_id ?reserved () = Internal.make content_type content_encoding headers delivery_mode priority correlation_id reply_to expiration message_id timestamp amqp_type user_id app_id reserved
  end
  
  (** 
        This method tells the client that the requested QoS levels could be handled by the
        server. The requested QoS applies to all active consumers until a new QoS is
        defined.
       *)
  (* spec/gen_spec.ml:276 *)
  module Qos_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((60, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method requests a specific quality of service. The QoS can be specified for the
        current channel or for all channels on the connection. The particular properties and
        semantics of a qos method always depend on the content class semantics. Though the
        qos method could in principle apply to both peers, it is currently meaningful only
        for the server.
       *)
  (* spec/gen_spec.ml:276 *)
  module Qos = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      prefetch_size: long; (** 
          The client can request that messages be sent in advance so that when the client
          finishes processing a message, the following message is already held locally,
          rather than needing to be sent down the channel. Prefetching gives a performance
          improvement. This field specifies the prefetch window size in octets. The server
          will send a message in advance if it is equal to or smaller in size than the
          available prefetch size (and also falls into other prefetch limits). May be set
          to zero, meaning "no specific limit", although other prefetch limits may still
          apply. The prefetch-size is ignored if the no-ack option is set.
         *)
      prefetch_count: short; (** 
          Specifies a prefetch window in terms of whole messages. This field may be used
          in combination with the prefetch-size field; a message will only be sent in
          advance if both prefetch windows (and those at the channel and connection level)
          allow it. The prefetch-count is ignored if the no-ack option is set.
         *)
      global: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Long :: Short :: Bit :: []
      let make prefetch_size prefetch_count global = { prefetch_size; prefetch_count; global }
      let apply f { prefetch_size; prefetch_count; global } = f prefetch_size prefetch_count global
      let def = ((60, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~prefetch_size ~prefetch_count ~global () = Internal.make prefetch_size prefetch_count global
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Qos_ok.Internal.read 
  end
  
  (** 
        The server provides the client with a consumer tag, which is used by the client
        for methods called on the consumer at a later stage.
       *)
  (* spec/gen_spec.ml:276 *)
  module Consume_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      consumer_tag: consumer_tag; (** 
          Holds the consumer tag specified by the client or provided by the server.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = consumer_tag :: []
      let make consumer_tag = { consumer_tag }
      let apply f { consumer_tag } = f consumer_tag
      let def = ((60, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~consumer_tag () = Internal.make consumer_tag
  end
  
  (** 
        This method asks the server to start a "consumer", which is a transient request for
        messages from a specific queue. Consumers last as long as the channel they were
        declared on, or until the client cancels them.
       *)
  (* spec/gen_spec.ml:276 *)
  module Consume = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to consume from. *)
      consumer_tag: consumer_tag; (** 
          Specifies the identifier for the consumer. The consumer tag is local to a
          channel, so two clients can use the same consumer tags. If this field is
          empty the server will generate a unique tag.
         *)
      no_local: no_local; 
      no_ack: no_ack; 
      exclusive: bit; (** 
          Request exclusive consumer access, meaning only this consumer can access the
          queue.
         *)
      no_wait: no_wait; 
      arguments: table; (** 
          A set of arguments for the consume. The syntax and semantics of these
          arguments depends on the server implementation.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: consumer_tag :: no_local :: no_ack :: Bit :: no_wait :: Table :: []
      let make _ queue consumer_tag no_local no_ack exclusive no_wait arguments = { queue; consumer_tag; no_local; no_ack; exclusive; no_wait; arguments }
      let apply f { queue; consumer_tag; no_local; no_ack; exclusive; no_wait; arguments } = f (reserved_value Short) queue consumer_tag no_local no_ack exclusive no_wait arguments
      let def = ((60, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~consumer_tag ~no_local ~no_ack ~exclusive ~no_wait ~arguments () = Internal.make queue consumer_tag no_local no_ack exclusive no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Consume_ok.Internal.read 
  end
  
  (** 
        This method confirms that the cancellation was completed.
       *)
  (* spec/gen_spec.ml:276 *)
  module Cancel_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      consumer_tag: consumer_tag; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = consumer_tag :: []
      let make consumer_tag = { consumer_tag }
      let apply f { consumer_tag } = f consumer_tag
      let def = ((60, 31), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~consumer_tag () = Internal.make consumer_tag
  end
  
  (** 
        This method cancels a consumer. This does not affect already delivered
        messages, but it does mean the server will not send any more messages for
        that consumer. The client may receive an arbitrary number of messages in
        between sending the cancel method and receiving the cancel-ok reply.

        It may also be sent from the server to the client in the event
        of the consumer being unexpectedly cancelled (i.e. cancelled
        for any reason other than the server receiving the
        corresponding basic.cancel from the client). This allows
        clients to be notified of the loss of consumers due to events
        such as queue deletion. Note that as it is not a MUST for
        clients to accept this method from the server, it is advisable
        for the broker to be able to identify those clients that are
        capable of accepting the method, through some means of
        capability negotiation.
       *)
  (* spec/gen_spec.ml:276 *)
  module Cancel = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      consumer_tag: consumer_tag; 
      no_wait: no_wait; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = consumer_tag :: no_wait :: []
      let make consumer_tag no_wait = { consumer_tag; no_wait }
      let apply f { consumer_tag; no_wait } = f consumer_tag no_wait
      let def = ((60, 30), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~consumer_tag ~no_wait () = Internal.make consumer_tag no_wait
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Cancel_ok.Internal.write 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Cancel_ok.Internal.read 
  end
  
  (** 
        This method publishes a message to a specific exchange. The message will be routed
        to queues as defined by the exchange configuration and distributed to any active
        consumers when the transaction, if any, is committed.
       *)
  (* spec/gen_spec.ml:276 *)
  module Publish = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      exchange: exchange_name; (** 
          Specifies the name of the exchange to publish to. The exchange name can be
          empty, meaning the default exchange. If the exchange name is specified, and that
          exchange does not exist, the server will raise a channel exception.
         *)
      routing_key: shortstr; (** 
          Specifies the routing key for the message. The routing key is used for routing
          messages depending on the exchange configuration.
         *)
      mandatory: bit; (** 
          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.
         *)
      immediate: bit; (** 
          This flag tells the server how to react if the message cannot be routed to a
          queue consumer immediately. If this flag is set, the server will return an
          undeliverable message with a Return method. If this flag is zero, the server
          will queue the message, but with no guarantee that it will ever be consumed.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: exchange_name :: Shortstr :: Bit :: Bit :: []
      let make _ exchange routing_key mandatory immediate = { exchange; routing_key; mandatory; immediate }
      let apply f { exchange; routing_key; mandatory; immediate } = f (reserved_value Short) exchange routing_key mandatory immediate
      let def = ((60, 40), spec, make, apply)
      (* spec/gen_spec.ml:338 *)
      let write = write_method_content def Content.Internal.def
      (* spec/gen_spec.ml:339 *)
      let read = read_method_content def Content.Internal.def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~exchange ~routing_key ~mandatory ~immediate () = Internal.make exchange routing_key mandatory immediate
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method returns an undeliverable message that was published with the "immediate"
        flag set, or an unroutable message published with the "mandatory" flag set. The
        reply code and text provide information about the reason that the message was
        undeliverable.
       *)
  (* spec/gen_spec.ml:276 *)
  module Return = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      reply_code: reply_code; 
      reply_text: reply_text; 
      exchange: exchange_name; (** 
          Specifies the name of the exchange that the message was originally published
          to.  May be empty, meaning the default exchange.
         *)
      routing_key: shortstr; (** 
          Specifies the routing key name specified when the message was published.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = reply_code :: reply_text :: exchange_name :: Shortstr :: []
      let make reply_code reply_text exchange routing_key = { reply_code; reply_text; exchange; routing_key }
      let apply f { reply_code; reply_text; exchange; routing_key } = f reply_code reply_text exchange routing_key
      let def = ((60, 50), spec, make, apply)
      (* spec/gen_spec.ml:338 *)
      let write = write_method_content def Content.Internal.def
      (* spec/gen_spec.ml:339 *)
      let read = read_method_content def Content.Internal.def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~reply_code ~reply_text ~exchange ~routing_key () = Internal.make reply_code reply_text exchange routing_key
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
  end
  
  (** 
        This method delivers a message to the client, via a consumer. In the asynchronous
        message delivery model, the client starts a consumer using the Consume method, then
        the server responds with Deliver methods as and when messages arrive for that
        consumer.
       *)
  (* spec/gen_spec.ml:276 *)
  module Deliver = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      consumer_tag: consumer_tag; 
      delivery_tag: delivery_tag; 
      redelivered: redelivered; 
      exchange: exchange_name; (** 
          Specifies the name of the exchange that the message was originally published to.
          May be empty, indicating the default exchange.
         *)
      routing_key: shortstr; (** Specifies the routing key name specified when the message was published. *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = consumer_tag :: delivery_tag :: redelivered :: exchange_name :: Shortstr :: []
      let make consumer_tag delivery_tag redelivered exchange routing_key = { consumer_tag; delivery_tag; redelivered; exchange; routing_key }
      let apply f { consumer_tag; delivery_tag; redelivered; exchange; routing_key } = f consumer_tag delivery_tag redelivered exchange routing_key
      let def = ((60, 60), spec, make, apply)
      (* spec/gen_spec.ml:338 *)
      let write = write_method_content def Content.Internal.def
      (* spec/gen_spec.ml:339 *)
      let read = read_method_content def Content.Internal.def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~consumer_tag ~delivery_tag ~redelivered ~exchange ~routing_key () = Internal.make consumer_tag delivery_tag redelivered exchange routing_key
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
  end
  
  (** 
        This method delivers a message to the client following a get method. A message
        delivered by 'get-ok' must be acknowledged unless the no-ack option was set in the
        get method.
       *)
  (* spec/gen_spec.ml:276 *)
  module Get_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      delivery_tag: delivery_tag; 
      redelivered: redelivered; 
      exchange: exchange_name; (** 
          Specifies the name of the exchange that the message was originally published to.
          If empty, the message was published to the default exchange.
         *)
      routing_key: shortstr; (** Specifies the routing key name specified when the message was published. *)
      message_count: message_count; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = delivery_tag :: redelivered :: exchange_name :: Shortstr :: message_count :: []
      let make delivery_tag redelivered exchange routing_key message_count = { delivery_tag; redelivered; exchange; routing_key; message_count }
      let apply f { delivery_tag; redelivered; exchange; routing_key; message_count } = f delivery_tag redelivered exchange routing_key message_count
      let def = ((60, 71), spec, make, apply)
      (* spec/gen_spec.ml:338 *)
      let write = write_method_content def Content.Internal.def
      (* spec/gen_spec.ml:339 *)
      let read = read_method_content def Content.Internal.def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~delivery_tag ~redelivered ~exchange ~routing_key ~message_count () = Internal.make delivery_tag redelivered exchange routing_key message_count
  end
  
  (** 
        This method tells the client that the queue has no messages available for the
        client.
       *)
  (* spec/gen_spec.ml:276 *)
  module Get_empty = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Shortstr :: []
      let make _ = ()
      let apply f () = f (reserved_value Shortstr)
      let def = ((60, 72), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method provides a direct access to the messages in a queue using a synchronous
        dialogue that is designed for specific types of application where synchronous
        functionality is more important than performance.
       *)
  (* spec/gen_spec.ml:276 *)
  module Get = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to get a message from. *)
      no_ack: no_ack; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: no_ack :: []
      let make _ queue no_ack = { queue; no_ack }
      let apply f { queue; no_ack } = f (reserved_value Short) queue no_ack
      let def = ((60, 70), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~no_ack () = Internal.make queue no_ack
    (* spec/gen_spec.ml:372 *)
    let request = request2 Internal.write Get_ok.Internal.read (fun m -> `Get_ok m) Get_empty.Internal.read (fun m -> `Get_empty m)
  end
  
  (** 
        When sent by the client, this method acknowledges one or more
        messages delivered via the Deliver or Get-Ok methods.

        When sent by server, this method acknowledges one or more
        messages published with the Publish method on a channel in
        confirm mode.

        The acknowledgement can be for a single message or a set of
        messages up to and including a specific message.
       *)
  (* spec/gen_spec.ml:276 *)
  module Ack = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      delivery_tag: delivery_tag; 
      multiple: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = delivery_tag :: Bit :: []
      let make delivery_tag multiple = { delivery_tag; multiple }
      let apply f { delivery_tag; multiple } = f delivery_tag multiple
      let def = ((60, 80), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~delivery_tag ~multiple () = Internal.make delivery_tag multiple
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method allows a client to reject a message. It can be used to interrupt and
        cancel large incoming messages, or return untreatable messages to their original
        queue.
       *)
  (* spec/gen_spec.ml:276 *)
  module Reject = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      delivery_tag: delivery_tag; 
      requeue: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = delivery_tag :: Bit :: []
      let make delivery_tag requeue = { delivery_tag; requeue }
      let apply f { delivery_tag; requeue } = f delivery_tag requeue
      let def = ((60, 90), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~delivery_tag ~requeue () = Internal.make delivery_tag requeue
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method asks the server to redeliver all unacknowledged messages on a
        specified channel. Zero or more messages may be redelivered.  This method
        is deprecated in favour of the synchronous Recover/Recover-Ok.
       *)
  (* spec/gen_spec.ml:276 *)
  module Recover_async = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      requeue: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Bit :: []
      let make requeue = { requeue }
      let apply f { requeue } = f requeue
      let def = ((60, 100), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~requeue () = Internal.make requeue
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method asks the server to redeliver all unacknowledged messages on a
        specified channel. Zero or more messages may be redelivered.  This method
        replaces the asynchronous Recover.
       *)
  (* spec/gen_spec.ml:276 *)
  module Recover = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      requeue: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Bit :: []
      let make requeue = { requeue }
      let apply f { requeue } = f requeue
      let def = ((60, 110), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~requeue () = Internal.make requeue
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method acknowledges a Basic.Recover method.
       *)
  (* spec/gen_spec.ml:276 *)
  module Recover_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((60, 111), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method allows a client to reject one or more incoming messages. It can be
        used to interrupt and cancel large incoming messages, or return untreatable
        messages to their original queue.

        This method is also used by the server to inform publishers on channels in
        confirm mode of unhandled messages.  If a publisher receives this method, it
        probably needs to republish the offending messages.
       *)
  (* spec/gen_spec.ml:276 *)
  module Nack = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      delivery_tag: delivery_tag; 
      multiple: bit; (** 
          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.
         *)
      requeue: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = delivery_tag :: Bit :: Bit :: []
      let make delivery_tag multiple requeue = { delivery_tag; multiple; requeue }
      let apply f { delivery_tag; multiple; requeue } = f delivery_tag multiple requeue
      let def = ((60, 120), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~delivery_tag ~multiple ~requeue () = Internal.make delivery_tag multiple requeue
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
end

(** 
      Queues store and forward messages. Queues can be configured in the server or created at
      runtime. Queues must be attached to at least one exchange in order to receive messages
      from publishers.
     *)
(* spec/gen_spec.ml:396 *)
module Queue = struct
  
  (** 
        This method confirms a Declare method and confirms the name of the queue, essential
        for automatically-named queues.
       *)
  (* spec/gen_spec.ml:276 *)
  module Declare_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** 
          Reports the name of the queue. If the server generated a queue name, this field
          contains that name.
         *)
      message_count: message_count; 
      consumer_count: long; (** 
          Reports the number of active consumers for the queue. Note that consumers can
          suspend activity (Channel.Flow) in which case they do not appear in this count.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = queue_name :: message_count :: Long :: []
      let make queue message_count consumer_count = { queue; message_count; consumer_count }
      let apply f { queue; message_count; consumer_count } = f queue message_count consumer_count
      let def = ((50, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~message_count ~consumer_count () = Internal.make queue message_count consumer_count
  end
  
  (** 
        This method creates or checks a queue. When creating a new queue the client can
        specify various properties that control the durability of the queue and its
        contents, and the level of sharing for the queue.
       *)
  (* spec/gen_spec.ml:276 *)
  module Declare = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; 
      passive: bit; (** 
          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.
         *)
      durable: bit; (** 
          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.
         *)
      exclusive: bit; (** 
          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.
         *)
      auto_delete: bit; (** 
          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.
         *)
      no_wait: no_wait; 
      arguments: table; (** 
          A set of arguments for the declaration. The syntax and semantics of these
          arguments depends on the server implementation.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: Bit :: Bit :: Bit :: Bit :: no_wait :: Table :: []
      let make _ queue passive durable exclusive auto_delete no_wait arguments = { queue; passive; durable; exclusive; auto_delete; no_wait; arguments }
      let apply f { queue; passive; durable; exclusive; auto_delete; no_wait; arguments } = f (reserved_value Short) queue passive durable exclusive auto_delete no_wait arguments
      let def = ((50, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~passive ~durable ~exclusive ~auto_delete ~no_wait ~arguments () = Internal.make queue passive durable exclusive auto_delete no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Declare_ok.Internal.read 
  end
  
  (** This method confirms that the bind was successful. *)
  (* spec/gen_spec.ml:276 *)
  module Bind_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((50, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method binds a queue to an exchange. Until a queue is bound it will not
        receive any messages. In a classic messaging model, store-and-forward queues
        are bound to a direct exchange and subscription queues are bound to a topic
        exchange.
       *)
  (* spec/gen_spec.ml:276 *)
  module Bind = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to bind. *)
      exchange: exchange_name; 
      routing_key: shortstr; (** 
          Specifies the routing key for the binding. The routing key is used for routing
          messages depending on the exchange configuration. Not all exchanges use a
          routing key - refer to the specific exchange documentation.  If the queue name
          is empty, the server uses the last queue declared on the channel.  If the
          routing key is also empty, the server uses this queue name for the routing
          key as well.  If the queue name is provided but the routing key is empty, the
          server does the binding with that empty routing key.  The meaning of empty
          routing keys depends on the exchange implementation.
         *)
      no_wait: no_wait; 
      arguments: table; (** 
          A set of arguments for the binding. The syntax and semantics of these arguments
          depends on the exchange class.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: exchange_name :: Shortstr :: no_wait :: Table :: []
      let make _ queue exchange routing_key no_wait arguments = { queue; exchange; routing_key; no_wait; arguments }
      let apply f { queue; exchange; routing_key; no_wait; arguments } = f (reserved_value Short) queue exchange routing_key no_wait arguments
      let def = ((50, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~exchange ~routing_key ~no_wait ~arguments () = Internal.make queue exchange routing_key no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Bind_ok.Internal.read 
  end
  
  (** This method confirms that the unbind was successful. *)
  (* spec/gen_spec.ml:276 *)
  module Unbind_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((50, 51), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** This method unbinds a queue from an exchange. *)
  (* spec/gen_spec.ml:276 *)
  module Unbind = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to unbind. *)
      exchange: exchange_name; (** The name of the exchange to unbind from. *)
      routing_key: shortstr; (** Specifies the routing key of the binding to unbind. *)
      arguments: table; (** Specifies the arguments of the binding to unbind. *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: exchange_name :: Shortstr :: Table :: []
      let make _ queue exchange routing_key arguments = { queue; exchange; routing_key; arguments }
      let apply f { queue; exchange; routing_key; arguments } = f (reserved_value Short) queue exchange routing_key arguments
      let def = ((50, 50), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~exchange ~routing_key ~arguments () = Internal.make queue exchange routing_key arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Unbind_ok.Internal.read 
  end
  
  (** This method confirms the purge of a queue. *)
  (* spec/gen_spec.ml:276 *)
  module Purge_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      message_count: message_count; (** 
          Reports the number of messages purged.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = message_count :: []
      let make message_count = { message_count }
      let apply f { message_count } = f message_count
      let def = ((50, 31), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~message_count () = Internal.make message_count
  end
  
  (** 
        This method removes all messages from a queue which are not awaiting
        acknowledgment.
       *)
  (* spec/gen_spec.ml:276 *)
  module Purge = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to purge. *)
      no_wait: no_wait; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: no_wait :: []
      let make _ queue no_wait = { queue; no_wait }
      let apply f { queue; no_wait } = f (reserved_value Short) queue no_wait
      let def = ((50, 30), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~no_wait () = Internal.make queue no_wait
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Purge_ok.Internal.read 
  end
  
  (** This method confirms the deletion of a queue. *)
  (* spec/gen_spec.ml:276 *)
  module Delete_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      message_count: message_count; (** Reports the number of messages deleted. *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = message_count :: []
      let make message_count = { message_count }
      let apply f { message_count } = f message_count
      let def = ((50, 41), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~message_count () = Internal.make message_count
  end
  
  (** 
        This method deletes a queue. When a queue is deleted any pending messages are sent
        to a dead-letter queue if this is defined in the server configuration, and all
        consumers on the queue are cancelled.
       *)
  (* spec/gen_spec.ml:276 *)
  module Delete = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      queue: queue_name; (** Specifies the name of the queue to delete. *)
      if_unused: bit; (** 
          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.
         *)
      if_empty: bit; (** 
          If set, the server will only delete the queue if it has no messages.
         *)
      no_wait: no_wait; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: queue_name :: Bit :: Bit :: no_wait :: []
      let make _ queue if_unused if_empty no_wait = { queue; if_unused; if_empty; no_wait }
      let apply f { queue; if_unused; if_empty; no_wait } = f (reserved_value Short) queue if_unused if_empty no_wait
      let def = ((50, 40), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~queue ~if_unused ~if_empty ~no_wait () = Internal.make queue if_unused if_empty no_wait
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Delete_ok.Internal.read 
  end
end

(** 
      Exchanges match and distribute messages across queues. Exchanges can be configured in
      the server or declared at runtime.
     *)
(* spec/gen_spec.ml:396 *)
module Exchange = struct
  
  (** 
        This method confirms a Declare method and confirms the name of the exchange,
        essential for automatically-named exchanges.
       *)
  (* spec/gen_spec.ml:276 *)
  module Declare_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((40, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method creates an exchange if it does not already exist, and if the exchange
        exists, verifies that it is of the correct and expected class.
       *)
  (* spec/gen_spec.ml:276 *)
  module Declare = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      exchange: exchange_name; 
      amqp_type: shortstr; (** 
          Each exchange belongs to one of a set of exchange types implemented by the
          server. The exchange types define the functionality of the exchange - i.e. how
          messages are routed through it. It is not valid or meaningful to attempt to
          change the type of an existing exchange.
         *)
      passive: bit; (** 
          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.
         *)
      durable: bit; (** 
          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.
         *)
      auto_delete: bit; (** 
          If set, the exchange is deleted when all queues have
          finished using it.
         *)
      internal: bit; (** 
          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.
         *)
      no_wait: no_wait; 
      arguments: table; (** 
          A set of arguments for the declaration. The syntax and semantics of these
          arguments depends on the server implementation.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: exchange_name :: Shortstr :: Bit :: Bit :: Bit :: Bit :: no_wait :: Table :: []
      let make _ exchange amqp_type passive durable auto_delete internal no_wait arguments = { exchange; amqp_type; passive; durable; auto_delete; internal; no_wait; arguments }
      let apply f { exchange; amqp_type; passive; durable; auto_delete; internal; no_wait; arguments } = f (reserved_value Short) exchange amqp_type passive durable auto_delete internal no_wait arguments
      let def = ((40, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~exchange ~amqp_type ~passive ~durable ~auto_delete ~internal ~no_wait ~arguments () = Internal.make exchange amqp_type passive durable auto_delete internal no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Declare_ok.Internal.read 
  end
  
  (** This method confirms the deletion of an exchange. *)
  (* spec/gen_spec.ml:276 *)
  module Delete_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((40, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method deletes an exchange. When an exchange is deleted all queue bindings on
        the exchange are cancelled.
       *)
  (* spec/gen_spec.ml:276 *)
  module Delete = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      exchange: exchange_name; 
      if_unused: bit; (** 
          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.
         *)
      no_wait: no_wait; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: exchange_name :: Bit :: no_wait :: []
      let make _ exchange if_unused no_wait = { exchange; if_unused; no_wait }
      let apply f { exchange; if_unused; no_wait } = f (reserved_value Short) exchange if_unused no_wait
      let def = ((40, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~exchange ~if_unused ~no_wait () = Internal.make exchange if_unused no_wait
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Delete_ok.Internal.read 
  end
  
  (** This method confirms that the bind was successful. *)
  (* spec/gen_spec.ml:276 *)
  module Bind_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((40, 31), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** This method binds an exchange to an exchange. *)
  (* spec/gen_spec.ml:276 *)
  module Bind = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      destination: exchange_name; (** Specifies the name of the destination exchange to bind. *)
      source: exchange_name; (** Specifies the name of the source exchange to bind. *)
      routing_key: shortstr; (** 
          Specifies the routing key for the binding. The routing key
          is used for routing messages depending on the exchange
          configuration. Not all exchanges use a routing key - refer
          to the specific exchange documentation.
         *)
      no_wait: no_wait; 
      arguments: table; (** 
          A set of arguments for the binding. The syntax and semantics
          of these arguments depends on the exchange class.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: exchange_name :: exchange_name :: Shortstr :: no_wait :: Table :: []
      let make _ destination source routing_key no_wait arguments = { destination; source; routing_key; no_wait; arguments }
      let apply f { destination; source; routing_key; no_wait; arguments } = f (reserved_value Short) destination source routing_key no_wait arguments
      let def = ((40, 30), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~destination ~source ~routing_key ~no_wait ~arguments () = Internal.make destination source routing_key no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Bind_ok.Internal.read 
  end
  
  (** This method confirms that the unbind was successful. *)
  (* spec/gen_spec.ml:276 *)
  module Unbind_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((40, 51), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** This method unbinds an exchange from an exchange. *)
  (* spec/gen_spec.ml:276 *)
  module Unbind = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      destination: exchange_name; (** Specifies the name of the destination exchange to unbind. *)
      source: exchange_name; (** Specifies the name of the source exchange to unbind. *)
      routing_key: shortstr; (** Specifies the routing key of the binding to unbind. *)
      no_wait: no_wait; 
      arguments: table; (** Specifies the arguments of the binding to unbind. *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: exchange_name :: exchange_name :: Shortstr :: no_wait :: Table :: []
      let make _ destination source routing_key no_wait arguments = { destination; source; routing_key; no_wait; arguments }
      let apply f { destination; source; routing_key; no_wait; arguments } = f (reserved_value Short) destination source routing_key no_wait arguments
      let def = ((40, 40), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~destination ~source ~routing_key ~no_wait ~arguments () = Internal.make destination source routing_key no_wait arguments
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Unbind_ok.Internal.read 
  end
end

(** 
      The channel class provides methods for a client to establish a channel to a
      server and for both peers to operate the channel thereafter.
     *)
(* spec/gen_spec.ml:396 *)
module Channel = struct
  
  (** 
        This method signals to the client that the channel is ready for use.
       *)
  (* spec/gen_spec.ml:276 *)
  module Open_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Longstr :: []
      let make _ = ()
      let apply f () = f (reserved_value Longstr)
      let def = ((20, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method opens a channel to the server.
       *)
  (* spec/gen_spec.ml:276 *)
  module Open = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Shortstr :: []
      let make _ = ()
      let apply f () = f (reserved_value Shortstr)
      let def = ((20, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Open_ok.Internal.read 
  end
  
  (** 
        Confirms to the peer that a flow command was received and processed.
       *)
  (* spec/gen_spec.ml:276 *)
  module Flow_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      active: bit; (** 
          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.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Bit :: []
      let make active = { active }
      let apply f { active } = f active
      let def = ((20, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~active () = Internal.make active
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method asks the peer to pause or restart the flow of content data sent by
        a consumer. This is a simple flow-control mechanism that a peer can use to avoid
        overflowing its queues or otherwise finding itself receiving more messages than
        it can process. Note that this method is not intended for window control. It does
        not affect contents returned by Basic.Get-Ok methods.
       *)
  (* spec/gen_spec.ml:276 *)
  module Flow = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      active: bit; (** 
          If 1, the peer starts sending content frames. If 0, the peer stops sending
          content frames.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Bit :: []
      let make active = { active }
      let apply f { active } = f active
      let def = ((20, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~active () = Internal.make active
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Flow_ok.Internal.write 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Flow_ok.Internal.read 
  end
  
  (** 
        This method confirms a Channel.Close method and tells the recipient that it is safe
        to release resources for the channel.
       *)
  (* spec/gen_spec.ml:276 *)
  module Close_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((20, 41), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method indicates that the sender wants to close the channel. This may be due to
        internal conditions (e.g. a forced shut-down) or due to an error handling a specific
        method, i.e. an exception. When a close is due to an exception, the sender provides
        the class and method id of the method which caused the exception.
       *)
  (* spec/gen_spec.ml:276 *)
  module Close = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      reply_code: reply_code; 
      reply_text: reply_text; 
      class_id: class_id; (** 
          When the close is provoked by a method exception, this is the class of the
          method.
         *)
      method_id: method_id; (** 
          When the close is provoked by a method exception, this is the ID of the method.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = reply_code :: reply_text :: class_id :: method_id :: []
      let make reply_code reply_text class_id method_id = { reply_code; reply_text; class_id; method_id }
      let apply f { reply_code; reply_text; class_id; method_id } = f reply_code reply_text class_id method_id
      let def = ((20, 40), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~reply_code ~reply_text ~class_id ~method_id () = Internal.make reply_code reply_text class_id method_id
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Close_ok.Internal.write 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Close_ok.Internal.read 
  end
end

(** 
      The connection class provides methods for a client to establish a network connection to
      a server, and for both peers to operate the connection thereafter.
     *)
(* spec/gen_spec.ml:396 *)
module Connection = struct
  
  (** 
        This method selects a SASL security mechanism.
       *)
  (* spec/gen_spec.ml:276 *)
  module Start_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      client_properties: peer_properties; 
      mechanism: shortstr; (** 
          A single security mechanisms selected by the client, which must be one of those
          specified by the server.
         *)
      response: longstr; (** 
          A block of opaque data passed to the security mechanism. The contents of this
          data are defined by the SASL security mechanism.
         *)
      locale: shortstr; (** 
          A single message locale selected by the client, which must be one of those
          specified by the server.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = peer_properties :: Shortstr :: Longstr :: Shortstr :: []
      let make client_properties mechanism response locale = { client_properties; mechanism; response; locale }
      let apply f { client_properties; mechanism; response; locale } = f client_properties mechanism response locale
      let def = ((10, 11), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~client_properties ~mechanism ~response ~locale () = Internal.make client_properties mechanism response locale
  end
  
  (** 
        This method starts the connection negotiation process by telling the client the
        protocol version that the server proposes, along with a list of security mechanisms
        which the client can use for authentication.
       *)
  (* spec/gen_spec.ml:276 *)
  module Start = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      version_major: octet; (** 
          The major version number can take any value from 0 to 99 as defined in the
          AMQP specification.
         *)
      version_minor: octet; (** 
          The minor version number can take any value from 0 to 99 as defined in the
          AMQP specification.
         *)
      server_properties: peer_properties; 
      mechanisms: longstr; (** 
          A list of the security mechanisms that the server supports, delimited by spaces.
         *)
      locales: longstr; (** 
          A list of the message locales that the server supports, delimited by spaces. The
          locale defines the language in which the server will send reply texts.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Octet :: Octet :: peer_properties :: Longstr :: Longstr :: []
      let make version_major version_minor server_properties mechanisms locales = { version_major; version_minor; server_properties; mechanisms; locales }
      let apply f { version_major; version_minor; server_properties; mechanisms; locales } = f version_major version_minor server_properties mechanisms locales
      let def = ((10, 10), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~version_major ~version_minor ~server_properties ~mechanisms ~locales () = Internal.make version_major version_minor server_properties mechanisms locales
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Start_ok.Internal.write 
  end
  
  (** 
        This method attempts to authenticate, passing a block of SASL data for the security
        mechanism at the server side.
       *)
  (* spec/gen_spec.ml:276 *)
  module Secure_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      response: longstr; (** 
          A block of opaque data passed to the security mechanism. The contents of this
          data are defined by the SASL security mechanism.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Longstr :: []
      let make response = { response }
      let apply f { response } = f response
      let def = ((10, 21), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~response () = Internal.make response
  end
  
  (** 
        The SASL protocol works by exchanging challenges and responses until both peers have
        received sufficient information to authenticate each other. This method challenges
        the client to provide more information.
       *)
  (* spec/gen_spec.ml:276 *)
  module Secure = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      challenge: longstr; (** 
          Challenge information, a block of opaque binary data passed to the security
          mechanism.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Longstr :: []
      let make challenge = { challenge }
      let apply f { challenge } = f challenge
      let def = ((10, 20), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~challenge () = Internal.make challenge
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Secure_ok.Internal.write 
  end
  
  (** 
        This method sends the client's connection tuning parameters to the server.
        Certain fields are negotiated, others provide capability information.
       *)
  (* spec/gen_spec.ml:276 *)
  module Tune_ok = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      channel_max: short; (** 
          The maximum total number of channels that the client will use per connection.
         *)
      frame_max: long; (** 
          The largest frame size that the client and server will use for the connection.
          Zero means that the client does not impose any specific limit but may reject
          very large frames if it cannot allocate resources for them. Note that the
          frame-max limit applies principally to content frames, where large contents can
          be broken into frames of arbitrary size.
         *)
      heartbeat: short; (** 
          The delay, in seconds, of the connection heartbeat that the client wants. Zero
          means the client does not want a heartbeat.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: Long :: Short :: []
      let make channel_max frame_max heartbeat = { channel_max; frame_max; heartbeat }
      let apply f { channel_max; frame_max; heartbeat } = f channel_max frame_max heartbeat
      let def = ((10, 31), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~channel_max ~frame_max ~heartbeat () = Internal.make channel_max frame_max heartbeat
  end
  
  (** 
        This method proposes a set of connection configuration values to the client. The
        client can accept and/or adjust these.
       *)
  (* spec/gen_spec.ml:276 *)
  module Tune = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      channel_max: short; (** 
          Specifies highest channel number that the server permits.  Usable channel numbers
          are in the range 1..channel-max.  Zero indicates no specified limit.
         *)
      frame_max: long; (** 
          The largest frame size that the server proposes for the connection, including
          frame header and end-byte.  The client can negotiate a lower value. Zero means
          that the server does not impose any specific limit but may reject very large
          frames if it cannot allocate resources for them.
         *)
      heartbeat: short; (** 
          The delay, in seconds, of the connection heartbeat that the server wants.
          Zero means the server does not want a heartbeat.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Short :: Long :: Short :: []
      let make channel_max frame_max heartbeat = { channel_max; frame_max; heartbeat }
      let apply f { channel_max; frame_max; heartbeat } = f channel_max frame_max heartbeat
      let def = ((10, 30), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~channel_max ~frame_max ~heartbeat () = Internal.make channel_max frame_max heartbeat
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Tune_ok.Internal.write 
  end
  
  (** 
        This method signals to the client that the connection is ready for use.
       *)
  (* spec/gen_spec.ml:276 *)
  module Open_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Shortstr :: []
      let make _ = ()
      let apply f () = f (reserved_value Shortstr)
      let def = ((10, 41), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method opens a connection to a virtual host, which is a collection of
        resources, and acts to separate multiple application domains within a server.
        The server may apply arbitrary limits per virtual host, such as the number
        of each type of entity that may be used, per connection and/or in total.
       *)
  (* spec/gen_spec.ml:276 *)
  module Open = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      virtual_host: path; (** 
          The name of the virtual host to work with.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = path :: Shortstr :: Bit :: []
      let make virtual_host _ _ = { virtual_host }
      let apply f { virtual_host } = f virtual_host (reserved_value Shortstr) (reserved_value Bit)
      let def = ((10, 40), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~virtual_host () = Internal.make virtual_host
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Open_ok.Internal.read 
  end
  
  (** 
        This method confirms a Connection.Close method and tells the recipient that it is
        safe to release resources for the connection and close the socket.
       *)
  (* spec/gen_spec.ml:276 *)
  module Close_ok = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((10, 51), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
  end
  
  (** 
        This method indicates that the sender wants to close the connection. This may be
        due to internal conditions (e.g. a forced shut-down) or due to an error handling
        a specific method, i.e. an exception. When a close is due to an exception, the
        sender provides the class and method id of the method which caused the exception.
       *)
  (* spec/gen_spec.ml:276 *)
  module Close = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      reply_code: reply_code; 
      reply_text: reply_text; 
      class_id: class_id; (** 
          When the close is provoked by a method exception, this is the class of the
          method.
         *)
      method_id: method_id; (** 
          When the close is provoked by a method exception, this is the ID of the method.
         *)
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = reply_code :: reply_text :: class_id :: method_id :: []
      let make reply_code reply_text class_id method_id = { reply_code; reply_text; class_id; method_id }
      let apply f { reply_code; reply_text; class_id; method_id } = f reply_code reply_text class_id method_id
      let def = ((10, 50), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~reply_code ~reply_text ~class_id ~method_id () = Internal.make reply_code reply_text class_id method_id
    (* spec/gen_spec.ml:368 *)
    let reply = reply1 Internal.read Close_ok.Internal.write 
    (* spec/gen_spec.ml:372 *)
    let request = request1 Internal.write Close_ok.Internal.read 
  end
  
  (** 
        This method indicates that a connection has been blocked
        and does not accept new publishes.
       *)
  (* spec/gen_spec.ml:276 *)
  module Blocked = struct
    (* spec/gen_spec.ml:310 *)
    type t = {
      reason: shortstr; 
    }
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = Shortstr :: []
      let make reason = { reason }
      let apply f { reason } = f reason
      let def = ((10, 60), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init ~reason () = Internal.make reason
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
  
  (** 
        This method indicates that a connection has been unblocked
        and now accepts publishes.
       *)
  (* spec/gen_spec.ml:276 *)
  module Unblocked = struct
    (* spec/gen_spec.ml:308 *)
    type t = unit
    
    (**/**)
    (* spec/gen_spec.ml:317 *)
    module Internal = struct
      open Internal_alias [@@warning "-33"]
      open Protocol.Spec
      (* spec/gen_spec.ml:327 *)
      let spec = []
      let make  = ()
      let apply f () = f 
      let def = ((10, 61), spec, make, apply)
      (* spec/gen_spec.ml:335 *)
      let write = write_method def
      (* spec/gen_spec.ml:336 *)
      let read = read_method def
    end
    (**/**)
    
    (* spec/gen_spec.ml:354 *)
    let init  () = Internal.make 
    (* spec/gen_spec.ml:368 *)
    let reply = reply0 Internal.read 
    (* spec/gen_spec.ml:372 *)
    let request = request0 Internal.write 
  end
end