<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Uses of Class org.apache.qpid.protonj2.client.exceptions.ClientException (Qpid ProtonJ2 Parent 1.0.0-M19 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="use: package: org.apache.qpid.protonj2.client.exceptions, class: ClientException">
<meta name="generator" content="javadoc/ClassUseWriter">
<link rel="stylesheet" type="text/css" href="../../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../../script.js"></script>
</head>
<body class="class-use-page">
<script type="text/javascript"></script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../../../index.html">Overview</a></li>
<li><a href="../package-summary.html">Package</a></li>
<li><a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">Class</a></li>
<li class="nav-bar-cell1-rev">Use</li>
<li><a href="../package-tree.html">Tree</a></li>
<li><a href="../../../../../../../help-doc.html#use">Help</a></li>
</ul>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<div class="header">
<h1 title="Uses of Class org.apache.qpid.protonj2.client.exceptions.ClientException" class="title">Uses of Class<br>org.apache.qpid.protonj2.client.exceptions.ClientException</h1>
</div>
<div class="caption"><span>Packages that use <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table two-column-summary">
<div class="table-header col-first">Package</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><a href="#org.apache.qpid.protonj2.client">org.apache.qpid.protonj2.client</a></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><a href="#org.apache.qpid.protonj2.client.exceptions">org.apache.qpid.protonj2.client.exceptions</a></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><a href="#org.apache.qpid.protonj2.client.futures">org.apache.qpid.protonj2.client.futures</a></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><a href="#org.apache.qpid.protonj2.client.impl">org.apache.qpid.protonj2.client.impl</a></div>
<div class="col-last odd-row-color">&nbsp;</div>
</div>
<section class="class-uses">
<ul class="block-list">
<li>
<section class="detail" id="org.apache.qpid.protonj2.client">
<h2>Uses of <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a> in <a href="../../package-summary.html">org.apache.qpid.protonj2.client</a></h2>
<div class="caption"><span>Methods in <a href="../../package-summary.html">org.apache.qpid.protonj2.client</a> that throw <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSenderMessage.</span><code><a href="../../StreamSenderMessage.html#abort()" class="member-name-link">abort</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Marks the currently streaming message as being aborted.</div>
</div>
<div class="col-first odd-row-color"><code>long</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#absoluteExpiryTime()" class="member-name-link">absoluteExpiryTime</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#absoluteExpiryTime(long)" class="member-name-link">absoluteExpiryTime</a><wbr>(long&nbsp;expiryTime)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the absolute expiration time value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#accept()" class="member-name-link">accept</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Accepts and settles the delivery.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#accept()" class="member-name-link">accept</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Accepts and settles the delivery.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#addBodySection(org.apache.qpid.protonj2.types.messaging.Section)" class="member-name-link">addBodySection</a><wbr>(<a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&nbsp;bodySection)</code></div>
<div class="col-last odd-row-color">
<div class="block">Adds the given <a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> to the internal collection of sections that will be sent
 to the remote peer when this message is encoded.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#addCredit(int)" class="member-name-link">addCredit</a><wbr>(int&nbsp;credits)</code></div>
<div class="col-last even-row-color">
<div class="block">Adds credit to the <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> link for use when there receiver has not been configured
 with a credit window.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#addCredit(int)" class="member-name-link">addCredit</a><wbr>(int&nbsp;credits)</code></div>
<div class="col-last odd-row-color">
<div class="block">Adds credit to the <a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamReceiver</code></a> link for use when the receiver has not been configured
 with a credit window.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#address()" class="member-name-link">address</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the address that the <a href="../../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a> instance will be subscribed to.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#annotation(java.lang.String)" class="member-name-link">annotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the requested message annotation value from this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#annotation(java.lang.String,java.lang.Object)" class="member-name-link">annotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the given message annotation value at the given key, replacing any previous value
 that was assigned to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Return the current <a href="../../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#annotations(org.apache.qpid.protonj2.types.messaging.MessageAnnotations)" class="member-name-link">annotations</a><wbr>(<a href="../../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a>&nbsp;messageAnnotations)</code></div>
<div class="col-last even-row-color">
<div class="block">Assign or replace the <a href="../../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>MessageAnnotations</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Decodes the <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> payload and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> containing a copy
 of any associated <a href="../../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>DeliveryAnnotations</code></a> that were transmitted with the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>
 payload of this <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Decodes the <a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamDelivery</code></a> payload and returns a <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a> containing a copy
 of any associated <a href="../../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>DeliveryAnnotations</code></a> that were transmitted with the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>
 payload of this <a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamDelivery</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#applicationProperties()" class="member-name-link">applicationProperties</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Return the current <a href="../../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#applicationProperties(org.apache.qpid.protonj2.types.messaging.ApplicationProperties)" class="member-name-link">applicationProperties</a><wbr>(<a href="../../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a>&nbsp;applicationProperties)</code></div>
<div class="col-last even-row-color">
<div class="block">Assign or replace the <a href="../../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>ApplicationProperties</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#awaitAccepted()" class="member-name-link">awaitAccepted</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery with an <a href="../../../types/messaging/Accepted.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Accepted</code></a>
 disposition unless it has either already been settled and accepted or the original delivery
 was sent settled in which case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#awaitAccepted(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitAccepted</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery with an <a href="../../../types/messaging/Accepted.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Accepted</code></a>
 disposition unless it has either already been settled and accepted or the original delivery
 was sent settled in which case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#awaitAccepted()" class="member-name-link">awaitAccepted</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery with an <a href="../../../types/messaging/Accepted.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Accepted</code></a>
 disposition unless it has either already been settled and accepted or the original delivery
 was sent settled in which case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#awaitAccepted(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitAccepted</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery with an <a href="../../../types/messaging/Accepted.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Accepted</code></a>
 disposition unless it has either already been settled and accepted or the original delivery
 was sent settled in which case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#awaitSettlement()" class="member-name-link">awaitSettlement</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery unless it has
 either already been settled or the original delivery was sent settled in which
 case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#awaitSettlement(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitSettlement</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery unless it has
 either already been settled or the original delivery was sent settled in which
 case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#awaitSettlement()" class="member-name-link">awaitSettlement</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery unless it has
 either already been settled or the original delivery was sent settled in which
 case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#awaitSettlement(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitSettlement</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits if necessary for the remote to settle the sent delivery unless it has
 either already been settled or the original delivery was sent settled in which
 case the remote will not send a <a href="../../../types/transport/Disposition.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Disposition</code></a> back.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#beginMessage()" class="member-name-link">beginMessage</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates and returns a new <a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamSenderMessage</code></a> that can be used by the caller to perform
 streaming sends of large message payload data.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#beginMessage(java.util.Map)" class="member-name-link">beginMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates and returns a new <a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamSenderMessage</code></a> that can be used by the caller to perform
 streaming sends of large message payload data.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#beginTransaction()" class="member-name-link">beginTransaction</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Opens a new transaction scoped to this <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> if one is not already active.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="type parameter in Message">E</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#body()" class="member-name-link">body</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the body value that is conveyed in this message or null if no body was set locally
 or sent from the remote if this is an incoming message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#body(E)" class="member-name-link">body</a><wbr>(<a href="../../Message.html" title="type parameter in Message">E</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the body value that is to be conveyed to the remote when this message is sent.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSenderMessage.</span><code><a href="../../StreamSenderMessage.html#body(org.apache.qpid.protonj2.client.OutputStreamOptions)" class="member-name-link">body</a><wbr>(<a href="../../OutputStreamOptions.html" title="class in org.apache.qpid.protonj2.client">OutputStreamOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/OutputStream.html" title="class or interface in java.io" class="external-link"><code>OutputStream</code></a> instance configured with the given options which will
 write the bytes as the payload of one or more AMQP <a href="../../../types/messaging/Data.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Data</code></a> sections based on the
 provided configuration..</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#bodySections()" class="member-name-link">bodySections</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Create and return an unmodifiable <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link"><code>Collection</code></a> that contains the <a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances
 currently assigned to this message.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#bodySections(java.util.Collection)" class="member-name-link">bodySections</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;<a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;sections)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the body <a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> instances to use when encoding this message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#clearBodySections()" class="member-name-link">clearBodySections</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Clears all current body <a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> elements from the <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#commitTransaction()" class="member-name-link">commitTransaction</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Commit the currently active transaction in this Session.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamSenderMessage.</span><code><a href="../../StreamSenderMessage.html#complete()" class="member-name-link">complete</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Marks the currently streaming message as being complete.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Client.</span><code><a href="../../Client.html#connect(java.lang.String)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</code></div>
<div class="col-last even-row-color">
<div class="block">Connect to the specified host, using the default port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Client.</span><code><a href="../../Client.html#connect(java.lang.String,int)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port)</code></div>
<div class="col-last odd-row-color">
<div class="block">Connect to the specified host and port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Client.</span><code><a href="../../Client.html#connect(java.lang.String,int,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port,
 <a href="../../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">
<div class="block">Connect to the specified host and port, with given connection options.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Client.</span><code><a href="../../Client.html#connect(java.lang.String,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 <a href="../../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last odd-row-color">
<div class="block">Connect to the specified host, using the default port, without credentials and with all
 connection options set to their defaults.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#contentEncoding()" class="member-name-link">contentEncoding</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#contentEncoding(java.lang.String)" class="member-name-link">contentEncoding</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentEncoding)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the contentEncoding value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#contentType()" class="member-name-link">contentType</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#contentType(java.lang.String)" class="member-name-link">contentType</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;contentType)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the contentType value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#correlationId()" class="member-name-link">correlationId</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#correlationId(java.lang.Object)" class="member-name-link">correlationId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;correlationId)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the correlationId value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#creationTime()" class="member-name-link">creationTime</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#creationTime(long)" class="member-name-link">creationTime</a><wbr>(long&nbsp;createTime)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the creation time value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#defaultSender()" class="member-name-link">defaultSender</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the default anonymous sender used by this <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> for <a href="../../Connection.html#send(org.apache.qpid.protonj2.client.Message)"><code>Connection.send(Message)</code></a>
 calls.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#defaultSession()" class="member-name-link">defaultSession</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the default <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance that is used by this Connection to
 create the default anonymous connection <a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> as well as creating those
 resources created from the <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> such as <a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> and <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>
 instances not married to a specific <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#deliveryCount()" class="member-name-link">deliveryCount</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#deliveryCount(long)" class="member-name-link">deliveryCount</a><wbr>(long&nbsp;deliveryCount)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the value to assign to the delivery count field of this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="../../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the desired capabilities that the remote provided upon successfully opening the <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last odd-row-color">
<div class="block">Updates the DeliveryState, and optionally settle the delivery as well.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last even-row-color">
<div class="block">Updates the DeliveryState, and optionally settle the delivery as well.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last odd-row-color">
<div class="block">Updates the DeliveryState, and optionally settle the delivery as well.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last even-row-color">
<div class="block">Updates the DeliveryState, and optionally settle the delivery as well.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#drain()" class="member-name-link">drain</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Requests the remote to drain previously granted credit for this <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> link.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#drain()" class="member-name-link">drain</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Requests the remote to drain previously granted credit for this <a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamReceiver</code></a> link.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#durable()" class="member-name-link">durable</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">For an message being sent this method returns the current state of the
 durable flag on the message.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#durable(boolean)" class="member-name-link">durable</a><wbr>(boolean&nbsp;durable)</code></div>
<div class="col-last even-row-color">
<div class="block">Controls if the message is marked as durable when sent.</div>
</div>
<div class="col-first odd-row-color"><code>default <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#encode(java.util.Map)" class="member-name-link">encode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">
<div class="block">Encodes the <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> for transmission by the client.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">encode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations,
 <a href="../../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last even-row-color">
<div class="block">Encodes the <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> for transmission by the client.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#firstAcquirer()" class="member-name-link">firstAcquirer</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#firstAcquirer(boolean)" class="member-name-link">firstAcquirer</a><wbr>(boolean&nbsp;firstAcquirer)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the value to assign to the first acquirer field of this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#footer()" class="member-name-link">footer</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Return the current <a href="../../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#footer(org.apache.qpid.protonj2.types.messaging.Footer)" class="member-name-link">footer</a><wbr>(<a href="../../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a>&nbsp;footer)</code></div>
<div class="col-last even-row-color">
<div class="block">Assign or replace the <a href="../../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Footer</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#footer(java.lang.String)" class="member-name-link">footer</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the requested footer value from this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists or returns
 <code>null</code> otherwise.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#footer(java.lang.String,java.lang.Object)" class="member-name-link">footer</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the given footer value at the given key, replacing any previous value
 that was assigned to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#forEachAnnotation(java.util.function.BiConsumer)" class="member-name-link">forEachAnnotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last odd-row-color">
<div class="block">Invokes the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link"><code>BiConsumer</code></a> on each message annotation entry carried in this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#forEachBodySection(java.util.function.Consumer)" class="member-name-link">forEachBodySection</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging">Section</a>&lt;?&gt;&gt;&nbsp;consumer)</code></div>
<div class="col-last even-row-color">
<div class="block">Performs the given action for each body <a href="../../../types/messaging/Section.html" title="interface in org.apache.qpid.protonj2.types.messaging"><code>Section</code></a> of the <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> until all
 sections have been presented to the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link"><code>Consumer</code></a> or the consumer throws an exception.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#forEachFooter(java.util.function.BiConsumer)" class="member-name-link">forEachFooter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last odd-row-color">
<div class="block">Invokes the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link"><code>BiConsumer</code></a> on each footer entry carried in this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#forEachProperty(java.util.function.BiConsumer)" class="member-name-link">forEachProperty</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last even-row-color">
<div class="block">Invokes the given <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link"><code>BiConsumer</code></a> on each application property entry carried in this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#groupId()" class="member-name-link">groupId</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#groupId(java.lang.String)" class="member-name-link">groupId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;groupId)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the groupId value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>int</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#groupSequence()" class="member-name-link">groupSequence</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#groupSequence(int)" class="member-name-link">groupSequence</a><wbr>(int&nbsp;groupSequence)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the group sequence value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasAnnotation(java.lang.String)" class="member-name-link">hasAnnotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given message annotation key.</div>
</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasAnnotations()" class="member-name-link">hasAnnotations</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any message annotations.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasFooter(java.lang.String)" class="member-name-link">hasFooter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given footer key.</div>
</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasFooters()" class="member-name-link">hasFooters</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any footers.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasProperties()" class="member-name-link">hasProperties</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries any application properties.</div>
</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#hasProperty(java.lang.String)" class="member-name-link">hasProperty</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">
<div class="block">Query the <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> to determine if it carries the given application property key.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#header()" class="member-name-link">header</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Return the current <a href="../../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#header(org.apache.qpid.protonj2.types.messaging.Header)" class="member-name-link">header</a><wbr>(<a href="../../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a>&nbsp;header)</code></div>
<div class="col-last even-row-color">
<div class="block">Assign or replace the <a href="../../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Header</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color"><code>&lt;E&gt;&nbsp;<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#message()" class="member-name-link">message</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Decode the <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> payload and return an <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> object.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiverMessage</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#message()" class="member-name-link">message</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Decode the <a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamDelivery</code></a> payload and return an <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> object.</div>
</div>
<div class="col-first odd-row-color"><code>int</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#messageFormat()" class="member-name-link">messageFormat</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#messageFormat(int)" class="member-name-link">messageFormat</a><wbr>(int&nbsp;messageFormat)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the message format to use when the message is sent.</div>
</div>
<div class="col-first odd-row-color"><code>int</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#messageFormat()" class="member-name-link">messageFormat</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Gets the message format for the current delivery.</div>
</div>
<div class="col-first even-row-color"><code>int</code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#messageFormat()" class="member-name-link">messageFormat</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Gets the message format for the current delivery.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamSenderMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamSenderMessage</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamSenderMessage.</span><code><a href="../../StreamSenderMessage.html#messageFormat(int)" class="member-name-link">messageFormat</a><wbr>(int&nbsp;messageFormat)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the configured message format value that will be set on the first outgoing
 AMQP <a href="../../../types/transport/Transfer.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Transfer</code></a> frame for the delivery that comprises this streamed message.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#messageId()" class="member-name-link">messageId</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#messageId(java.lang.Object)" class="member-name-link">messageId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;messageId)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the message Id value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#modified(boolean,boolean)" class="member-name-link">modified</a><wbr>(boolean&nbsp;deliveryFailed,
 boolean&nbsp;undeliverableHere)</code></div>
<div class="col-last even-row-color">
<div class="block">Modifies and settles the delivery.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#modified(boolean,boolean)" class="member-name-link">modified</a><wbr>(boolean&nbsp;deliveryFailed,
 boolean&nbsp;undeliverableHere)</code></div>
