// Generated by Lisette bindgen
// Source: net/rpc (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.20

import "go:io"
import "go:net"
import "go:net/http"

/// Accept accepts connections on the listener and serves requests
/// to [DefaultServer] for each incoming connection.
/// Accept blocks; the caller typically invokes it in a go statement.
pub fn Accept(lis: net.Listener)

pub fn Dial(network: string, address: string) -> Result<Ref<Client>, error>

pub fn DialHTTP(network: string, address: string) -> Result<Ref<Client>, error>

pub fn DialHTTPPath(network: string, address: string, path: string) -> Result<Ref<Client>, error>

/// HandleHTTP registers an HTTP handler for RPC messages to [DefaultServer]
/// on [DefaultRPCPath] and a debugging handler on [DefaultDebugPath].
/// It is still necessary to invoke [http.Serve](), typically in a go statement.
pub fn HandleHTTP()

pub fn NewClient(conn: io.ReadWriteCloser) -> Ref<Client>

pub fn NewClientWithCodec(codec: ClientCodec) -> Ref<Client>

pub fn NewServer() -> Ref<Server>

/// Register publishes the receiver's methods in the [DefaultServer].
pub fn Register(rcvr: Unknown) -> Result<(), error>

/// RegisterName is like [Register] but uses the provided name for the type
/// instead of the receiver's concrete type.
pub fn RegisterName(name: string, rcvr: Unknown) -> Result<(), error>

/// ServeCodec is like [ServeConn] but uses the specified codec to
/// decode requests and encode responses.
pub fn ServeCodec(codec: ServerCodec)

/// ServeConn runs the [DefaultServer] on a single connection.
/// ServeConn blocks, serving the connection until the client hangs up.
/// The caller typically invokes ServeConn in a go statement.
/// ServeConn uses the gob wire format (see package gob) on the
/// connection. To use an alternate codec, use [ServeCodec].
/// See [NewClient]'s comment for information about concurrent access.
pub fn ServeConn(conn: io.ReadWriteCloser)

/// ServeRequest is like [ServeCodec] but synchronously serves a single request.
/// It does not close the codec upon completion.
pub fn ServeRequest(codec: ServerCodec) -> Result<(), error>

/// Call represents an active RPC.
pub struct Call {
  pub ServiceMethod: string,
  pub Args: Unknown,
  pub Reply: Unknown,
  pub Error: error,
  pub Done: Channel<Ref<Call>>,
}

/// Client represents an RPC Client.
/// There may be multiple outstanding Calls associated
/// with a single Client, and a Client may be used by
/// multiple goroutines simultaneously.
pub type Client

/// A ClientCodec implements writing of RPC requests and
/// reading of RPC responses for the client side of an RPC session.
/// The client calls [ClientCodec.WriteRequest] to write a request to the connection
/// and calls [ClientCodec.ReadResponseHeader] and [ClientCodec.ReadResponseBody] in pairs
/// to read responses. The client calls [ClientCodec.Close] when finished with the
/// connection. ReadResponseBody may be called with a nil
/// argument to force the body of the response to be read and then
/// discarded.
/// See [NewClient]'s comment for information about concurrent access.
pub interface ClientCodec {
  fn Close() -> Result<(), error>
  fn ReadResponseBody(arg0: Unknown) -> Result<(), error>
  fn ReadResponseHeader(arg0: Ref<Response>) -> Result<(), error>
  fn WriteRequest(arg0: Ref<Request>, arg1: Unknown) -> Result<(), error>
}

/// Request is a header written before every RPC call. It is used internally
/// but documented here as an aid to debugging, such as when analyzing
/// network traffic.
pub struct Request {
  pub ServiceMethod: string,
  pub Seq: uint64,
}

/// Response is a header written before every RPC return. It is used internally
/// but documented here as an aid to debugging, such as when analyzing
/// network traffic.
pub struct Response {
  pub ServiceMethod: string,
  pub Seq: uint64,
  pub Error: string,
}

/// Server represents an RPC Server.
pub type Server

