"""
The classes inside :mod:`pamqp.commands` allow for the automatic marshaling
and unmarshaling of AMQP method frames and
:class:`Basic.Properties <pamqp.commands.Basic.Properties>`. In addition the
command classes contain information that designates if they are synchronous
commands and if so, what the expected responses are. Each commands arguments
are detailed in the class and are listed in the attributes property.

.. note:: All AMQ classes and methods extend :class:`pamqp.base.Frame`.

"""
# Auto-generated, do not edit this file.
import datetime
import typing
import warnings

from pamqp import base, common, constants


class Connection:
    """Work with socket connections

    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.

    """
    __slots__: typing.List[str] = []

    frame_id = 10  # AMQP Frame ID
    index = 0x000A0000  # pamqp Mapping Index

    class Start(base.Frame):
        """Start connection negotiation

        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.

        :param version_major: Protocol major version
            - Default: ``0``
        :param version_minor: Protocol minor version
            - Default: ``9``
        :param server_properties: Server properties
            - Default: ``{}``
        :type server_properties: :const:`~pamqp.common.FieldTable`
        :param mechanisms: Available security mechanisms
            - Default: ``PLAIN``
        :param locales: Available message locales
            - Default: ``en_US``

        """
        __annotations__: typing.Dict[str, object] = {
            'version_major': int,
            'version_minor': int,
            'server_properties': common.FieldTable,
            'mechanisms': str,
            'locales': str
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'version_major', 'version_minor', 'server_properties',
            'mechanisms', 'locales'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x000A000A  # pamqp Mapping Index
        name = 'Connection.Start'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.StartOk']

        # Class Attribute Types for unmarshaling
        _version_major = 'octet'
        _version_minor = 'octet'
        _server_properties = 'table'
        _mechanisms = 'longstr'
        _locales = 'longstr'

        def __init__(self,
                     version_major: int = 0,
                     version_minor: int = 9,
                     server_properties: typing.Optional[
                         common.FieldTable] = None,
                     mechanisms: str = 'PLAIN',
                     locales: str = 'en_US') -> None:
            """Initialize the :class:`Connection.Start` class"""
            self.version_major = version_major
            self.version_minor = version_minor
            self.server_properties = server_properties or {}
            self.mechanisms = mechanisms
            self.locales = locales

    class StartOk(base.Frame):
        """Select security mechanism and locale

        This method selects a SASL security mechanism.

        :param client_properties: Client properties
            - Default: ``{}``
        :type client_properties: :const:`~pamqp.common.FieldTable`
        :param mechanism: Selected security mechanism
            - Default: ``PLAIN``
        :param response: Security response data
            - Default: ``''``
        :param locale: Selected message locale
            - Default: ``en_US``

        """
        __annotations__: typing.Dict[str, object] = {
            'client_properties': common.FieldTable,
            'mechanism': str,
            'response': str,
            'locale': str
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'client_properties', 'mechanism', 'response', 'locale'
        ]

        frame_id = 11  # AMQP Frame ID
        index = 0x000A000B  # pamqp Mapping Index
        name = 'Connection.StartOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _client_properties = 'table'
        _mechanism = 'shortstr'
        _response = 'longstr'
        _locale = 'shortstr'

        def __init__(self,
                     client_properties: typing.Optional[
                         common.FieldTable] = None,
                     mechanism: str = 'PLAIN',
                     response: str = '',
                     locale: str = 'en_US') -> None:
            """Initialize the :class:`Connection.StartOk` class"""
            self.client_properties = client_properties or {}
            self.mechanism = mechanism
            self.response = response
            self.locale = locale

    class Secure(base.Frame):
        """Security mechanism challenge

        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.

        :param challenge: Security challenge data

        """
        __annotations__: typing.Dict[str, object] = {'challenge': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'challenge'
        ]

        frame_id = 20  # AMQP Frame ID
        index = 0x000A0014  # pamqp Mapping Index
        name = 'Connection.Secure'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.SecureOk']

        # Class Attribute Types for unmarshaling
        _challenge = 'longstr'

        def __init__(self, challenge: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Connection.Secure` class"""
            self.challenge = challenge

    class SecureOk(base.Frame):
        """Security mechanism response

        This method attempts to authenticate, passing a block of SASL data for
        the security mechanism at the server side.

        :param response: Security response data

        """
        __annotations__: typing.Dict[str, object] = {'response': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'response'
        ]

        frame_id = 21  # AMQP Frame ID
        index = 0x000A0015  # pamqp Mapping Index
        name = 'Connection.SecureOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _response = 'longstr'

        def __init__(self, response: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Connection.SecureOk` class"""
            self.response = response

    class Tune(base.Frame):
        """Propose connection tuning parameters

        This method proposes a set of connection configuration values to the
        client. The client can accept and/or adjust these.

        :param channel_max: Proposed maximum channels
            - Default: ``0``
        :param frame_max: Proposed maximum frame size
            - Default: ``0``
        :param heartbeat: Desired heartbeat delay
            - Default: ``0``

        """
        __annotations__: typing.Dict[str, object] = {
            'channel_max': int,
            'frame_max': int,
            'heartbeat': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'channel_max', 'frame_max', 'heartbeat'
        ]

        frame_id = 30  # AMQP Frame ID
        index = 0x000A001E  # pamqp Mapping Index
        name = 'Connection.Tune'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.TuneOk']

        # Class Attribute Types for unmarshaling
        _channel_max = 'short'
        _frame_max = 'long'
        _heartbeat = 'short'

        def __init__(self,
                     channel_max: int = 0,
                     frame_max: int = 0,
                     heartbeat: int = 0) -> None:
            """Initialize the :class:`Connection.Tune` class"""
            self.channel_max = channel_max
            self.frame_max = frame_max
            self.heartbeat = heartbeat

    class TuneOk(base.Frame):
        """Negotiate connection tuning parameters

        This method sends the client's connection tuning parameters to the
        server. Certain fields are negotiated, others provide capability
        information.

        :param channel_max: Negotiated maximum channels
            - Default: ``0``
        :param frame_max: Negotiated maximum frame size
            - Default: ``0``
        :param heartbeat: Desired heartbeat delay
            - Default: ``0``

        """
        __annotations__: typing.Dict[str, object] = {
            'channel_max': int,
            'frame_max': int,
            'heartbeat': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'channel_max', 'frame_max', 'heartbeat'
        ]

        frame_id = 31  # AMQP Frame ID
        index = 0x000A001F  # pamqp Mapping Index
        name = 'Connection.TuneOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _channel_max = 'short'
        _frame_max = 'long'
        _heartbeat = 'short'

        def __init__(self,
                     channel_max: int = 0,
                     frame_max: int = 0,
                     heartbeat: int = 0) -> None:
            """Initialize the :class:`Connection.TuneOk` class"""
            self.channel_max = channel_max
            self.frame_max = frame_max
            self.heartbeat = heartbeat

    class Open(base.Frame):
        """Open connection to virtual host

        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.

        :param virtual_host: Virtual host name
            - Default: ``/``
        :param capabilities: Deprecated, must be empty
            - Default: ``''``
        :param insist: Deprecated, must be ``False``
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'virtual_host': str,
            'capabilities': str,
            'insist': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'virtual_host', 'capabilities', 'insist'
        ]

        frame_id = 40  # AMQP Frame ID
        index = 0x000A0028  # pamqp Mapping Index
        name = 'Connection.Open'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.OpenOk']

        # Class Attribute Types for unmarshaling
        _virtual_host = 'shortstr'
        _capabilities = 'shortstr'
        _insist = 'bit'

        def __init__(self,
                     virtual_host: str = '/',
                     capabilities: str = '',
                     insist: bool = False) -> None:
            """Initialize the :class:`Connection.Open` class"""
            self.virtual_host = virtual_host
            self.capabilities = capabilities
            self.insist = insist
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.virtual_host is not None and len(self.virtual_host) > 127:
                raise ValueError('Max length exceeded for virtual_host')
            if self.capabilities is not None and self.capabilities != '':
                raise ValueError('capabilities must be empty')
            if self.insist is not None and self.insist is not False:
                raise ValueError('insist must be False')

    class OpenOk(base.Frame):
        """Signal that connection is ready

        This method signals to the client that the connection is ready for use.

        :param known_hosts: Deprecated, must be empty
            - Default: ``''``

        """
        __annotations__: typing.Dict[str, object] = {'known_hosts': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'known_hosts'
        ]

        frame_id = 41  # AMQP Frame ID
        index = 0x000A0029  # pamqp Mapping Index
        name = 'Connection.OpenOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _known_hosts = 'shortstr'

        def __init__(self, known_hosts: str = '') -> None:
            """Initialize the :class:`Connection.OpenOk` class"""
            self.known_hosts = known_hosts
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.known_hosts is not None and self.known_hosts != '':
                raise ValueError('known_hosts must be empty')

    class Close(base.Frame):
        """Request a connection close

        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.

        :param reply_code: Reply code from server
        :param reply_text: Localised reply text
            - Default: ``''``
        :param class_id: Failing method class
        :param method_id: Failing method ID

        """
        __annotations__: typing.Dict[str, object] = {
            'reply_code': int,
            'reply_text': str,
            'class_id': int,
            'method_id': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'reply_code', 'reply_text', 'class_id', 'method_id'
        ]

        frame_id = 50  # AMQP Frame ID
        index = 0x000A0032  # pamqp Mapping Index
        name = 'Connection.Close'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.CloseOk']

        # Class Attribute Types for unmarshaling
        _reply_code = 'short'
        _reply_text = 'shortstr'
        _class_id = 'short'
        _method_id = 'short'

        def __init__(self,
                     reply_code: typing.Optional[int] = None,
                     reply_text: str = '',
                     class_id: typing.Optional[int] = None,
                     method_id: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Connection.Close` class"""
            self.reply_code = reply_code
            self.reply_text = reply_text or ''
            self.class_id = class_id
            self.method_id = method_id

    class CloseOk(base.Frame):
        """Confirm a connection close

        This method confirms a :class:`Connection.Close` method and tells the
        recipient that it is safe to release resources for the connection and
        close the socket.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 51  # AMQP Frame ID
        index = 0x000A0033  # pamqp Mapping Index
        name = 'Connection.CloseOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Blocked(base.Frame):
        """Indicate that connection is blocked

        This method indicates that a connection has been blocked and does not
        accept new publishes.

        :param reason: Block reason
            - Default: ``''``

        """
        __annotations__: typing.Dict[str, object] = {'reason': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'reason'
        ]

        frame_id = 60  # AMQP Frame ID
        index = 0x000A003C  # pamqp Mapping Index
        name = 'Connection.Blocked'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _reason = 'shortstr'

        def __init__(self, reason: str = '') -> None:
            """Initialize the :class:`Connection.Blocked` class"""
            self.reason = reason

    class Unblocked(base.Frame):
        """Indicate that connection is unblocked

        This method indicates that a connection has been unblocked and now
        accepts publishes.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 61  # AMQP Frame ID
        index = 0x000A003D  # pamqp Mapping Index
        name = 'Connection.Unblocked'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class UpdateSecret(base.Frame):
        """Update secret

        This method updates the secret used to authenticate this connection. It
        is used when secrets have an expiration date and need to be renewed,
        like OAuth 2 tokens.

        :param new_secret: New secret
        :param reason: Reason

        """
        __annotations__: typing.Dict[str, object] = {
            'new_secret': str,
            'reason': str
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'new_secret', 'reason'
        ]

        frame_id = 70  # AMQP Frame ID
        index = 0x000A0046  # pamqp Mapping Index
        name = 'Connection.UpdateSecret'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Connection.UpdateSecretOk']

        # Class Attribute Types for unmarshaling
        _new_secret = 'longstr'
        _reason = 'shortstr'

        def __init__(self,
                     new_secret: typing.Optional[str] = None,
                     reason: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Connection.UpdateSecret` class"""
            self.new_secret = new_secret
            self.reason = reason

    class UpdateSecretOk(base.Frame):
        """Update secret response

        This method confirms the updated secret is valid.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 71  # AMQP Frame ID
        index = 0x000A0047  # pamqp Mapping Index
        name = 'Connection.UpdateSecretOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


class Channel:
    """Work with channels

    The channel class provides methods for a client to establish a channel to a
    server and for both peers to operate the channel thereafter.

    """
    __slots__: typing.List[str] = []

    frame_id = 20  # AMQP Frame ID
    index = 0x00140000  # pamqp Mapping Index

    class Open(base.Frame):
        """Open a channel for use

        This method opens a channel to the server.

        :param out_of_band: Protocol level field, do not use, must be ``0``.
            - Default: ``0``

        """
        __annotations__: typing.Dict[str, object] = {'out_of_band': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'out_of_band'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x0014000A  # pamqp Mapping Index
        name = 'Channel.Open'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Channel.OpenOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _out_of_band = 'shortstr'

        def __init__(self, out_of_band: str = '0') -> None:
            """Initialize the :class:`Channel.Open` class"""
            self.out_of_band = out_of_band
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.out_of_band is not None and self.out_of_band != '0':
                raise ValueError('out_of_band must be 0')

    class OpenOk(base.Frame):
        """Signal that the channel is ready

        This method signals to the client that the channel is ready for use.

        :param channel_id: Deprecated, must be ``0``
            - Default: ``0``

        """
        __annotations__: typing.Dict[str, object] = {'channel_id': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'channel_id'
        ]

        frame_id = 11  # AMQP Frame ID
        index = 0x0014000B  # pamqp Mapping Index
        name = 'Channel.OpenOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _channel_id = 'longstr'

        def __init__(self, channel_id: str = '0') -> None:
            """Initialize the :class:`Channel.OpenOk` class"""
            self.channel_id = channel_id
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.channel_id is not None and self.channel_id != '0':
                raise ValueError('channel_id must be 0')

    class Flow(base.Frame):
        """Enable/disable flow from peer

        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 :class:`Basic.GetOk` methods.

        :param active: Start/stop content frames

        """
        __annotations__: typing.Dict[str, object] = {'active': bool}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'active'
        ]

        frame_id = 20  # AMQP Frame ID
        index = 0x00140014  # pamqp Mapping Index
        name = 'Channel.Flow'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Channel.FlowOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _active = 'bit'

        def __init__(self, active: typing.Optional[bool] = None) -> None:
            """Initialize the :class:`Channel.Flow` class"""
            self.active = active

    class FlowOk(base.Frame):
        """Confirm a flow method

        Confirms to the peer that a flow command was received and processed.

        :param active: Current flow setting

        """
        __annotations__: typing.Dict[str, object] = {'active': bool}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'active'
        ]

        frame_id = 21  # AMQP Frame ID
        index = 0x00140015  # pamqp Mapping Index
        name = 'Channel.FlowOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _active = 'bit'

        def __init__(self, active: typing.Optional[bool] = None) -> None:
            """Initialize the :class:`Channel.FlowOk` class"""
            self.active = active

    class Close(base.Frame):
        """Request a channel close

        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.

        :param reply_code: Reply code from server
        :param reply_text: Localised reply text
            - Default: ``''``
        :param class_id: Failing method class
        :param method_id: Failing method ID

        """
        __annotations__: typing.Dict[str, object] = {
            'reply_code': int,
            'reply_text': str,
            'class_id': int,
            'method_id': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'reply_code', 'reply_text', 'class_id', 'method_id'
        ]

        frame_id = 40  # AMQP Frame ID
        index = 0x00140028  # pamqp Mapping Index
        name = 'Channel.Close'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Channel.CloseOk']

        # Class Attribute Types for unmarshaling
        _reply_code = 'short'
        _reply_text = 'shortstr'
        _class_id = 'short'
        _method_id = 'short'

        def __init__(self,
                     reply_code: typing.Optional[int] = None,
                     reply_text: str = '',
                     class_id: typing.Optional[int] = None,
                     method_id: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Channel.Close` class"""
            self.reply_code = reply_code
            self.reply_text = reply_text or ''
            self.class_id = class_id
            self.method_id = method_id

    class CloseOk(base.Frame):
        """Confirm a channel close

        This method confirms a :class:`Channel.Close` method and tells the
        recipient that it is safe to release resources for the channel.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 41  # AMQP Frame ID
        index = 0x00140029  # pamqp Mapping Index
        name = 'Channel.CloseOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


class Exchange:
    """Work with exchanges

    Exchanges match and distribute messages across queues. Exchanges can be
    configured in the server or declared at runtime.

    """
    __slots__: typing.List[str] = []

    frame_id = 40  # AMQP Frame ID
    index = 0x00280000  # pamqp Mapping Index

    class Declare(base.Frame):
        """Verify exchange exists, create if needed

        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.

        .. note:: The AMQP type argument is referred to as "exchange_type" to
            not conflict with the Python type keyword.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param exchange: exchange name
            - Default: ``''``
        :param exchange_type: Exchange type
            - Default: ``direct``
        :param passive: Do not create exchange
            - Default: ``False``
        :param durable: Request a durable exchange
            - Default: ``False``
        :param auto_delete: Auto-delete when unused
            - Default: ``False``
        :param internal: Create internal exchange
            - Default: ``False``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments for declaration
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'exchange': str,
            'exchange_type': str,
            'passive': bool,
            'durable': bool,
            'auto_delete': bool,
            'internal': bool,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'exchange', 'exchange_type', 'passive', 'durable',
            'auto_delete', 'internal', 'nowait', 'arguments'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x0028000A  # pamqp Mapping Index
        name = 'Exchange.Declare'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Exchange.DeclareOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _exchange = 'shortstr'
        _exchange_type = 'shortstr'
        _passive = 'bit'
        _durable = 'bit'
        _auto_delete = 'bit'
        _internal = 'bit'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                exchange: str = '',
                exchange_type: str = 'direct',
                passive: bool = False,
                durable: bool = False,
                auto_delete: bool = False,
                internal: bool = False,
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Exchange.Declare` class"""
            self.ticket = ticket
            self.exchange = exchange
            self.exchange_type = exchange_type
            self.passive = passive
            self.durable = durable
            self.auto_delete = auto_delete
            self.internal = internal
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class DeclareOk(base.Frame):
        """Confirm exchange declaration

        This method confirms a Declare method and confirms the name of the
        exchange, essential for automatically-named exchanges.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 11  # AMQP Frame ID
        index = 0x0028000B  # pamqp Mapping Index
        name = 'Exchange.DeclareOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Delete(base.Frame):
        """Delete an exchange

        This method deletes an exchange. When an exchange is deleted all queue
        bindings on the exchange are cancelled.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param exchange: exchange name
            - Default: ``''``
        :param if_unused: Delete only if unused
            - Default: ``False``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'exchange': str,
            'if_unused': bool,
            'nowait': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'exchange', 'if_unused', 'nowait'
        ]

        frame_id = 20  # AMQP Frame ID
        index = 0x00280014  # pamqp Mapping Index
        name = 'Exchange.Delete'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Exchange.DeleteOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _exchange = 'shortstr'
        _if_unused = 'bit'
        _nowait = 'bit'

        def __init__(self,
                     ticket: int = 0,
                     exchange: str = '',
                     if_unused: bool = False,
                     nowait: bool = False) -> None:
            """Initialize the :class:`Exchange.Delete` class"""
            self.ticket = ticket
            self.exchange = exchange
            self.if_unused = if_unused
            self.nowait = nowait
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class DeleteOk(base.Frame):
        """Confirm deletion of an exchange

        This method confirms the deletion of an exchange.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 21  # AMQP Frame ID
        index = 0x00280015  # pamqp Mapping Index
        name = 'Exchange.DeleteOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Bind(base.Frame):
        """Bind exchange to an exchange

        This method binds an exchange to an exchange.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param destination: Name of the destination exchange to bind to
            - Default: ``''``
        :param source: Name of the source exchange to bind to
            - Default: ``''``
        :param routing_key: Message routing key
            - Default: ``''``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments for binding
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'destination': str,
            'source': str,
            'routing_key': str,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'destination', 'source', 'routing_key', 'nowait',
            'arguments'
        ]

        frame_id = 30  # AMQP Frame ID
        index = 0x0028001E  # pamqp Mapping Index
        name = 'Exchange.Bind'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Exchange.BindOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _destination = 'shortstr'
        _source = 'shortstr'
        _routing_key = 'shortstr'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                destination: str = '',
                source: str = '',
                routing_key: str = '',
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Exchange.Bind` class"""
            self.ticket = ticket
            self.destination = destination
            self.source = source
            self.routing_key = routing_key
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.destination is not None and len(self.destination) > 127:
                raise ValueError('Max length exceeded for destination')
            if self.destination is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.destination):
                raise ValueError('Invalid value for destination')
            if self.source is not None and len(self.source) > 127:
                raise ValueError('Max length exceeded for source')
            if self.source is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.source):
                raise ValueError('Invalid value for source')

    class BindOk(base.Frame):
        """Confirm bind successful

        This method confirms that the bind was successful.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 31  # AMQP Frame ID
        index = 0x0028001F  # pamqp Mapping Index
        name = 'Exchange.BindOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Unbind(base.Frame):
        """Unbind an exchange from an exchange

        This method unbinds an exchange from an exchange.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param destination: Specifies the name of the destination exchange to
            unbind.
            - Default: ``''``
        :param source: Specifies the name of the source exchange to unbind.
            - Default: ``''``
        :param routing_key: Routing key of binding
            - Default: ``''``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments of binding
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'destination': str,
            'source': str,
            'routing_key': str,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'destination', 'source', 'routing_key', 'nowait',
            'arguments'
        ]

        frame_id = 40  # AMQP Frame ID
        index = 0x00280028  # pamqp Mapping Index
        name = 'Exchange.Unbind'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Exchange.UnbindOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _destination = 'shortstr'
        _source = 'shortstr'
        _routing_key = 'shortstr'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                destination: str = '',
                source: str = '',
                routing_key: str = '',
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Exchange.Unbind` class"""
            self.ticket = ticket
            self.destination = destination
            self.source = source
            self.routing_key = routing_key
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.destination is not None and len(self.destination) > 127:
                raise ValueError('Max length exceeded for destination')
            if self.destination is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.destination):
                raise ValueError('Invalid value for destination')
            if self.source is not None and len(self.source) > 127:
                raise ValueError('Max length exceeded for source')
            if self.source is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.source):
                raise ValueError('Invalid value for source')

    class UnbindOk(base.Frame):
        """Confirm unbind successful

        This method confirms that the unbind was successful.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 51  # AMQP Frame ID
        index = 0x00280033  # pamqp Mapping Index
        name = 'Exchange.UnbindOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


class Queue:
    """Work with queues

    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.

    """
    __slots__: typing.List[str] = []

    frame_id = 50  # AMQP Frame ID
    index = 0x00320000  # pamqp Mapping Index

    class Declare(base.Frame):
        """Declare queue, create if needed

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: queue name
            - Default: ``''``
        :param passive: Do not create queue
            - Default: ``False``
        :param durable: Request a durable queue
            - Default: ``False``
        :param exclusive: Request an exclusive queue
            - Default: ``False``
        :param auto_delete: Auto-delete queue when unused
            - Default: ``False``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments for declaration
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'passive': bool,
            'durable': bool,
            'exclusive': bool,
            'auto_delete': bool,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'passive', 'durable', 'exclusive',
            'auto_delete', 'nowait', 'arguments'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x0032000A  # pamqp Mapping Index
        name = 'Queue.Declare'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Queue.DeclareOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _passive = 'bit'
        _durable = 'bit'
        _exclusive = 'bit'
        _auto_delete = 'bit'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                queue: str = '',
                passive: bool = False,
                durable: bool = False,
                exclusive: bool = False,
                auto_delete: bool = False,
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Queue.Declare` class"""
            self.ticket = ticket
            self.queue = queue
            self.passive = passive
            self.durable = durable
            self.exclusive = exclusive
            self.auto_delete = auto_delete
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class DeclareOk(base.Frame):
        """Confirms a queue definition

        This method confirms a Declare method and confirms the name of the
        queue, essential for automatically-named queues.

        :param queue: Reports the name of the queue. If the server generated a
            queue name, this field contains that name.
        :param message_count: Number of messages in the queue.
        :param consumer_count: Number of consumers
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'queue': str,
            'message_count': int,
            'consumer_count': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'queue', 'message_count', 'consumer_count'
        ]

        frame_id = 11  # AMQP Frame ID
        index = 0x0032000B  # pamqp Mapping Index
        name = 'Queue.DeclareOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _queue = 'shortstr'
        _message_count = 'long'
        _consumer_count = 'long'

        def __init__(self,
                     queue: typing.Optional[str] = None,
                     message_count: typing.Optional[int] = None,
                     consumer_count: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Queue.DeclareOk` class"""
            self.queue = queue
            self.message_count = message_count
            self.consumer_count = consumer_count
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class Bind(base.Frame):
        """Bind queue to an exchange

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to bind.
            - Default: ``''``
        :param exchange: Name of the exchange to bind to
            - Default: ``''``
        :param routing_key: Message routing key
            - Default: ``''``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments for binding
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'exchange': str,
            'routing_key': str,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'exchange', 'routing_key', 'nowait', 'arguments'
        ]

        frame_id = 20  # AMQP Frame ID
        index = 0x00320014  # pamqp Mapping Index
        name = 'Queue.Bind'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Queue.BindOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                queue: str = '',
                exchange: str = '',
                routing_key: str = '',
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Queue.Bind` class"""
            self.ticket = ticket
            self.queue = queue
            self.exchange = exchange
            self.routing_key = routing_key
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class BindOk(base.Frame):
        """Confirm bind successful

        This method confirms that the bind was successful.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 21  # AMQP Frame ID
        index = 0x00320015  # pamqp Mapping Index
        name = 'Queue.BindOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Purge(base.Frame):
        """Purge a queue

        This method removes all messages from a queue which are not awaiting
        acknowledgment.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to purge.
            - Default: ``''``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'nowait': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'nowait'
        ]

        frame_id = 30  # AMQP Frame ID
        index = 0x0032001E  # pamqp Mapping Index
        name = 'Queue.Purge'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Queue.PurgeOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _nowait = 'bit'

        def __init__(self,
                     ticket: int = 0,
                     queue: str = '',
                     nowait: bool = False) -> None:
            """Initialize the :class:`Queue.Purge` class"""
            self.ticket = ticket
            self.queue = queue
            self.nowait = nowait
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class PurgeOk(base.Frame):
        """Confirms a queue purge

        This method confirms the purge of a queue.

        :param message_count: Reports the number of messages purged.

        """
        __annotations__: typing.Dict[str, object] = {'message_count': int}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'message_count'
        ]

        frame_id = 31  # AMQP Frame ID
        index = 0x0032001F  # pamqp Mapping Index
        name = 'Queue.PurgeOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _message_count = 'long'

        def __init__(self, message_count: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Queue.PurgeOk` class"""
            self.message_count = message_count

    class Delete(base.Frame):
        """Delete a queue

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to delete.
            - Default: ``''``
        :param if_unused: Delete only if unused
            - Default: ``False``
        :param if_empty: Delete only if empty
            - Default: ``False``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'if_unused': bool,
            'if_empty': bool,
            'nowait': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'if_unused', 'if_empty', 'nowait'
        ]

        frame_id = 40  # AMQP Frame ID
        index = 0x00320028  # pamqp Mapping Index
        name = 'Queue.Delete'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Queue.DeleteOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _if_unused = 'bit'
        _if_empty = 'bit'
        _nowait = 'bit'

        def __init__(self,
                     ticket: int = 0,
                     queue: str = '',
                     if_unused: bool = False,
                     if_empty: bool = False,
                     nowait: bool = False) -> None:
            """Initialize the :class:`Queue.Delete` class"""
            self.ticket = ticket
            self.queue = queue
            self.if_unused = if_unused
            self.if_empty = if_empty
            self.nowait = nowait
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class DeleteOk(base.Frame):
        """Confirm deletion of a queue

        This method confirms the deletion of a queue.

        :param message_count: Reports the number of messages deleted.

        """
        __annotations__: typing.Dict[str, object] = {'message_count': int}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'message_count'
        ]

        frame_id = 41  # AMQP Frame ID
        index = 0x00320029  # pamqp Mapping Index
        name = 'Queue.DeleteOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _message_count = 'long'

        def __init__(self, message_count: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Queue.DeleteOk` class"""
            self.message_count = message_count

    class Unbind(base.Frame):
        """Unbind a queue from an exchange

        This method unbinds a queue from an exchange.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to unbind.
            - Default: ``''``
        :param exchange: The name of the exchange to unbind from.
            - Default: ``''``
        :param routing_key: Routing key of binding
            - Default: ``''``
        :param arguments: Arguments of binding
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'exchange': str,
            'routing_key': str,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'exchange', 'routing_key', 'arguments'
        ]

        frame_id = 50  # AMQP Frame ID
        index = 0x00320032  # pamqp Mapping Index
        name = 'Queue.Unbind'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Queue.UnbindOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                queue: str = '',
                exchange: str = '',
                routing_key: str = '',
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Queue.Unbind` class"""
            self.ticket = ticket
            self.queue = queue
            self.exchange = exchange
            self.routing_key = routing_key
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class UnbindOk(base.Frame):
        """Confirm unbind successful

        This method confirms that the unbind was successful.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 51  # AMQP Frame ID
        index = 0x00320033  # pamqp Mapping Index
        name = 'Queue.UnbindOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


class Basic:
    """Work with basic content

    The Basic class provides methods that support an industry-standard
    messaging model.

    """
    __slots__: typing.List[str] = []

    frame_id = 60  # AMQP Frame ID
    index = 0x003C0000  # pamqp Mapping Index

    class Qos(base.Frame):
        """Specify quality of service

        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.

        :param prefetch_size: Prefetch window in octets
            - Default: ``0``
        :param prefetch_count: Prefetch window in messages
            - Default: ``0``
        :param global_: Apply to entire connection
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {
            'prefetch_size': int,
            'prefetch_count': int,
            'global_': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'prefetch_size', 'prefetch_count', 'global_'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x003C000A  # pamqp Mapping Index
        name = 'Basic.Qos'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Basic.QosOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _prefetch_size = 'long'
        _prefetch_count = 'short'
        _global_ = 'bit'

        def __init__(self,
                     prefetch_size: int = 0,
                     prefetch_count: int = 0,
                     global_: bool = False) -> None:
            """Initialize the :class:`Basic.Qos` class"""
            self.prefetch_size = prefetch_size
            self.prefetch_count = prefetch_count
            self.global_ = global_

    class QosOk(base.Frame):
        """Confirm the requested qos

        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.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 11  # AMQP Frame ID
        index = 0x003C000B  # pamqp Mapping Index
        name = 'Basic.QosOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Consume(base.Frame):
        """Start a queue consumer

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to consume from.
            - Default: ``''``
        :param 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.
            - Default: ``''``
        :param no_local: Do not deliver own messages
            - Default: ``False``
        :param no_ack: No acknowledgement needed
            - Default: ``False``
        :param exclusive: Request exclusive access
            - Default: ``False``
        :param nowait: Do not send a reply method
            - Default: ``False``
        :param arguments: Arguments for declaration
            - Default: ``{}``
        :type arguments: :const:`~pamqp.common.Arguments`
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'consumer_tag': str,
            'no_local': bool,
            'no_ack': bool,
            'exclusive': bool,
            'nowait': bool,
            'arguments': common.Arguments
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'consumer_tag', 'no_local', 'no_ack',
            'exclusive', 'nowait', 'arguments'
        ]

        frame_id = 20  # AMQP Frame ID
        index = 0x003C0014  # pamqp Mapping Index
        name = 'Basic.Consume'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Basic.ConsumeOk']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _consumer_tag = 'shortstr'
        _no_local = 'bit'
        _no_ack = 'bit'
        _exclusive = 'bit'
        _nowait = 'bit'
        _arguments = 'table'

        def __init__(
                self,
                ticket: int = 0,
                queue: str = '',
                consumer_tag: str = '',
                no_local: bool = False,
                no_ack: bool = False,
                exclusive: bool = False,
                nowait: bool = False,
                arguments: typing.Optional[common.Arguments] = None) -> None:
            """Initialize the :class:`Basic.Consume` class"""
            self.ticket = ticket
            self.queue = queue
            self.consumer_tag = consumer_tag
            self.no_local = no_local
            self.no_ack = no_ack
            self.exclusive = exclusive
            self.nowait = nowait
            self.arguments = arguments or {}
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class ConsumeOk(base.Frame):
        """Confirm a new consumer

        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.

        :param consumer_tag: Holds the consumer tag specified by the client or
            provided by the server.

        """
        __annotations__: typing.Dict[str, object] = {'consumer_tag': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'consumer_tag'
        ]

        frame_id = 21  # AMQP Frame ID
        index = 0x003C0015  # pamqp Mapping Index
        name = 'Basic.ConsumeOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _consumer_tag = 'shortstr'

        def __init__(self, consumer_tag: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Basic.ConsumeOk` class"""
            self.consumer_tag = consumer_tag

    class Cancel(base.Frame):
        """End a queue consumer

        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.

        :param consumer_tag: Consumer tag
        :param nowait: Do not send a reply method
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {
            'consumer_tag': str,
            'nowait': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'consumer_tag', 'nowait'
        ]

        frame_id = 30  # AMQP Frame ID
        index = 0x003C001E  # pamqp Mapping Index
        name = 'Basic.Cancel'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Basic.CancelOk']  # Valid responses to this method

        # Class Attribute Types for unmarshaling
        _consumer_tag = 'shortstr'
        _nowait = 'bit'

        def __init__(self,
                     consumer_tag: typing.Optional[str] = None,
                     nowait: bool = False) -> None:
            """Initialize the :class:`Basic.Cancel` class"""
            self.consumer_tag = consumer_tag
            self.nowait = nowait or False

    class CancelOk(base.Frame):
        """Confirm a cancelled consumer

        This method confirms that the cancellation was completed.

        :param consumer_tag: Consumer tag

        """
        __annotations__: typing.Dict[str, object] = {'consumer_tag': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'consumer_tag'
        ]

        frame_id = 31  # AMQP Frame ID
        index = 0x003C001F  # pamqp Mapping Index
        name = 'Basic.CancelOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _consumer_tag = 'shortstr'

        def __init__(self, consumer_tag: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Basic.CancelOk` class"""
            self.consumer_tag = consumer_tag

    class Publish(base.Frame):
        """Publish a message

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param exchange: 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.
            - Default: ``''``
        :param routing_key: Message routing key
            - Default: ``''``
        :param mandatory: Indicate mandatory routing
            - Default: ``False``
        :param immediate: Request immediate delivery
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'exchange': str,
            'routing_key': str,
            'mandatory': bool,
            'immediate': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'exchange', 'routing_key', 'mandatory', 'immediate'
        ]

        frame_id = 40  # AMQP Frame ID
        index = 0x003C0028  # pamqp Mapping Index
        name = 'Basic.Publish'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'
        _mandatory = 'bit'
        _immediate = 'bit'

        def __init__(self,
                     ticket: int = 0,
                     exchange: str = '',
                     routing_key: str = '',
                     mandatory: bool = False,
                     immediate: bool = False) -> None:
            """Initialize the :class:`Basic.Publish` class"""
            self.ticket = ticket
            self.exchange = exchange
            self.routing_key = routing_key
            self.mandatory = mandatory
            self.immediate = immediate
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class Return(base.Frame):
        """Return a failed message

        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.

        :param reply_code: Reply code from server
        :param reply_text: Localised reply text
            - Default: ``''``
        :param exchange: Specifies the name of the exchange that the message
            was originally published to.  May be empty, meaning the default
            exchange.
            - Default: ``''``
        :param routing_key: Message routing key
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'reply_code': int,
            'reply_text': str,
            'exchange': str,
            'routing_key': str
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'reply_code', 'reply_text', 'exchange', 'routing_key'
        ]

        frame_id = 50  # AMQP Frame ID
        index = 0x003C0032  # pamqp Mapping Index
        name = 'Basic.Return'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _reply_code = 'short'
        _reply_text = 'shortstr'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'

        def __init__(self,
                     reply_code: typing.Optional[int] = None,
                     reply_text: str = '',
                     exchange: str = '',
                     routing_key: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Basic.Return` class"""
            self.reply_code = reply_code
            self.reply_text = reply_text or ''
            self.exchange = exchange or ''
            self.routing_key = routing_key
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class Deliver(base.Frame):
        """Notify the client of a consumer message

        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.

        :param consumer_tag: Consumer tag
        :param delivery_tag: Server-assigned delivery tag
        :param redelivered: Message is being redelivered
            - Default: ``False``
        :param exchange: Specifies the name of the exchange that the message
            was originally published to. May be empty, indicating the default
            exchange.
            - Default: ``''``
        :param routing_key: Message routing key
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'consumer_tag': str,
            'delivery_tag': int,
            'redelivered': bool,
            'exchange': str,
            'routing_key': str
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'consumer_tag', 'delivery_tag', 'redelivered', 'exchange',
            'routing_key'
        ]

        frame_id = 60  # AMQP Frame ID
        index = 0x003C003C  # pamqp Mapping Index
        name = 'Basic.Deliver'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _consumer_tag = 'shortstr'
        _delivery_tag = 'longlong'
        _redelivered = 'bit'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'

        def __init__(self,
                     consumer_tag: typing.Optional[str] = None,
                     delivery_tag: typing.Optional[int] = None,
                     redelivered: bool = False,
                     exchange: str = '',
                     routing_key: typing.Optional[str] = None) -> None:
            """Initialize the :class:`Basic.Deliver` class"""
            self.consumer_tag = consumer_tag
            self.delivery_tag = delivery_tag
            self.redelivered = redelivered or False
            self.exchange = exchange or ''
            self.routing_key = routing_key
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class Get(base.Frame):
        """Direct access to a queue

        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.

        :param ticket: Deprecated, must be ``0``
            - Default: ``0``
        :param queue: Specifies the name of the queue to get a message from.
            - Default: ``''``
        :param no_ack: No acknowledgement needed
            - Default: ``False``
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'ticket': int,
            'queue': str,
            'no_ack': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'ticket', 'queue', 'no_ack'
        ]

        frame_id = 70  # AMQP Frame ID
        index = 0x003C0046  # pamqp Mapping Index
        name = 'Basic.Get'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Basic.GetOk', 'Basic.GetEmpty']

        # Class Attribute Types for unmarshaling
        _ticket = 'short'
        _queue = 'shortstr'
        _no_ack = 'bit'

        def __init__(self,
                     ticket: int = 0,
                     queue: str = '',
                     no_ack: bool = False) -> None:
            """Initialize the :class:`Basic.Get` class"""
            self.ticket = ticket
            self.queue = queue
            self.no_ack = no_ack
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.ticket is not None and self.ticket != 0:
                raise ValueError('ticket must be 0')
            if self.queue is not None and len(self.queue) > 256:
                raise ValueError('Max length exceeded for queue')
            if self.queue is not None and not constants.DOMAIN_REGEX[
                    'queue-name'].fullmatch(self.queue):
                raise ValueError('Invalid value for queue')

    class GetOk(base.Frame):
        """Provide client with a message

        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.

        :param delivery_tag: Server-assigned delivery tag
        :param redelivered: Message is being redelivered
            - Default: ``False``
        :param exchange: Specifies the name of the exchange that the message
            was originally published to. If empty, the message was published to
            the default exchange.
            - Default: ``''``
        :param routing_key: Message routing key
        :param message_count: Number of messages in the queue.
        :raises ValueError: when an argument fails to validate

        """
        __annotations__: typing.Dict[str, object] = {
            'delivery_tag': int,
            'redelivered': bool,
            'exchange': str,
            'routing_key': str,
            'message_count': int
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'delivery_tag', 'redelivered', 'exchange', 'routing_key',
            'message_count'
        ]

        frame_id = 71  # AMQP Frame ID
        index = 0x003C0047  # pamqp Mapping Index
        name = 'Basic.GetOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _delivery_tag = 'longlong'
        _redelivered = 'bit'
        _exchange = 'shortstr'
        _routing_key = 'shortstr'
        _message_count = 'long'

        def __init__(self,
                     delivery_tag: typing.Optional[int] = None,
                     redelivered: bool = False,
                     exchange: str = '',
                     routing_key: typing.Optional[str] = None,
                     message_count: typing.Optional[int] = None) -> None:
            """Initialize the :class:`Basic.GetOk` class"""
            self.delivery_tag = delivery_tag
            self.redelivered = redelivered or False
            self.exchange = exchange or ''
            self.routing_key = routing_key
            self.message_count = message_count
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.exchange is not None and len(self.exchange) > 127:
                raise ValueError('Max length exceeded for exchange')
            if self.exchange is not None and not constants.DOMAIN_REGEX[
                    'exchange-name'].fullmatch(self.exchange):
                raise ValueError('Invalid value for exchange')

    class GetEmpty(base.Frame):
        """Indicate no messages available

        This method tells the client that the queue has no messages available
        for the client.

        :param cluster_id: Deprecated, must be empty
            - Default: ``''``

        """
        __annotations__: typing.Dict[str, object] = {'cluster_id': str}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'cluster_id'
        ]

        frame_id = 72  # AMQP Frame ID
        index = 0x003C0048  # pamqp Mapping Index
        name = 'Basic.GetEmpty'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _cluster_id = 'shortstr'

        def __init__(self, cluster_id: str = '') -> None:
            """Initialize the :class:`Basic.GetEmpty` class"""
            self.cluster_id = cluster_id
            self.validate()

        def validate(self) -> None:
            """Validate the frame data ensuring all domains or attributes
            adhere to the protocol specification.

            :raises ValueError: on validation error

            """
            if self.cluster_id is not None and self.cluster_id != '':
                raise ValueError('cluster_id must be empty')

    class Ack(base.Frame):
        """Acknowledge one or more messages

        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.

        :param delivery_tag: Server-assigned delivery tag
            - Default: ``0``
        :param multiple: Acknowledge multiple messages
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {
            'delivery_tag': int,
            'multiple': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'delivery_tag', 'multiple'
        ]

        frame_id = 80  # AMQP Frame ID
        index = 0x003C0050  # pamqp Mapping Index
        name = 'Basic.Ack'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _delivery_tag = 'longlong'
        _multiple = 'bit'

        def __init__(self,
                     delivery_tag: int = 0,
                     multiple: bool = False) -> None:
            """Initialize the :class:`Basic.Ack` class"""
            self.delivery_tag = delivery_tag
            self.multiple = multiple

    class Reject(base.Frame):
        """Reject an incoming message

        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.

        :param delivery_tag: Server-assigned delivery tag
        :param requeue: Requeue the message
            - Default: ``True``

        """
        __annotations__: typing.Dict[str, object] = {
            'delivery_tag': int,
            'requeue': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'delivery_tag', 'requeue'
        ]

        frame_id = 90  # AMQP Frame ID
        index = 0x003C005A  # pamqp Mapping Index
        name = 'Basic.Reject'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _delivery_tag = 'longlong'
        _requeue = 'bit'

        def __init__(self,
                     delivery_tag: typing.Optional[int] = None,
                     requeue: bool = True) -> None:
            """Initialize the :class:`Basic.Reject` class"""
            self.delivery_tag = delivery_tag
            self.requeue = requeue

    class RecoverAsync(base.Frame):
        """Redeliver unacknowledged messages

        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.

        .. deprecated:: This command is deprecated in AMQP 0-9-1

        :param requeue: Requeue the message
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {'requeue': bool}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'requeue'
        ]

        frame_id = 100  # AMQP Frame ID
        index = 0x003C0064  # pamqp Mapping Index
        name = 'Basic.RecoverAsync'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _requeue = 'bit'

        def __init__(self, requeue: bool = False) -> None:
            """Initialize the :class:`Basic.RecoverAsync` class"""
            self.requeue = requeue
            warnings.warn(constants.DEPRECATION_WARNING,
                          category=DeprecationWarning)

    class Recover(base.Frame):
        """Redeliver unacknowledged messages

        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.

        :param requeue: Requeue the message
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {'requeue': bool}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'requeue'
        ]

        frame_id = 110  # AMQP Frame ID
        index = 0x003C006E  # pamqp Mapping Index
        name = 'Basic.Recover'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Basic.RecoverOk']

        # Class Attribute Types for unmarshaling
        _requeue = 'bit'

        def __init__(self, requeue: bool = False) -> None:
            """Initialize the :class:`Basic.Recover` class"""
            self.requeue = requeue

    class RecoverOk(base.Frame):
        """Confirm recovery

        This method acknowledges a :class:`Basic.Recover` method.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 111  # AMQP Frame ID
        index = 0x003C006F  # pamqp Mapping Index
        name = 'Basic.RecoverOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Nack(base.Frame):
        """Reject one or more incoming messages

        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.

        :param delivery_tag: Server-assigned delivery tag
            - Default: ``0``
        :param multiple: Reject multiple messages
            - Default: ``False``
        :param requeue: Requeue the message
            - Default: ``True``

        """
        __annotations__: typing.Dict[str, object] = {
            'delivery_tag': int,
            'multiple': bool,
            'requeue': bool
        }
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'delivery_tag', 'multiple', 'requeue'
        ]

        frame_id = 120  # AMQP Frame ID
        index = 0x003C0078  # pamqp Mapping Index
        name = 'Basic.Nack'
        synchronous = False  # Indicates if this is a synchronous AMQP method

        # Class Attribute Types for unmarshaling
        _delivery_tag = 'longlong'
        _multiple = 'bit'
        _requeue = 'bit'

        def __init__(self,
                     delivery_tag: int = 0,
                     multiple: bool = False,
                     requeue: bool = True) -> None:
            """Initialize the :class:`Basic.Nack` class"""
            self.delivery_tag = delivery_tag
            self.multiple = multiple
            self.requeue = requeue

    class Properties(base.BasicProperties):
        """Content Properties

        .. Note:: The AMQP property type is named ``message_type`` as to not
                  conflict with the Python ``type`` keyword

        :param content_type: MIME content type
        :param content_encoding: MIME content encoding
        :param headers: Message header field table
        :type headers: typing.Optional[:const:`~pamqp.common.FieldTable`]
        :param delivery_mode: Non-persistent (1) or persistent (2)
        :param priority: Message priority, 0 to 9
        :param correlation_id: Application correlation identifier
        :param reply_to: Address to reply to
        :param expiration: Message expiration specification
        :param message_id: Application message identifier
        :param timestamp: Message timestamp
        :param message_type: Message type name
        :param user_id: Creating user id
        :param app_id: Creating application id
        :param cluster_id: Deprecated, must be empty
        :raises: ValueError

        """
        __annotations__: typing.Dict[str, object] = {
            'content_type': str,
            'content_encoding': str,
            'headers': common.FieldTable,
            'delivery_mode': int,
            'priority': int,
            'correlation_id': str,
            'reply_to': str,
            'expiration': str,
            'message_id': str,
            'timestamp': datetime.datetime,
            'message_type': str,
            'user_id': str,
            'app_id': str,
            'cluster_id': str
        }
        __slots__: typing.List[str] = [  # AMQ Properties Attributes
            'content_type', 'content_encoding', 'headers', 'delivery_mode',
            'priority', 'correlation_id', 'reply_to', 'expiration',
            'message_id', 'timestamp', 'message_type', 'user_id', 'app_id',
            'cluster_id'
        ]

        # Flag values for marshaling / unmarshaling
        flags = {
            'content_type': 32768,
            'content_encoding': 16384,
            'headers': 8192,
            'delivery_mode': 4096,
            'priority': 2048,
            'correlation_id': 1024,
            'reply_to': 512,
            'expiration': 256,
            'message_id': 128,
            'timestamp': 64,
            'message_type': 32,
            'user_id': 16,
            'app_id': 8,
            'cluster_id': 4
        }

        frame_id = 60  # AMQP Frame ID
        index = 0x003C  # pamqp Mapping Index
        name = 'Basic.Properties'

        # Class Attribute Types for unmarshaling
        _content_type = 'shortstr'
        _content_encoding = 'shortstr'
        _headers = 'table'
        _delivery_mode = 'octet'
        _priority = 'octet'
        _correlation_id = 'shortstr'
        _reply_to = 'shortstr'
        _expiration = 'shortstr'
        _message_id = 'shortstr'
        _timestamp = 'timestamp'
        _message_type = 'shortstr'
        _user_id = 'shortstr'
        _app_id = 'shortstr'
        _cluster_id = 'shortstr'

        def __init__(self,
                     content_type: typing.Optional[str] = None,
                     content_encoding: typing.Optional[str] = None,
                     headers: typing.Optional[common.FieldTable] = None,
                     delivery_mode: typing.Optional[int] = None,
                     priority: typing.Optional[int] = None,
                     correlation_id: typing.Optional[str] = None,
                     reply_to: typing.Optional[str] = None,
                     expiration: typing.Optional[str] = None,
                     message_id: typing.Optional[str] = None,
                     timestamp: typing.Optional[datetime.datetime] = None,
                     message_type: typing.Optional[str] = None,
                     user_id: typing.Optional[str] = None,
                     app_id: typing.Optional[str] = None,
                     cluster_id: str = '') -> None:
            """Initialize the Basic.Properties class"""
            self.content_type = content_type
            self.content_encoding = content_encoding
            self.headers = headers
            self.delivery_mode = delivery_mode
            self.priority = priority
            self.correlation_id = correlation_id
            self.reply_to = reply_to
            self.expiration = expiration
            self.message_id = message_id
            self.timestamp = timestamp
            self.message_type = message_type
            self.user_id = user_id
            self.app_id = app_id
            self.cluster_id = cluster_id
            self.validate()


