def get_deadletter_receiver(<EOL>self, transfer_deadletter=False, prefetch=<NUM_LIT:0>,<EOL>mode=ReceiveSettleMode.PeekLock, idle_timeout=<NUM_LIT:0>, **kwargs):
if int(prefetch) < <NUM_LIT:0> or int(prefetch) > <NUM_LIT>:<EOL><INDENT>raise ValueError("<STR_LIT>")<EOL><DEDENT>prefetch += <NUM_LIT:1><EOL>handler_id = str(uuid.uuid4())<EOL>if transfer_deadletter:<EOL><INDENT>entity_uri = self.mgmt_client.format_transfer_dead_letter_queue_name(self.entity_uri)<EOL><DEDENT>else:<EOL><INDENT>entity_uri = self.mgmt_client.format_dead_letter_queue_name(self.entity_uri)<EOL><DEDENT>return Receiver(<EOL>handler_id,<EOL>entity_uri,<EOL>self.auth_config,<EOL>debug=self.debug,<EOL>timeout=int(idle_timeout * <NUM_LIT:1000>),<EOL>prefetch=prefetch,<EOL>mode=mode,<EOL>**kwargs)<EOL>
Get a Receiver for the deadletter endpoint of the queue.

        A Receiver represents a single open Connection with which multiple receive operations can be made.

        :param transfer_deadletter: Whether to connect to the transfer deadletter queue, or the standard
         deadletter queue. Default is False, using the standard deadletter endpoint.
        :type transfer_deadletter: bool
        :param prefetch: The maximum number of messages to cache with each request to the service.
         The default value is 0, meaning messages will be received from the service and processed
         one at a time. Increasing this value will improve message throughput performance but increase
         the change that messages will expire while they are cached if they're not processed fast enough.
        :type prefetch: int
        :param mode: The mode with which messages will be retrieved from the entity. The two options
         are PeekLock and ReceiveAndDelete. Messages received with PeekLock must be settled within a given
         lock period before they will be removed from the queue. Messages received with ReceiveAndDelete
         will be immediately removed from the queue, and cannot be subsequently rejected or re-received if
         the client fails to process the message. The default mode is PeekLock.
        :type mode: ~azure.servicebus.common.constants.ReceiveSettleMode
        :param idle_timeout: The timeout in seconds between received messages after which the receiver will
         automatically shutdown. The default value is 0, meaning no timeout.
        :type idle_timeout: int
        :returns: A Receiver instance with an unopened Connection.
        :rtype: ~azure.servicebus.receive_handler.Receiver

        Example:
            .. literalinclude:: ../examples/test_examples.py
                :start-after: [START get_dead_letter_receiver]
                :end-before: [END get_dead_letter_receiver]
                :language: python
                :dedent: 4
                :caption: Get the dead lettered messages