// 
// 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.buffer.ByteBuf;
import io.netty.util.concurrent.Promise;
import io.netty.util.concurrent.Future;
import io.netty.channel.ChannelHandler;
import org.jetbrains.annotations.Nullable;
import javax.net.ssl.SSLEngine;
import io.netty.channel.ChannelProgressivePromise;
import io.netty.channel.ChannelPromise;
import io.netty.channel.ChannelFuture;
import java.net.SocketAddress;
import io.netty.channel.Channel;

public interface QuicChannel extends Channel
{
    default ChannelFuture bind(final SocketAddress localAddress) {
        return this.pipeline().bind(localAddress);
    }
    
    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 promise) {
        return this.pipeline().bind(localAddress, promise);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress, final ChannelPromise promise) {
        return this.pipeline().connect(remoteAddress, promise);
    }
    
    default ChannelFuture connect(final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
        return this.pipeline().connect(remoteAddress, localAddress, promise);
    }
    
    default ChannelFuture disconnect(final ChannelPromise promise) {
        return this.pipeline().disconnect(promise);
    }
    
    default ChannelFuture close(final ChannelPromise promise) {
        return this.pipeline().close(promise);
    }
    
    default ChannelFuture deregister(final ChannelPromise promise) {
        return this.pipeline().deregister(promise);
    }
    
    default ChannelFuture write(final Object msg) {
        return this.pipeline().write(msg);
    }
    
    default ChannelFuture write(final Object msg, final ChannelPromise promise) {
        return this.pipeline().write(msg, promise);
    }
    
    default ChannelFuture writeAndFlush(final Object msg, final ChannelPromise promise) {
        return this.pipeline().writeAndFlush(msg, promise);
    }
    
    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();
    }
    
    QuicChannel read();
    
    QuicChannel flush();
    
    QuicChannelConfig config();
    
    @Nullable
    SSLEngine sslEngine();
    
    long peerAllowedStreams(final QuicStreamType p0);
    
    boolean isTimedOut();
    
    @Nullable
    QuicTransportParameters peerTransportParameters();
    
    @Nullable
    QuicConnectionAddress localAddress();
    
    @Nullable
    QuicConnectionAddress remoteAddress();
    
    @Nullable
    SocketAddress localSocketAddress();
    
    @Nullable
    SocketAddress remoteSocketAddress();
    
    default Future<QuicStreamChannel> createStream(final QuicStreamType type, @Nullable final ChannelHandler handler) {
        return this.createStream(type, handler, this.eventLoop().newPromise());
    }
    
    Future<QuicStreamChannel> createStream(final QuicStreamType p0, @Nullable final ChannelHandler p1, final Promise<QuicStreamChannel> p2);
    
    default QuicStreamChannelBootstrap newStreamBootstrap() {
        return new QuicStreamChannelBootstrap(this);
    }
    
    default ChannelFuture close(final boolean applicationClose, final int error, final ByteBuf reason) {
        return this.close(applicationClose, error, reason, this.newPromise());
    }
    
    ChannelFuture close(final boolean p0, final int p1, final ByteBuf p2, final ChannelPromise p3);
    
    default Future<QuicConnectionStats> collectStats() {
        return this.collectStats(this.eventLoop().newPromise());
    }
    
    Future<QuicConnectionStats> collectStats(final Promise<QuicConnectionStats> p0);
    
    default Future<QuicConnectionPathStats> collectPathStats(final int pathIdx) {
        return this.collectPathStats(pathIdx, this.eventLoop().newPromise());
    }
    
    Future<QuicConnectionPathStats> collectPathStats(final int p0, final Promise<QuicConnectionPathStats> p1);
    
    default QuicChannelBootstrap newBootstrap(final Channel channel) {
        return new QuicChannelBootstrap(channel);
    }
}