var ForwarderDesc rpc.InterfaceDesc = descForwarder

var TunnelDesc rpc.InterfaceDesc = descTunnel

type ClientShellPacket interface {
    // Index returns the field index.
    Index() int
    // Interface returns the field value as an interface.
    Interface() interface{}
    // Name returns the field name.
    Name() string
    // VDLReflect describes the ClientShellPacket union type.
    VDLReflect(vdlClientShellPacketReflect)
    VDLIsZero() bool
    VDLWrite(vdl.Encoder) error
}

type ClientShellPacketEndOfFile struct{ Value Unused }

type ClientShellPacketStdin struct{ Value []byte }

type ClientShellPacketWinSize struct{ Value WindowSize }

type ForwarderClientMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to a predetermined network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(*context.T, ...rpc.CallOpt) (ForwarderForwardClientCall, error)
}

type ForwarderClientStub interface {
    ForwarderClientMethods
}

type ForwarderForwardClientCall interface {
    ForwarderForwardClientStream
    // Finish performs the equivalent of SendStream().Close, then blocks until
    // the server is done, and returns the positional return values for the call.
    //
    // Finish returns immediately if the call has been canceled; depending on the
    // timing the output could either be an error signaling cancelation, or the
    // valid positional return values from the server.
    //
    // Calling Finish is mandatory for releasing stream resources, unless the call
    // has been canceled or any of the other methods return an error.  Finish should
    // be called at most once.
    Finish() error
}

type ForwarderForwardClientStream interface {
    // RecvStream returns the receiver side of the Forwarder.Forward client stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() []byte
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Forwarder.Forward client stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors
        // encountered while sending, or if Send is called after Close or
        // the stream has been canceled.  Blocks if there is no buffer
        // space; will unblock when buffer space is available or after
        // the stream has been canceled.
        Send(item []byte) error
        // Close indicates to the server that no more items will be sent;
        // server Recv calls will receive io.EOF after all sent items.
        // This is an optional call - e.g. a client might call Close if it
        // needs to continue receiving items from the server after it's
        // done sending.  Returns errors encountered while closing, or if
        // Close is called after the stream has been canceled.  Like Send,
        // blocks if there is no buffer space available.
        Close() error
    }
}

type ForwarderForwardServerCall interface {
    rpc.ServerCall
    ForwarderForwardServerStream
}

type ForwarderForwardServerCallStub struct {
    rpc.StreamServerCall
    // contains filtered or unexported fields
}

type ForwarderForwardServerStream interface {
    // RecvStream returns the receiver side of the Forwarder.Forward server stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() []byte
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Forwarder.Forward server stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors encountered
        // while sending.  Blocks if there is no buffer space; will unblock when
        // buffer space is available.
        Send(item []byte) error
    }
}

type ForwarderServerMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to a predetermined network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(*context.T, ForwarderForwardServerCall) error
}

type ForwarderServerStub interface {
    ForwarderServerStubMethods
    // DescribeInterfaces the Forwarder interfaces.
    Describe__() []rpc.InterfaceDesc
}

type ForwarderServerStubMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to a predetermined network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(*context.T, *ForwarderForwardServerCallStub) error
}

type ServerShellPacket interface {
    // Index returns the field index.
    Index() int
    // Interface returns the field value as an interface.
    Interface() interface{}
    // Name returns the field name.
    Name() string
    // VDLReflect describes the ServerShellPacket union type.
    VDLReflect(vdlServerShellPacketReflect)
    VDLIsZero() bool
    VDLWrite(vdl.Encoder) error
}

type ServerShellPacketStderr struct{ Value []byte }

type ServerShellPacketStdout struct{ Value []byte }

type ShellOpts struct {
    UsePty      bool       // Whether to open a pseudo-terminal.
    Environment []string   // Environment variables to pass to the remote shell.
    WinSize     WindowSize // The size of the window.
}

type TunnelClientMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to the requested network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(_ *context.T, network string, address string, _ ...rpc.CallOpt) (TunnelForwardClientCall, error)
    // The ReverseForward method is used for network forwarding from the server
    // back to the client. The server process listens on the requested network
    // address, forwarding all connections by calling Forwarder.Forward on the
    // caller.
    ReverseForward(_ *context.T, network string, address string, _ ...rpc.CallOpt) error
    // The Shell method is used to either run shell commands remotely, or to open
    // an interactive shell. The data received over the byte stream is sent to the
    // shell's stdin, and the data received from the shell's stdout and stderr is
    // sent back in the reply stream. It returns the exit status of the shell
    // command as an integer exit code and a human readable string.
    Shell(_ *context.T, command string, shellOpts ShellOpts, _ ...rpc.CallOpt) (TunnelShellClientCall, error)
}

type TunnelClientStub interface {
    TunnelClientMethods
}

type TunnelForwardClientCall interface {
    TunnelForwardClientStream
    // Finish performs the equivalent of SendStream().Close, then blocks until
    // the server is done, and returns the positional return values for the call.
    //
    // Finish returns immediately if the call has been canceled; depending on the
    // timing the output could either be an error signaling cancelation, or the
    // valid positional return values from the server.
    //
    // Calling Finish is mandatory for releasing stream resources, unless the call
    // has been canceled or any of the other methods return an error.  Finish should
    // be called at most once.
    Finish() error
}

