// 
// Decompiled by Procyon v0.6.0
// 

package io.netty.handler.codec.quic;

import io.netty.channel.ChannelOutboundInvoker;
import io.netty.channel.ChannelConfig;
import io.netty.channel.Channel;
import org.jetbrains.annotations.Nullable;
import io.netty.channel.ChannelProgressivePromise;
import io.netty.channel.ChannelPromise;
import io.netty.channel.ChannelFuture;
import java.net.SocketAddress;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.socket.DuplexChannel;

public interface QuicStreamChannel extends DuplexChannel
{
    public static final ChannelFutureListener SHUTDOWN_OUTPUT = f -> ((QuicStreamChannel)f.channel()).shutdownOutput();
    
    default ChannelFuture bind(final SocketAddress socketAddress) {
        return this.pipeline().bind(socketAddress);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress) {
        return this.pipeline().connect(remoteAddress);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
        return this.pipeline().connect(remoteAddress, localAddress);
    }
    
    default ChannelFuture disconnect() {
        return this.pipeline().disconnect();
    }
    
    default ChannelFuture close() {
        return this.pipeline().close();
    }
    
    default ChannelFuture deregister() {
        return this.pipeline().deregister();
    }
    
    default ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise channelPromise) {
        return this.pipeline().bind(localAddress, channelPromise);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress, final ChannelPromise channelPromise) {
        return this.pipeline().connect(remoteAddress, channelPromise);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise channelPromise) {
        return this.pipeline().connect(remoteAddress, localAddress, channelPromise);
    }
    
    default ChannelFuture disconnect(final ChannelPromise channelPromise) {
        return this.pipeline().disconnect(channelPromise);
    }
    
    default ChannelFuture close(final ChannelPromise channelPromise) {
        return this.pipeline().close(channelPromise);
    }
    
    default ChannelFuture deregister(final ChannelPromise channelPromise) {
        return this.pipeline().deregister(channelPromise);
    }
    
    default ChannelFuture write(final Object msg) {
        return this.pipeline().write(msg);
    }
    
    default ChannelFuture write(final Object msg, final ChannelPromise channelPromise) {
        return this.pipeline().write(msg, channelPromise);
    }
    
    default ChannelFuture writeAndFlush(final Object msg, final ChannelPromise channelPromise) {
        return this.pipeline().writeAndFlush(msg, channelPromise);
    }
    
    default ChannelFuture writeAndFlush(final Object msg) {
        return this.pipeline().writeAndFlush(msg);
    }
    
    default ChannelPromise newPromise() {
        return this.pipeline().newPromise();
    }
    
    default ChannelProgressivePromise newProgressivePromise() {
        return this.pipeline().newProgressivePromise();
    }
    
    default ChannelFuture newSucceededFuture() {
        return this.pipeline().newSucceededFuture();
    }
    
    default ChannelFuture newFailedFuture(final Throwable cause) {
        return this.pipeline().newFailedFuture(cause);
    }
    
    default ChannelPromise voidPromise() {
        return this.pipeline().voidPromise();
    }
    
    default ChannelFuture shutdownInput() {
        return this.shutdownInput(this.newPromise());
    }
    
    default ChannelFuture shutdownInput(final ChannelPromise promise) {
        return this.shutdownInput(0, promise);
    }
    
    default ChannelFuture shutdownOutput() {
        return this.shutdownOutput(this.newPromise());
    }
    
    default ChannelFuture shutdown() {
        return this.shutdown(this.newPromise());
    }
    
    default ChannelFuture shutdown(final int error) {
        return this.shutdown(error, this.newPromise());
    }
    
    ChannelFuture shutdown(final int p0, final ChannelPromise p1);
    
    default ChannelFuture shutdownInput(final int error) {
        return this.shutdownInput(error, this.newPromise());
    }
    
    ChannelFuture shutdownInput(final int p0, final ChannelPromise p1);
    
    default ChannelFuture shutdownOutput(final int error) {
        return this.shutdownOutput(error, this.newPromise());
    }
    
    ChannelFuture shutdownOutput(final int p0, final ChannelPromise p1);
    
    QuicStreamAddress localAddress();
    
    QuicStreamAddress remoteAddress();
    
    boolean isLocalCreated();
    
    QuicStreamType type();
    
    long streamId();
    
    @Nullable
    QuicStreamPriority priority();
    
    default ChannelFuture updatePriority(final QuicStreamPriority priority) {
        return this.updatePriority(priority, this.newPromise());
    }
    
    ChannelFuture updatePriority(final QuicStreamPriority p0, final ChannelPromise p1);
    
    QuicChannel parent();
    
    QuicStreamChannel read();
    
    QuicStreamChannel flush();
    
    QuicStreamChannelConfig config();
}