class Tx:
    """Work with transactions

    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 :class:`Basic.Publish` methods is not defined.

    """
    __slots__: typing.List[str] = []

    frame_id = 90  # AMQP Frame ID
    index = 0x005A0000  # pamqp Mapping Index

    class Select(base.Frame):
        """Select standard transaction mode

        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.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 10  # AMQP Frame ID
        index = 0x005A000A  # pamqp Mapping Index
        name = 'Tx.Select'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Tx.SelectOk']  # Valid responses to this method

    class SelectOk(base.Frame):
        """Confirm transaction mode

        This method confirms to the client that the channel was successfully
        set to use standard transactions.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 11  # AMQP Frame ID
        index = 0x005A000B  # pamqp Mapping Index
        name = 'Tx.SelectOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Commit(base.Frame):
        """Commit the current transaction

        This method commits all message publications and acknowledgments
        performed in the current transaction.  A new transaction starts
        immediately after a commit.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 20  # AMQP Frame ID
        index = 0x005A0014  # pamqp Mapping Index
        name = 'Tx.Commit'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Tx.CommitOk']  # Valid responses to this method

    class CommitOk(base.Frame):
        """Confirm a successful commit

        This method confirms to the client that the commit succeeded. Note that
        if a commit fails, the server raises a channel exception.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 21  # AMQP Frame ID
        index = 0x005A0015  # pamqp Mapping Index
        name = 'Tx.CommitOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method

    class Rollback(base.Frame):
        """Abandon the current transaction

        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.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 30  # AMQP Frame ID
        index = 0x005A001E  # pamqp Mapping Index
        name = 'Tx.Rollback'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        valid_responses = ['Tx.RollbackOk']  # Valid responses to this method

    class RollbackOk(base.Frame):
        """Confirm successful rollback

        This method confirms to the client that the rollback succeeded. Note
        that if an rollback fails, the server raises a channel exception.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 31  # AMQP Frame ID
        index = 0x005A001F  # pamqp Mapping Index
        name = 'Tx.RollbackOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