<div class="col-last odd-row-color">
<div class="block">Modifies and settles the delivery.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#nextReceiver()" class="member-name-link">nextReceiver</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Waits indefinitely for a receiver created from the connection default session to have a
 delivery ready for receipt.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#nextReceiver(long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits for the configured time interval for a receiver created from the connection default
 session to have a delivery ready for receipt.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits indefinitely for a receiver created from the connection default session to have a
 delivery ready for receipt.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits for the configured time interval for a receiver created from the connection default
 session to have a delivery ready for receipt.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#nextReceiver()" class="member-name-link">nextReceiver</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#nextReceiver(long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last even-row-color">
<div class="block">Waits indefinitely for a receiver created from this session to have a delivery ready for
 receipt.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">
<div class="block">Waits for the given duration for a receiver created from this session to have a delivery ready
 for receipt.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="../../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the offered capabilities that the remote provided upon successfully opening the <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each message
 that is sent using this sender must specify an address in its destination address field.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a sender that is established to the 'anonymous relay' and as such each
 message that is sent using this sender must specify an address in its destination
 address field.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address and configure it
 such that the remote create a durable node.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from a dynamically generated node on the remote..</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from a dynamically generated node on the remote..</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a dynamic receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openReceiver(java.lang.String)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a receiver used to consumer messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a receiver used to consumer messages from the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openReceiver(java.lang.String)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a receiver used to consume messages from the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openSender(java.lang.String)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openSender(java.lang.String)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a sender used to send messages to the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openSession()" class="member-name-link">openSession</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance for use by the client application.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openSession(org.apache.qpid.protonj2.client.SessionOptions)" class="member-name-link">openSession</a><wbr>(<a href="../../SessionOptions.html" title="class in org.apache.qpid.protonj2.client">SessionOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a new <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a> instance for use by the client application.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openStreamReceiver(java.lang.String)" class="member-name-link">openStreamReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a streaming message receiver used to consume large messages from the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openStreamReceiver(java.lang.String,org.apache.qpid.protonj2.client.StreamReceiverOptions)" class="member-name-link">openStreamReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../StreamReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">StreamReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a streaming message receiver used to consume large messages from the given node address.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamSender.html" title="interface in org.apache.qpid.protonj2.client">StreamSender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openStreamSender(java.lang.String)" class="member-name-link">openStreamSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a stream sender used to send large messages to the given node address.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamSender.html" title="interface in org.apache.qpid.protonj2.client">StreamSender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#openStreamSender(java.lang.String,org.apache.qpid.protonj2.client.StreamSenderOptions)" class="member-name-link">openStreamSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../StreamSenderOptions.html" title="class in org.apache.qpid.protonj2.client">StreamSenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">
<div class="block">Creates a streaming sender used to send large messages to the given node address.</div>
</div>
<div class="col-first odd-row-color"><code>byte</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#priority()" class="member-name-link">priority</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#priority(byte)" class="member-name-link">priority</a><wbr>(byte&nbsp;priority)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the relative message priority.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Return the current <a href="../../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> assigned to this message, if none was assigned yet
 then this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../AdvancedMessage.html" title="type parameter in AdvancedMessage">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AdvancedMessage.</span><code><a href="../../AdvancedMessage.html#properties(org.apache.qpid.protonj2.types.messaging.Properties)" class="member-name-link">properties</a><wbr>(<a href="../../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a>&nbsp;properties)</code></div>
<div class="col-last even-row-color">
<div class="block">Assign or replace the <a href="../../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging"><code>Properties</code></a> instance associated with this message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="../../Link.html" title="interface in org.apache.qpid.protonj2.client"><code>Link</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the properties that the remote provided upon successfully opening the <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#property(java.lang.String)" class="member-name-link">property</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the requested application property value from this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> if it exists
 or returns null otherwise.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#property(java.lang.String,java.lang.Object)" class="member-name-link">property</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the given application property value at the given key, replacing any previous value
 that was assigned to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#queuedDeliveries()" class="member-name-link">queuedDeliveries</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns the number of Deliveries that are currently held in the <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> delivery
 queue.</div>
</div>
<div class="col-first odd-row-color"><code>long</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#queuedDeliveries()" class="member-name-link">queuedDeliveries</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns the number of Deliveries that are currently held in the <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a> delivery
 queue.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#rawInputStream()" class="member-name-link">rawInputStream</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Create and return an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> that reads the raw payload bytes of the given <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#rawInputStream()" class="member-name-link">rawInputStream</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Create and return an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link"><code>InputStream</code></a> that reads the raw payload bytes of the given <a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamDelivery</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSenderMessage.</span><code><a href="../../StreamSenderMessage.html#rawOutputStream()" class="member-name-link">rawOutputStream</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Creates an <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/OutputStream.html" title="class or interface in java.io" class="external-link"><code>OutputStream</code></a> instance that writes the bytes given without additional
 encoding or transformation.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#receive()" class="member-name-link">receive</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Blocking receive method that waits forever for the remote to provide a <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> for consumption.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#receive(long,java.util.concurrent.TimeUnit)" class="member-name-link">receive</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Blocking receive method that waits the given time interval for the remote to provide a
 <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> for consumption.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#receive()" class="member-name-link">receive</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Blocking receive method that waits forever for the remote to provide a <a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamReceiverMessage</code></a> for consumption.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#receive(long,java.util.concurrent.TimeUnit)" class="member-name-link">receive</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Blocking receive method that waits the given time interval for the remote to provide a
 <a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>StreamReceiverMessage</code></a> for consumption.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#reject(java.lang.String,java.lang.String)" class="member-name-link">reject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last odd-row-color">
<div class="block">Rejects and settles the delivery, sending supplied error information along
 with the rejection.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#reject(java.lang.String,java.lang.String)" class="member-name-link">reject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last even-row-color">
<div class="block">Rejects and settles the delivery, sending supplied error information along
 with the rejection.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#release()" class="member-name-link">release</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Releases and settles the delivery.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#release()" class="member-name-link">release</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Releases and settles the delivery.</div>
</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#remoteSettled()" class="member-name-link">remoteSettled</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Gets whether the delivery was settled by the remote peer yet.</div>
</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#remoteSettled()" class="member-name-link">remoteSettled</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Gets whether the delivery was settled by the remote peer yet.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#remoteState()" class="member-name-link">remoteState</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Gets the current remote state for the delivery.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#remoteState()" class="member-name-link">remoteState</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Gets the current remote state for the delivery.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#removeAnnotation(java.lang.String)" class="member-name-link">removeAnnotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Removes the given message annotation from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#removeFooter(java.lang.String)" class="member-name-link">removeFooter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">
<div class="block">Removes the given footer from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#removeProperty(java.lang.String)" class="member-name-link">removeProperty</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">
<div class="block">Removes the given application property from the values carried in the message currently, if none
 was present than this method returns <code>null</code>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#replyTo()" class="member-name-link">replyTo</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#replyTo(java.lang.String)" class="member-name-link">replyTo</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replyTo)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the replyTo value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#replyToGroupId()" class="member-name-link">replyToGroupId</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#replyToGroupId(java.lang.String)" class="member-name-link">replyToGroupId</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replyToGroupId)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the replyTo group Id value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Session.</span><code><a href="../../Session.html#rollbackTransaction()" class="member-name-link">rollbackTransaction</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Roll back the currently active transaction in this Session.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Connection.</span><code><a href="../../Connection.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sends the given <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> using the internal connection sender.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Sender.</span><code><a href="../../Sender.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last even-row-color">
<div class="block">Send the given message immediately if there is credit available or blocks if the link
 has not yet been granted credit.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Sender.</span><code><a href="../../Sender.html#send(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">
<div class="block">Send the given message immediately if there is credit available or blocks if the link
 has not yet been granted credit.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last even-row-color">
<div class="block">Send the given message immediately if there is credit available or blocks if the link
 has not yet been granted credit or there is a streaming send ongoing.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#send(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">
<div class="block">Send the given message immediately if there is credit available or blocks if the link
 has not yet been granted credit or there is a streaming send ongoing.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Settles the delivery locally.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Settles the delivery locally.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamTracker.</span><code><a href="../../StreamTracker.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Settles the delivery locally, if not <a href="../../LinkOptions.html#autoSettle()"><code>auto-settling</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Tracker.</span><code><a href="../../Tracker.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Settles the delivery locally, if not <a href="../../LinkOptions.html#autoSettle()"><code>auto-settling</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#settled()" class="member-name-link">settled</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#settled()" class="member-name-link">settled</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#source()" class="member-name-link">source</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Returns an immutable view of the remote <a href="../../Source.html" title="interface in org.apache.qpid.protonj2.client"><code>Source</code></a> object assigned to this link.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Delivery.</span><code><a href="../../Delivery.html#state()" class="member-name-link">state</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Gets the current local state for the delivery.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamDelivery.</span><code><a href="../../StreamDelivery.html#state()" class="member-name-link">state</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Gets the current local state for the delivery.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#subject()" class="member-name-link">subject</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#subject(java.lang.String)" class="member-name-link">subject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subject)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the subject value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Link.</span><code><a href="../../Link.html#target()" class="member-name-link">target</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Returns an immutable view of the remote <a href="../../Target.html" title="interface in org.apache.qpid.protonj2.client"><code>Target</code></a> object assigned to this sender link.</div>
</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#timeToLive()" class="member-name-link">timeToLive</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#timeToLive(long)" class="member-name-link">timeToLive</a><wbr>(long&nbsp;timeToLive)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the message time to live value.</div>
</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#to()" class="member-name-link">to</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#to(java.lang.String)" class="member-name-link">to</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;to)</code></div>
<div class="col-last odd-row-color">
<div class="block">Sets the 'to' value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>default <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#toAdvancedMessage()" class="member-name-link">toAdvancedMessage</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Safely convert this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance into an <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client"><code>AdvancedMessage</code></a> reference
 which can offer more low level APIs to an experienced client user.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Receiver.</span><code><a href="../../Receiver.html#tryReceive()" class="member-name-link">tryReceive</a>()</code></div>
<div class="col-last odd-row-color">
<div class="block">Non-blocking receive method that either returns a message is one is immediately available or
 returns null if none is currently at hand.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamReceiver.</span><code><a href="../../StreamReceiver.html#tryReceive()" class="member-name-link">tryReceive</a>()</code></div>
<div class="col-last even-row-color">
<div class="block">Non-blocking receive method that either returns a message is one is immediately available or
 returns null if none is currently at hand.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Sender.</span><code><a href="../../Sender.html#trySend(org.apache.qpid.protonj2.client.Message)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">
<div class="block">Send the given message if credit is available or returns null if no credit has been
 granted to the link at the time of the send attempt.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">Sender.</span><code><a href="../../Sender.html#trySend(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">
<div class="block">Send the given message if credit is available or returns null if no credit has been
 granted to the link at the time of the send attempt.</div>
</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#trySend(org.apache.qpid.protonj2.client.Message)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">
<div class="block">Send the given message if credit is available or returns null if no credit has been
 granted to the link at the time of the send attempt or a streaming send is ongoing.</div>
</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">StreamSender.</span><code><a href="../../StreamSender.html#trySend(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">
<div class="block">Send the given message if credit is available or returns null if no credit has been
 granted to the link at the time of the send attempt.</div>
</div>
<div class="col-first odd-row-color"><code>byte[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#userId()" class="member-name-link">userId</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;<a href="../../Message.html" title="type parameter in Message">E</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">Message.</span><code><a href="../../Message.html#userId(byte%5B%5D)" class="member-name-link">userId</a><wbr>(byte[]&nbsp;userId)</code></div>
<div class="col-last even-row-color">
<div class="block">Sets the user Id value to assign to this <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a>.</div>
</div>
</div>
</section>
</li>
<li>
<section class="detail" id="org.apache.qpid.protonj2.client.exceptions">
<h2>Uses of <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a> in <a href="../package-summary.html">org.apache.qpid.protonj2.client.exceptions</a></h2>
<div class="caption"><span>Subclasses of <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a> in <a href="../package-summary.html">org.apache.qpid.protonj2.client.exceptions</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientConnectionRedirectedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientConnectionRedirectedException</a></code></div>
<div class="col-last even-row-color">
<div class="block">A <a href="../ClientIOException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientIOException</code></a> type that defines that the remote peer has requested that this
 connection be redirected to some alternative peer.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientConnectionRemotelyClosedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientConnectionRemotelyClosedException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Exception thrown when the remote peer actively closes the <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> by sending
 and AMQP <a href="../../../types/transport/Close.html" title="class in org.apache.qpid.protonj2.types.transport"><code>Close</code></a> frame or when the IO layer is disconnected due to some other
 reason such as a security error or transient network error.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientConnectionSecurityException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientConnectionSecurityException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Connection level Security Exception used to indicate a security violation has occurred.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientConnectionSecuritySaslException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientConnectionSecuritySaslException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Security Exception used to indicate a security violation has occurred.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientDeliveryAbortedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientDeliveryAbortedException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Thrown in cases where an action was requested that cannot be performed because
 the delivery being operated on has been aborted by the remote sender.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientDeliveryIsPartialException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientDeliveryIsPartialException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown in cases where an action was requested that cannot be performed because
 the delivery being operated on is only the partial Transfer payload.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientDeliveryStateException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientDeliveryStateException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Thrown from client API that deal with a <a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client"><code>Delivery</code></a> or <a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client"><code>Tracker</code></a> where the outcome
 that results from that API can affect whether the API call succeeded or failed.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientIdleTimeoutException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientIdleTimeoutException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when the Provider fails a connection due to idle timeout.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientIllegalStateException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientIllegalStateException</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientIOException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientIOException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Exception type that is thrown when the provider has encountered an unrecoverable error.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientLinkRedirectedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientLinkRedirectedException</a></code></div>
<div class="col-last even-row-color">
<div class="block">A <a href="../ClientLinkRemotelyClosedException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientLinkRemotelyClosedException</code></a> type that defines that the remote peer has requested that
 this link be redirected to some alternative peer.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientLinkRemotelyClosedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientLinkRemotelyClosedException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Root exception type for cases of remote closure or client created <a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client"><code>Sender</code></a> or
 <a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client"><code>Receiver</code></a>.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientMessageFormatViolationException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientMessageFormatViolationException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Exception thrown from <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instances when the body section specified
 violates the configure message format of the message that is being created.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientOperationTimedOutException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientOperationTimedOutException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Indicates that an operation in the provider timed out waiting for completion</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientResourceRemotelyClosedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientResourceRemotelyClosedException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Root exception type for cases of remote closure or client created resources other
 than the Client <a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client"><code>Connection</code></a> which will throw exceptions rooted from the
 <a href="../ClientConnectionRemotelyClosedException.html" title="class in org.apache.qpid.protonj2.client.exceptions"><code>ClientConnectionRemotelyClosedException</code></a> to indicate a fatal connection
 level error that requires a new connection to be created.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientSendTimedOutException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientSendTimedOutException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when a message send operation times out in the Provider layer.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientSessionRemotelyClosedException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientSessionRemotelyClosedException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Root exception type for cases of remote closure or client created <a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client"><code>Session</code></a>.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientTransactionDeclarationException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientTransactionDeclarationException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when a transaction declaration fails or is rejected by the remote.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientTransactionInDoubtException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientTransactionInDoubtException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Thrown when a transaction operation fails and state is now unknown.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientTransactionNotActiveException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientTransactionNotActiveException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when a client attempt to commit or roll-back when no transaction has been declared.</div>
</div>
<div class="col-first even-row-color"><code>class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="../ClientTransactionRolledBackException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientTransactionRolledBackException</a></code></div>
<div class="col-last even-row-color">
<div class="block">Thrown when a message send operation times out in the Provider layer.</div>
</div>
<div class="col-first odd-row-color"><code>class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="../ClientUnsupportedOperationException.html" class="type-name-link" title="class in org.apache.qpid.protonj2.client.exceptions">ClientUnsupportedOperationException</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Thrown when an action request is not supported through this provider.</div>
</div>
</div>
</section>
</li>
<li>
<section class="detail" id="org.apache.qpid.protonj2.client.futures">
<h2>Uses of <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a> in <a href="../../futures/package-summary.html">org.apache.qpid.protonj2.client.futures</a></h2>
<div class="caption"><span>Methods in <a href="../../futures/package-summary.html">org.apache.qpid.protonj2.client.futures</a> with parameters of type <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">AsyncResult.</span><code><a href="../../futures/AsyncResult.html#failed(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">failed</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;result)</code></div>
<div class="col-last even-row-color">
<div class="block">If the operation fails this method is invoked with the Exception
 that caused the failure.</div>
</div>
<div class="col-first odd-row-color"><code>void</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientFuture.</span><code><a href="../../futures/ClientFuture.html#failed(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">failed</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;result)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">NoOpAsyncResult.</span><code><a href="../../futures/NoOpAsyncResult.html#failed(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">failed</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;result)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
<li>
<section class="detail" id="org.apache.qpid.protonj2.client.impl">
<h2>Uses of <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a> in <a href="../../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a></h2>
<div class="caption"><span>Fields in <a href="../../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> declared as <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>protected <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#failureCause" class="member-name-link">failureCause</a></code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Methods in <a href="../../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> that return <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.ClientOutgoingEnvelope.</span><code><a href="../../impl/ClientStreamSender.ClientOutgoingEnvelope.html#createSendTimedOutException()" class="member-name-link">createSendTimedOutException</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Methods in <a href="../../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> with parameters of type <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientStreamSender.ClientOutgoingEnvelope.html" title="class in org.apache.qpid.protonj2.client.impl">ClientStreamSender.ClientOutgoingEnvelope</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.ClientOutgoingEnvelope.</span><code><a href="../../impl/ClientStreamSender.ClientOutgoingEnvelope.html#failed(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">failed</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;exception)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected final void</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#immediateLinkShutdown(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">immediateLinkShutdown</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected abstract void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected void</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientReceiverLinkType.</span><code><a href="../../impl/ClientReceiverLinkType.html#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSender.</span><code><a href="../../impl/ClientSender.html#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected void</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#linkSpecificCleanupHandler(org.apache.qpid.protonj2.client.exceptions.ClientException)" class="member-name-link">linkSpecificCleanupHandler</a><wbr>(<a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a>&nbsp;failureCause)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
<div class="caption"><span>Methods in <a href="../../impl/package-summary.html">org.apache.qpid.protonj2.client.impl</a> that throw <a href="../ClientException.html" title="class in org.apache.qpid.protonj2.client.exceptions">ClientException</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#absoluteExpiryTime()" class="member-name-link">absoluteExpiryTime</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#accept()" class="member-name-link">accept</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientReceiver.</span><code><a href="../../impl/ClientReceiver.html#addCredit(int)" class="member-name-link">addCredit</a><wbr>(int&nbsp;credits)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#addCredit(int)" class="member-name-link">addCredit</a><wbr>(int&nbsp;credits)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#address()" class="member-name-link">address</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#annotation(java.lang.String)" class="member-name-link">annotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientDelivery.</span><code><a href="../../impl/ClientDelivery.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamDelivery.</span><code><a href="../../impl/ClientStreamDelivery.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../../types/messaging/MessageAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">MessageAnnotations</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#annotations()" class="member-name-link">annotations</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/ApplicationProperties.html" title="class in org.apache.qpid.protonj2.types.messaging">ApplicationProperties</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#applicationProperties()" class="member-name-link">applicationProperties</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#awaitAccepted()" class="member-name-link">awaitAccepted</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#awaitAccepted(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitAccepted</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#awaitAccepted()" class="member-name-link">awaitAccepted</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#awaitAccepted(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitAccepted</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#awaitAccepted()" class="member-name-link">awaitAccepted</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#awaitAccepted(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitAccepted</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#awaitSettlement()" class="member-name-link">awaitSettlement</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#awaitSettlement(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitSettlement</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#awaitSettlement()" class="member-name-link">awaitSettlement</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#awaitSettlement(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitSettlement</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#awaitSettlement()" class="member-name-link">awaitSettlement</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#awaitSettlement(long,java.util.concurrent.TimeUnit)" class="member-name-link">awaitSettlement</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>org.apache.qpid.protonj2.client.impl.ClientStreamSenderMessage</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#beginMessage()" class="member-name-link">beginMessage</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>org.apache.qpid.protonj2.client.impl.ClientStreamSenderMessage</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#beginMessage(java.util.Map)" class="member-name-link">beginMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#beginTransaction()" class="member-name-link">beginTransaction</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#body()" class="member-name-link">body</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#checkClosedOrFailed()" class="member-name-link">checkClosedOrFailed</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>protected void</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#checkClosedOrFailed()" class="member-name-link">checkClosedOrFailed</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#checkClosedOrFailed()" class="member-name-link">checkClosedOrFailed</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#commitTransaction()" class="member-name-link">commitTransaction</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../../impl/ClientInstance.html#connect(java.lang.String)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../../impl/ClientInstance.html#connect(java.lang.String,int)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../../impl/ClientInstance.html#connect(java.lang.String,int,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 int&nbsp;port,
 <a href="../../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Connection.html" title="interface in org.apache.qpid.protonj2.client">Connection</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientInstance.</span><code><a href="../../impl/ClientInstance.html#connect(java.lang.String,org.apache.qpid.protonj2.client.ConnectionOptions)" class="member-name-link">connect</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;host,
 <a href="../../ConnectionOptions.html" title="class in org.apache.qpid.protonj2.client">ConnectionOptions</a>&nbsp;options)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#contentEncoding()" class="member-name-link">contentEncoding</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#contentType()" class="member-name-link">contentType</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static &lt;E&gt;&nbsp;<a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#convertMessage(org.apache.qpid.protonj2.client.Message)" class="member-name-link">convertMessage</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;&nbsp;message)</code></div>