type TunnelForwardClientStream interface {
    // RecvStream returns the receiver side of the Tunnel.Forward client stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() []byte
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Tunnel.Forward client stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors
        // encountered while sending, or if Send is called after Close or
        // the stream has been canceled.  Blocks if there is no buffer
        // space; will unblock when buffer space is available or after
        // the stream has been canceled.
        Send(item []byte) error
        // Close indicates to the server that no more items will be sent;
        // server Recv calls will receive io.EOF after all sent items.
        // This is an optional call - e.g. a client might call Close if it
        // needs to continue receiving items from the server after it's
        // done sending.  Returns errors encountered while closing, or if
        // Close is called after the stream has been canceled.  Like Send,
        // blocks if there is no buffer space available.
        Close() error
    }
}

type TunnelForwardServerCall interface {
    rpc.ServerCall
    TunnelForwardServerStream
}

type TunnelForwardServerCallStub struct {
    rpc.StreamServerCall
    // contains filtered or unexported fields
}

type TunnelForwardServerStream interface {
    // RecvStream returns the receiver side of the Tunnel.Forward server stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() []byte
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Tunnel.Forward server stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors encountered
        // while sending.  Blocks if there is no buffer space; will unblock when
        // buffer space is available.
        Send(item []byte) error
    }
}

type TunnelServerMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to the requested network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(_ *context.T, _ TunnelForwardServerCall, network string, address string) error
    // The ReverseForward method is used for network forwarding from the server
    // back to the client. The server process listens on the requested network
    // address, forwarding all connections by calling Forwarder.Forward on the
    // caller.
    ReverseForward(_ *context.T, _ rpc.ServerCall, network string, address string) error
    // The Shell method is used to either run shell commands remotely, or to open
    // an interactive shell. The data received over the byte stream is sent to the
    // shell's stdin, and the data received from the shell's stdout and stderr is
    // sent back in the reply stream. It returns the exit status of the shell
    // command as an integer exit code and a human readable string.
    Shell(_ *context.T, _ TunnelShellServerCall, command string, shellOpts ShellOpts) (exitCode int32, exitMsg string, _ error)
}

type TunnelServerStub interface {
    TunnelServerStubMethods
    // DescribeInterfaces the Tunnel interfaces.
    Describe__() []rpc.InterfaceDesc
}

type TunnelServerStubMethods interface {
    // The Forward method is used for network forwarding. All the data sent over
    // the byte stream is forwarded to the requested network address and all the
    // data received from that network connection is sent back on the reply
    // stream.
    Forward(_ *context.T, _ *TunnelForwardServerCallStub, network string, address string) error
    // The ReverseForward method is used for network forwarding from the server
    // back to the client. The server process listens on the requested network
    // address, forwarding all connections by calling Forwarder.Forward on the
    // caller.
    ReverseForward(_ *context.T, _ rpc.ServerCall, network string, address string) error
    // The Shell method is used to either run shell commands remotely, or to open
    // an interactive shell. The data received over the byte stream is sent to the
    // shell's stdin, and the data received from the shell's stdout and stderr is
    // sent back in the reply stream. It returns the exit status of the shell
    // command as an integer exit code and a human readable string.
    Shell(_ *context.T, _ *TunnelShellServerCallStub, command string, shellOpts ShellOpts) (exitCode int32, exitMsg string, _ error)
}

type TunnelShellClientCall interface {
    TunnelShellClientStream
    // Finish performs the equivalent of SendStream().Close, then blocks until
    // the server is done, and returns the positional return values for the call.
    //
    // Finish returns immediately if the call has been canceled; depending on the
    // timing the output could either be an error signaling cancelation, or the
    // valid positional return values from the server.
    //
    // Calling Finish is mandatory for releasing stream resources, unless the call
    // has been canceled or any of the other methods return an error.  Finish should
    // be called at most once.
    Finish() (exitCode int32, exitMsg string, _ error)
}

type TunnelShellClientStream interface {
    // RecvStream returns the receiver side of the Tunnel.Shell client stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() ServerShellPacket
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Tunnel.Shell client stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors
        // encountered while sending, or if Send is called after Close or
        // the stream has been canceled.  Blocks if there is no buffer
        // space; will unblock when buffer space is available or after
        // the stream has been canceled.
        Send(item ClientShellPacket) error
        // Close indicates to the server that no more items will be sent;
        // server Recv calls will receive io.EOF after all sent items.
        // This is an optional call - e.g. a client might call Close if it
        // needs to continue receiving items from the server after it's
        // done sending.  Returns errors encountered while closing, or if
        // Close is called after the stream has been canceled.  Like Send,
        // blocks if there is no buffer space available.
        Close() error
    }
}

type TunnelShellServerCall interface {
    rpc.ServerCall
    TunnelShellServerStream
}

type TunnelShellServerCallStub struct {
    rpc.StreamServerCall
    // contains filtered or unexported fields
}

type TunnelShellServerStream interface {
    // RecvStream returns the receiver side of the Tunnel.Shell server stream.
    RecvStream() interface {
        // Advance stages an item so that it may be retrieved via Value.  Returns
        // true iff there is an item to retrieve.  Advance must be called before
        // Value is called.  May block if an item is not available.
        Advance() bool
        // Value returns the item that was staged by Advance.  May panic if Advance
        // returned false or was not called.  Never blocks.
        Value() ClientShellPacket
        // Err returns any error encountered by Advance.  Never blocks.
        Err() error
    }
    // SendStream returns the send side of the Tunnel.Shell server stream.
    SendStream() interface {
        // Send places the item onto the output stream.  Returns errors encountered
        // while sending.  Blocks if there is no buffer space; will unblock when
        // buffer space is available.
        Send(item ServerShellPacket) error
    }
}

type Unused struct {
}

type WindowSize struct {
    Rows uint16
    Cols uint16
}