class Confirm:
    """Work with confirms

    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 :class:`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
    :class:`Confirm.Select` method. The server confirms messages by sending
    :class:`Basic.Ack` methods referring to these sequence numbers.

    """
    __slots__: typing.List[str] = []

    frame_id = 85  # AMQP Frame ID
    index = 0x00550000  # pamqp Mapping Index

    class Select(base.Frame):
        """Select confirm mode (i.e. enable publisher acknowledgements)

        This method sets the channel to use publisher acknowledgements. The
        client can only use this method on a non-transactional channel.

        :param nowait: Do not send a reply method
            - Default: ``False``

        """
        __annotations__: typing.Dict[str, object] = {'nowait': bool}
        __slots__: typing.List[str] = [  # AMQ Method Attributes
            'nowait'
        ]

        frame_id = 10  # AMQP Frame ID
        index = 0x0055000A  # pamqp Mapping Index
        name = 'Confirm.Select'
        synchronous = True  # Indicates if this is a synchronous AMQP method
        # Valid responses to this method
        valid_responses = ['Confirm.SelectOk']

        # Class Attribute Types for unmarshaling
        _nowait = 'bit'

        def __init__(self, nowait: bool = False) -> None:
            """Initialize the :class:`Confirm.Select` class"""
            self.nowait = nowait

    class SelectOk(base.Frame):
        """Acknowledge confirm mode

        This method confirms to the client that the channel was successfully
        set to use publisher acknowledgements.

        """
        __annotations__: typing.Dict[str, object] = {}
        __slots__: typing.List[str] = []  # AMQ Method Attributes

        frame_id = 11  # AMQP Frame ID
        index = 0x0055000B  # pamqp Mapping Index
        name = 'Confirm.SelectOk'
        synchronous = False  # Indicates if this is a synchronous AMQP method