/// A ServerCodec implements reading of RPC requests and writing of
/// RPC responses for the server side of an RPC session.
/// The server calls [ServerCodec.ReadRequestHeader] and [ServerCodec.ReadRequestBody] in pairs
/// to read requests from the connection, and it calls [ServerCodec.WriteResponse] to
/// write a response back. The server calls [ServerCodec.Close] when finished with the
/// connection. ReadRequestBody may be called with a nil
/// argument to force the body of the request to be read and discarded.
/// See [NewClient]'s comment for information about concurrent access.
pub interface ServerCodec {
  fn Close() -> Result<(), error>
  fn ReadRequestBody(arg0: Unknown) -> Result<(), error>
  fn ReadRequestHeader(arg0: Ref<Request>) -> Result<(), error>
  fn WriteResponse(arg0: Ref<Response>, arg1: Unknown) -> Result<(), error>
}

/// ServerError represents an error that has been returned from
/// the remote side of the RPC connection.
pub struct ServerError(string)

const DefaultDebugPath = "/debug/rpc"

const DefaultRPCPath = "/_goRPC_"

/// DefaultServer is the default instance of [*Server].
pub var DefaultServer: Ref<Server>

pub var ErrShutdown: error

impl Client {
  /// Call invokes the named function, waits for it to complete, and returns its error status.
  fn Call(
    self: Ref<Client>,
    serviceMethod: string,
    args: Unknown,
    reply: Unknown,
  ) -> Result<(), error>

  /// Close calls the underlying codec's Close method. If the connection is already
  /// shutting down, [ErrShutdown] is returned.
  #[allow(unused_result)]
  fn Close(self: Ref<Client>) -> Result<(), error>

  /// Go invokes the function asynchronously. It returns the [Call] structure representing
  /// the invocation. The done channel will signal when the call is complete by returning
  /// the same Call object. If done is nil, Go will allocate a new channel.
  /// If non-nil, done must be buffered or Go will deliberately crash.
  fn Go(
    self: Ref<Client>,
    serviceMethod: string,
    args: Unknown,
    reply: Unknown,
    done: Channel<Ref<Call>>,
  ) -> Ref<Call>
}

impl Server {
  /// Accept accepts connections on the listener and serves requests
  /// for each incoming connection. Accept blocks until the listener
  /// returns a non-nil error. The caller typically invokes Accept in a
  /// go statement.
  fn Accept(self: Ref<Server>, lis: net.Listener)

  /// HandleHTTP registers an HTTP handler for RPC messages on rpcPath,
  /// and a debugging handler on debugPath.
  /// It is still necessary to invoke [http.Serve](), typically in a go statement.
  fn HandleHTTP(self: Ref<Server>, rpcPath: string, debugPath: string)

  /// Register publishes in the server the set of methods of the
  /// receiver value that satisfy the following conditions:
  ///   - exported method of exported type
  ///   - two arguments, both of exported type
  ///   - the second argument is a pointer
  ///   - one return value, of type error
  /// 
  /// It returns an error if the receiver is not an exported type or has
  /// no suitable methods. It also logs the error using package log.
  /// The client accesses each method using a string of the form "Type.Method",
  /// where Type is the receiver's concrete type.
  fn Register(self: Ref<Server>, rcvr: Unknown) -> Result<(), error>

  /// RegisterName is like [Register] but uses the provided name for the type
  /// instead of the receiver's concrete type.
  fn RegisterName(self: Ref<Server>, name: string, rcvr: Unknown) -> Result<(), error>

  /// ServeCodec is like [ServeConn] but uses the specified codec to
  /// decode requests and encode responses.
  fn ServeCodec(self: Ref<Server>, codec: ServerCodec)

  /// ServeConn runs the server on a single connection.
  /// ServeConn blocks, serving the connection until the client hangs up.
  /// The caller typically invokes ServeConn in a go statement.
  /// ServeConn uses the gob wire format (see package gob) on the
  /// connection. To use an alternate codec, use [ServeCodec].
  /// See [NewClient]'s comment for information about concurrent access.
  fn ServeConn(self: Ref<Server>, conn: io.ReadWriteCloser)

  /// ServeHTTP implements an [http.Handler] that answers RPC requests.
  fn ServeHTTP(
    self: Ref<Server>,
    w: http.ResponseWriter,
    req: Ref<http.Request>,
  )

  /// ServeRequest is like [ServeCodec] but synchronously serves a single request.
  /// It does not close the codec upon completion.
  fn ServeRequest(self: Ref<Server>, codec: ServerCodec) -> Result<(), error>
}

impl ServerError {
  fn Error(self) -> string
}