<div class="col-last even-row-color">
<div class="block">Converts a <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client"><code>Message</code></a> instance into a <a href="../../impl/ClientMessage.html" title="class in org.apache.qpid.protonj2.client.impl"><code>ClientMessage</code></a> instance
 either by cast or by construction of a new instance with a copy of the
 values carried in the given message.</div>
</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#correlationId()" class="member-name-link">correlationId</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#creationTime()" class="member-name-link">creationTime</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#decodeMessage(org.apache.qpid.protonj2.buffer.ProtonBuffer,java.util.function.Consumer)" class="member-name-link">decodeMessage</a><wbr>(<a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">DeliveryAnnotations</a>&gt;&nbsp;daConsumer)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#decodeMessage(org.apache.qpid.protonj2.codec.Decoder,org.apache.qpid.protonj2.buffer.ProtonBuffer,java.util.function.Consumer)" class="member-name-link">decodeMessage</a><wbr>(<a href="../../../codec/Decoder.html" title="interface in org.apache.qpid.protonj2.codec">Decoder</a>&nbsp;decoder,
 <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">DeliveryAnnotations</a>&gt;&nbsp;daConsumer)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static <a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#decodeMessage(org.apache.qpid.protonj2.codec.Decoder,org.apache.qpid.protonj2.codec.DecoderState,org.apache.qpid.protonj2.buffer.ProtonBuffer,java.util.function.Consumer)" class="member-name-link">decodeMessage</a><wbr>(<a href="../../../codec/Decoder.html" title="interface in org.apache.qpid.protonj2.codec">Decoder</a>&nbsp;decoder,
 <a href="../../../codec/DecoderState.html" title="interface in org.apache.qpid.protonj2.codec">DecoderState</a>&nbsp;decoderState,
 <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a>&nbsp;buffer,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="../../../types/messaging/DeliveryAnnotations.html" title="class in org.apache.qpid.protonj2.types.messaging">DeliveryAnnotations</a>&gt;&nbsp;daConsumer)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#defaultSender()" class="member-name-link">defaultSender</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#defaultSession()" class="member-name-link">defaultSession</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>long</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#deliveryCount()" class="member-name-link">deliveryCount</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#desiredCapabilities()" class="member-name-link">desiredCapabilities</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#disposition(org.apache.qpid.protonj2.client.DeliveryState,boolean)" class="member-name-link">disposition</a><wbr>(<a href="../../DeliveryState.html" title="interface in org.apache.qpid.protonj2.client">DeliveryState</a>&nbsp;state,
 boolean&nbsp;settle)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientReceiver.</span><code><a href="../../impl/ClientReceiver.html#drain()" class="member-name-link">drain</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/Future.html" title="class or interface in java.util.concurrent" class="external-link">Future</a>&lt;<a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#drain()" class="member-name-link">drain</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#durable()" class="member-name-link">durable</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientMessage.</span><code><a href="../../impl/ClientMessage.html#encode(java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">encode</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations,
 <a href="../../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#encodeMessage(org.apache.qpid.protonj2.client.AdvancedMessage,java.util.Map)" class="member-name-link">encodeMessage</a><wbr>(<a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#encodeMessage(org.apache.qpid.protonj2.client.AdvancedMessage,java.util.Map,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator)" class="member-name-link">encodeMessage</a><wbr>(<a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations,
 <a href="../../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>static <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#encodeMessage(org.apache.qpid.protonj2.codec.Encoder,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.client.AdvancedMessage,java.util.Map)" class="member-name-link">encodeMessage</a><wbr>(<a href="../../../codec/Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a>&nbsp;encoder,
 <a href="../../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>static <a href="../../../buffer/ProtonBuffer.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBuffer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientMessageSupport.</span><code><a href="../../impl/ClientMessageSupport.html#encodeMessage(org.apache.qpid.protonj2.codec.Encoder,org.apache.qpid.protonj2.codec.EncoderState,org.apache.qpid.protonj2.buffer.ProtonBufferAllocator,org.apache.qpid.protonj2.client.AdvancedMessage,java.util.Map)" class="member-name-link">encodeMessage</a><wbr>(<a href="../../../codec/Encoder.html" title="interface in org.apache.qpid.protonj2.codec">Encoder</a>&nbsp;encoder,
 <a href="../../../codec/EncoderState.html" title="interface in org.apache.qpid.protonj2.codec">EncoderState</a>&nbsp;encoderState,
 <a href="../../../buffer/ProtonBufferAllocator.html" title="interface in org.apache.qpid.protonj2.buffer">ProtonBufferAllocator</a>&nbsp;allocator,
 <a href="../../AdvancedMessage.html" title="interface in org.apache.qpid.protonj2.client">AdvancedMessage</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#firstAcquirer()" class="member-name-link">firstAcquirer</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/Footer.html" title="class in org.apache.qpid.protonj2.types.messaging">Footer</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#footer()" class="member-name-link">footer</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#footer(java.lang.String)" class="member-name-link">footer</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiverMessage</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#forEachAnnotation(java.util.function.BiConsumer)" class="member-name-link">forEachAnnotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiverMessage</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#forEachFooter(java.util.function.BiConsumer)" class="member-name-link">forEachFooter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiverMessage.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiverMessage</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#forEachProperty(java.util.function.BiConsumer)" class="member-name-link">forEachProperty</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/BiConsumer.html" title="class or interface in java.util.function" class="external-link">BiConsumer</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;action)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#groupId()" class="member-name-link">groupId</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>int</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#groupSequence()" class="member-name-link">groupSequence</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasAnnotation(java.lang.String)" class="member-name-link">hasAnnotation</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasAnnotations()" class="member-name-link">hasAnnotations</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasFooter(java.lang.String)" class="member-name-link">hasFooter</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasFooters()" class="member-name-link">hasFooters</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>boolean</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasProperties()" class="member-name-link">hasProperties</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>boolean</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#hasProperty(java.lang.String)" class="member-name-link">hasProperty</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../../types/messaging/Header.html" title="class in org.apache.qpid.protonj2.types.messaging">Header</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#header()" class="member-name-link">header</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>&lt;E&gt;&nbsp;<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientDelivery.</span><code><a href="../../impl/ClientDelivery.html#message()" class="member-name-link">message</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientStreamReceiverMessage.html" title="class in org.apache.qpid.protonj2.client.impl">ClientStreamReceiverMessage</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamDelivery.</span><code><a href="../../impl/ClientStreamDelivery.html#message()" class="member-name-link">message</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>int</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#messageFormat()" class="member-name-link">messageFormat</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#messageId()" class="member-name-link">messageId</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#modified(boolean,boolean)" class="member-name-link">modified</a><wbr>(boolean&nbsp;deliveryFailed,
 boolean&nbsp;undeliverableHere)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#nextReceiver()" class="member-name-link">nextReceiver</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#nextReceiver(long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#nextReceiver()" class="member-name-link">nextReceiver</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#nextReceiver(long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#nextReceiver(org.apache.qpid.protonj2.client.NextReceiverPolicy,long,java.util.concurrent.TimeUnit)" class="member-name-link">nextReceiver</a><wbr>(<a href="../../NextReceiverPolicy.html" title="enum in org.apache.qpid.protonj2.client">NextReceiverPolicy</a>&nbsp;policy,
 long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#offeredCapabilities()" class="member-name-link">offeredCapabilities</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openAnonymousSender()" class="member-name-link">openAnonymousSender</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openAnonymousSender(org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openAnonymousSender</a><wbr>(<a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDurableReceiver(java.lang.String,java.lang.String)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDurableReceiver(java.lang.String,java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDurableReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;subscriptionName,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDynamicReceiver()" class="member-name-link">openDynamicReceiver</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDynamicReceiver(java.util.Map)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDynamicReceiver(java.util.Map,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;dynamicNodeProperties,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openDynamicReceiver(org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openDynamicReceiver</a><wbr>(<a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openReceiver(java.lang.String)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openReceiver(java.lang.String)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openReceiver(java.lang.String)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Receiver.html" title="interface in org.apache.qpid.protonj2.client">Receiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openReceiver(java.lang.String,org.apache.qpid.protonj2.client.ReceiverOptions)" class="member-name-link">openReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../ReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">ReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openSender(java.lang.String)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openSender(java.lang.String)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openSender(java.lang.String)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Sender.html" title="interface in org.apache.qpid.protonj2.client">Sender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSession.</span><code><a href="../../impl/ClientStreamSession.html#openSender(java.lang.String,org.apache.qpid.protonj2.client.SenderOptions)" class="member-name-link">openSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../SenderOptions.html" title="class in org.apache.qpid.protonj2.client">SenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openSession()" class="member-name-link">openSession</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openSession(org.apache.qpid.protonj2.client.SessionOptions)" class="member-name-link">openSession</a><wbr>(<a href="../../SessionOptions.html" title="class in org.apache.qpid.protonj2.client">SessionOptions</a>&nbsp;sessionOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openStreamReceiver(java.lang.String)" class="member-name-link">openStreamReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamReceiver.html" title="interface in org.apache.qpid.protonj2.client">StreamReceiver</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openStreamReceiver(java.lang.String,org.apache.qpid.protonj2.client.StreamReceiverOptions)" class="member-name-link">openStreamReceiver</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../StreamReceiverOptions.html" title="class in org.apache.qpid.protonj2.client">StreamReceiverOptions</a>&nbsp;receiverOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamSender.html" title="interface in org.apache.qpid.protonj2.client">StreamSender</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openStreamSender(java.lang.String)" class="member-name-link">openStreamSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamSender.html" title="interface in org.apache.qpid.protonj2.client">StreamSender</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#openStreamSender(java.lang.String,org.apache.qpid.protonj2.client.StreamSenderOptions)" class="member-name-link">openStreamSender</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;address,
 <a href="../../StreamSenderOptions.html" title="class in org.apache.qpid.protonj2.client">StreamSenderOptions</a>&nbsp;senderOptions)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>byte</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#priority()" class="member-name-link">priority</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../../types/messaging/Properties.html" title="class in org.apache.qpid.protonj2.types.messaging">Properties</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#properties()" class="member-name-link">properties</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#property(java.lang.String)" class="member-name-link">property</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;key)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>long</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#queuedDeliveries()" class="member-name-link">queuedDeliveries</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientDelivery.</span><code><a href="../../impl/ClientDelivery.html#rawInputStream()" class="member-name-link">rawInputStream</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamDelivery.</span><code><a href="../../impl/ClientStreamDelivery.html#rawInputStream()" class="member-name-link">rawInputStream</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientReceiver.</span><code><a href="../../impl/ClientReceiver.html#receive()" class="member-name-link">receive</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientReceiver.</span><code><a href="../../impl/ClientReceiver.html#receive(long,java.util.concurrent.TimeUnit)" class="member-name-link">receive</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;units)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#receive()" class="member-name-link">receive</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#receive(long,java.util.concurrent.TimeUnit)" class="member-name-link">receive</a><wbr>(long&nbsp;timeout,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/TimeUnit.html" title="class or interface in java.util.concurrent" class="external-link">TimeUnit</a>&nbsp;unit)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#reject(java.lang.String,java.lang.String)" class="member-name-link">reject</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;condition,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#release()" class="member-name-link">release</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#replyTo()" class="member-name-link">replyTo</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#replyToGroupId()" class="member-name-link">replyToGroupId</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Session.html" title="interface in org.apache.qpid.protonj2.client">Session</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSession.</span><code><a href="../../impl/ClientSession.html#rollbackTransaction()" class="member-name-link">rollbackTransaction</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientConnection.</span><code><a href="../../impl/ClientConnection.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSender.</span><code><a href="../../impl/ClientSender.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSender.</span><code><a href="../../impl/ClientSender.html#send(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#send(org.apache.qpid.protonj2.client.Message)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#send(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">send</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../impl/ClientDeliverable.html" title="type parameter in ClientDeliverable">DeliveryType</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientDeliverable.</span><code><a href="../../impl/ClientDeliverable.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientNoOpStreamTracker.</span><code><a href="../../impl/ClientNoOpStreamTracker.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientNoOpTracker.</span><code><a href="../../impl/ClientNoOpTracker.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../impl/ClientTrackable.html" title="type parameter in ClientTrackable">TrackerType</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientTrackable.</span><code><a href="../../impl/ClientTrackable.html#settle()" class="member-name-link">settle</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Source.html" title="interface in org.apache.qpid.protonj2.client">Source</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#source()" class="member-name-link">source</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#subject()" class="member-name-link">subject</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Target.html" title="interface in org.apache.qpid.protonj2.client">Target</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#target()" class="member-name-link">target</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>long</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#timeToLive()" class="member-name-link">timeToLive</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#to()" class="member-name-link">to</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Delivery.html" title="interface in org.apache.qpid.protonj2.client">Delivery</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientReceiver.</span><code><a href="../../impl/ClientReceiver.html#tryReceive()" class="member-name-link">tryReceive</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamDelivery.html" title="interface in org.apache.qpid.protonj2.client">StreamDelivery</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamReceiver.</span><code><a href="../../impl/ClientStreamReceiver.html#tryReceive()" class="member-name-link">tryReceive</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientSender.</span><code><a href="../../impl/ClientSender.html#trySend(org.apache.qpid.protonj2.client.Message)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../Tracker.html" title="interface in org.apache.qpid.protonj2.client">Tracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientSender.</span><code><a href="../../impl/ClientSender.html#trySend(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#trySend(org.apache.qpid.protonj2.client.Message)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message)</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code><a href="../../StreamTracker.html" title="interface in org.apache.qpid.protonj2.client">StreamTracker</a></code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientStreamSender.</span><code><a href="../../impl/ClientStreamSender.html#trySend(org.apache.qpid.protonj2.client.Message,java.util.Map)" class="member-name-link">trySend</a><wbr>(<a href="../../Message.html" title="interface in org.apache.qpid.protonj2.client">Message</a>&lt;?&gt;&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;deliveryAnnotations)</code></div>
<div class="col-last even-row-color">&nbsp;</div>
<div class="col-first odd-row-color"><code>byte[]</code></div>
<div class="col-second odd-row-color"><span class="type-name-label">ClientStreamReceiverMessage.</span><code><a href="../../impl/ClientStreamReceiverMessage.html#userId()" class="member-name-link">userId</a>()</code></div>
<div class="col-last odd-row-color">&nbsp;</div>
<div class="col-first even-row-color"><code>protected void</code></div>
<div class="col-second even-row-color"><span class="type-name-label">ClientLinkType.</span><code><a href="../../impl/ClientLinkType.html#waitForOpenToComplete()" class="member-name-link">waitForOpenToComplete</a>()</code></div>
<div class="col-last even-row-color">&nbsp;</div>
</div>
</section>
</li>
</ul>
</section>
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2024 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