# AMQP Class.Method Index Mapping
INDEX_MAPPING = {
    0x000A000A: Connection.Start,
    0x000A000B: Connection.StartOk,
    0x000A0014: Connection.Secure,
    0x000A0015: Connection.SecureOk,
    0x000A001E: Connection.Tune,
    0x000A001F: Connection.TuneOk,
    0x000A0028: Connection.Open,
    0x000A0029: Connection.OpenOk,
    0x000A0032: Connection.Close,
    0x000A0033: Connection.CloseOk,
    0x000A003C: Connection.Blocked,
    0x000A003D: Connection.Unblocked,
    0x000A0046: Connection.UpdateSecret,
    0x000A0047: Connection.UpdateSecretOk,
    0x0014000A: Channel.Open,
    0x0014000B: Channel.OpenOk,
    0x00140014: Channel.Flow,
    0x00140015: Channel.FlowOk,
    0x00140028: Channel.Close,
    0x00140029: Channel.CloseOk,
    0x0028000A: Exchange.Declare,
    0x0028000B: Exchange.DeclareOk,
    0x00280014: Exchange.Delete,
    0x00280015: Exchange.DeleteOk,
    0x0028001E: Exchange.Bind,
    0x0028001F: Exchange.BindOk,
    0x00280028: Exchange.Unbind,
    0x00280033: Exchange.UnbindOk,
    0x0032000A: Queue.Declare,
    0x0032000B: Queue.DeclareOk,
    0x00320014: Queue.Bind,
    0x00320015: Queue.BindOk,
    0x0032001E: Queue.Purge,
    0x0032001F: Queue.PurgeOk,
    0x00320028: Queue.Delete,
    0x00320029: Queue.DeleteOk,
    0x00320032: Queue.Unbind,
    0x00320033: Queue.UnbindOk,
    0x003C000A: Basic.Qos,
    0x003C000B: Basic.QosOk,
    0x003C0014: Basic.Consume,
    0x003C0015: Basic.ConsumeOk,
    0x003C001E: Basic.Cancel,
    0x003C001F: Basic.CancelOk,
    0x003C0028: Basic.Publish,
    0x003C0032: Basic.Return,
    0x003C003C: Basic.Deliver,
    0x003C0046: Basic.Get,
    0x003C0047: Basic.GetOk,
    0x003C0048: Basic.GetEmpty,
    0x003C0050: Basic.Ack,
    0x003C005A: Basic.Reject,
    0x003C0064: Basic.RecoverAsync,
    0x003C006E: Basic.Recover,
    0x003C006F: Basic.RecoverOk,
    0x003C0078: Basic.Nack,
    0x005A000A: Tx.Select,
    0x005A000B: Tx.SelectOk,
    0x005A0014: Tx.Commit,
    0x005A0015: Tx.CommitOk,
    0x005A001E: Tx.Rollback,
    0x005A001F: Tx.RollbackOk,
    0x0055000A: Confirm.Select,
    0x0055000B: Confirm.SelectOk
}
