public class JChannel implements Closeable {

    // Initialization accepts configuration options
    public JChannel ();
    public JChannel (String url);
    public JChannel (InputStream stream);

    // Join a group with a given name
    public void connect (String cluster);
    public String clusterName ();
    public void disconnect ();

    // View is the current list of members
    public View getView ();

    // Send a message to all or one group member.
    public void send (Message msg);
    public void send (Address dst, Object obj);
    public void send (Address dst, byte [] buf);
    public void send (Address dst, byte [] buf, int offset, int length);

    // Asynchronous notification about messages and membership is available
    public void setReceiver (Receiver r);
    public Receiver getReceiver ();

    ...
}

public interface Receiver {

    // Receive individual messages or batches of messages
    default void receive (Message msg) { ... }
    default void receive (MessageBatch batch) { ... }

    // Notification about membership view change
    default void viewAccepted (View new_view) { ... }

    // Notification to temporarily suspend sending messages
    default void block () { ... }
    default void unblock () { ... }

    // Group members can share state
    default void getState (OutputStream output) { ... }
    default void setState (InputStream input) { ... }
}

public interface Message ... {

    short BYTES_MSG   = 0,
        NIO_MSG       = 1,
        EMPTY_MSG     = 2,
        OBJ_MSG       = 3,
        LONG_MSG      = 4,
        COMPOSITE_MSG = 5,
        FRAG_MSG      = 6;

    short getType ();

    Address getDest ();
    Message setDest (Address new_dest);
    Address getSrc ();
    Message setSrc (Address new_src);

    // Headers are internal and interpreted by individual protocol modules
    Message putHeader (short id, Header hdr);
    <T extends Header> T getHeader (short id);
    Map<Short,Header> getHeaders ();

    // Flags are interpreted by individual protocol modules
    // Examples include disabling flow control or reliability
    short getFlags (boolean transient_flags);
    Message setFlag (short flag, boolean transient_flags);

    // Convenience methods on the interface
    // May not make sense for all message classes

    byte [] getArray ();
    int getOffset ();
    int getLength ();
    public Message setBuffer (byte [] b);
    Message setArray (byte [] b, int offset, int length);

    <T extends Object> T getObject ();
    Message setObject (Object obj);

    <T extends Object> T getPayload ();
    Message setPayload (Object pl);

    ...
}

public class BytesMessage ... {
    public BytesMessage (Address dest, byte [] array) { ... }
    public BytesMessage (Address dest, byte [] array, int offset, int length) { ... }
    ...
}

public class NioMessage ... {
    // Uses java.nio.ByteBuffer that can reduce copying overhead
    public NioMessage (Address dest, ByteBuffer buf) { ... }
    public ByteBuffer getBuf () { ... }
    public NioMessage setBuf (ByteBuffer b) { ... }
    ...
}

public class ObjectMessage ... {
    public ObjectMessage(Address dest, Object obj) {
    ...
}

public class CompositeMessage ... implements Iterable<Message> {
    public CompositeMessage (Address dest, Message ... messages) { ... }
    public CompositeMessage add (Message msg) { ... }
    public <T extends Message> T get (int index) { ... }
    public Iterator<Message> iterator () { ... }
    ...
}

public class MessageDispatcher implements ... {

    // Message dispatcher needs channel for communication and request handler for message delivery.
    public MessageDispatcher (JChannel channel) { ... }
    public MessageDispatcher (JChannel channel, RequestHandler req_handler) { ... }

    // Casting sends to multiple destinations or all members when none specified.
    public <T> RspList<T> castMessage (final Collection<Address> dests, Message msg, RequestOptions opts) { ... }
    public <T> CompletableFuture<RspList<T>> castMessageWithFuture (final Collection<Address> dests, Message msg, RequestOptions opts) { ... }

    // Sending sends to single destination.
    public <T> T sendMessage (Message msg, RequestOptions opts) { ... }
    public <T> CompletableFuture<T> sendMessageWithFuture (Message msg, RequestOptions opts) { ... }

    // Request handler interface if none provided externally.
    @Override public Object handle (Message msg) { ... }
    @Override public void handle (Message request, Response response) { ... }

    ...
}

public class RequestOptions {

    // Can wait for none, one or all responses.
    public ResponseMode getMode () { ... }
    public RequestOptions setMode (ResponseMode mode) { ... }

    // Can specify response filter if response expected.
    public RspFilter getRspFilter () { ... }
    public RequestOptions setRspFilter (RspFilter filter) { ... }

    // Can specify response timeout if response expected.
    public long getTimeout () { ... }
    public RequestOptions setTimeout (long timeout) { ... }

    ...
}

public class RspList<T> extends HashMap<Address,Rsp<T>> implements Iterable<Rsp<T>> {

    public int numReceived () { ... }
    public boolean isReceived (Address sender) { ... }

    // Standard get inherited.
    public T getFirst () { ... }
    public List<T> getResults () { ... }

    // Response is not expected from failed members.
    public int numSuspectedMembers () { ... }
    public List<Address> getSuspectedMembers () { ... }
    public boolean isSuspected (Address sender) { ... }

    ...
}

public class CounterService {

    // Channel stack must include COUNTER protocol.
    public CounterService (JChannel ch) { ... }
    public SyncCounter getOrCreateSyncCounter (String name, long initial_value) { ... }
    public CompletionStage<AsyncCounter> getOrCreateAsyncCounter (String name, long initial_value) { ... }
    public void deleteCounter (String name) { ... }
    ...
}

public interface SyncCounter extends BaseCounter {

    long get ();
    void set (long new_value);

    long addAndGet (long delta);
    long incrementAndGet ();
    long decrementAndGet ();

    long compareAndSwap (long expect, long update);
    boolean compareAndSet (long expect, long update);

    // Useful for complex updates under high contention.
    <T extends Streamable> T update (CounterFunction<T> updateFunction);
}

public interface AsyncCounter extends BaseCounter {

    CompletionStage<Long> get ();
    CompletionStage<Void> set (long new_value);

    ...
}