// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/class.Session.html).
pub type Session

///|
pub(open) trait ISession {
  fn as_session(Self) -> Session
  fn abort(Self) -> Unit = _
  fn add_feature(Self, &ISessionFeature) -> Unit = _
  fn get_accept_language(Self) -> String? = _
  fn get_accept_language_auto(Self) -> Bool = _
  fn get_async_result_message(Self, &@gio.IAsyncResult) -> Message? = _
  fn get_idle_timeout(Self) -> UInt = _
  fn get_local_address(Self) -> @gio.InetSocketAddress? = _
  fn get_max_conns(Self) -> UInt = _
  fn get_max_conns_per_host(Self) -> UInt = _
  fn get_proxy_resolver(Self) -> @gio.ProxyResolver? = _
  fn get_remote_connectable(Self) -> @gio.SocketConnectable? = _
  fn get_timeout(Self) -> UInt = _
  fn get_tls_database(Self) -> @gio.TlsDatabase? = _
  fn get_tls_interaction(Self) -> @gio.TlsInteraction? = _
  fn get_user_agent(Self) -> String? = _
  fn remove_feature(Self, &ISessionFeature) -> Unit = _
  fn send(Self, &IMessage, &@gio.ICancellable?) -> @gio.InputStream raise @glib.Error_ = _
  fn send_and_read(Self, &IMessage, &@gio.ICancellable?) -> Bytes raise @glib.Error_ = _
  fn send_and_splice(
    Self,
    &IMessage,
    &@gio.IOutputStream,
    @gio.OutputStreamSpliceFlags,
    &@gio.ICancellable?,
  ) -> Int64 raise @glib.Error_ = _
  fn set_accept_language(Self, String) -> Unit = _
  fn set_accept_language_auto(Self, Bool) -> Unit = _
  fn set_idle_timeout(Self, UInt) -> Unit = _
  fn set_proxy_resolver(Self, &@gio.IProxyResolver?) -> Unit = _
  fn set_timeout(Self, UInt) -> Unit = _
  fn set_tls_database(Self, &@gio.ITlsDatabase?) -> Unit = _
  fn set_tls_interaction(Self, &@gio.ITlsInteraction?) -> Unit = _
  fn set_user_agent(Self, String) -> Unit = _
  fn connect_request_queued(Self, (Session, Message) -> Unit) -> UInt64 = _
  fn connect_request_unqueued(Self, (Session, Message) -> Unit) -> UInt64 = _
  fn preconnect_async(
    Self,
    &IMessage,
    Int,
    &@gio.ICancellable?,
    (Result[Bool, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn send_and_read_async(
    Self,
    &IMessage,
    Int,
    &@gio.ICancellable?,
    (Result[Bytes, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn send_and_splice_async(
    Self,
    &IMessage,
    &@gio.IOutputStream,
    @gio.OutputStreamSpliceFlags,
    Int,
    &@gio.ICancellable?,
    (Result[Int64, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn send_async(
    Self,
    &IMessage,
    Int,
    &@gio.ICancellable?,
    (Result[@gio.InputStream, @glib.Error_]) -> Unit,
  ) -> Unit = _
  fn websocket_connect_async(
    Self,
    &IMessage,
    String?,
    Array[String]?,
    Int,
    &@gio.ICancellable?,
    (Result[WebsocketConnection, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl ISession for Session with fn as_session(self) {
  self
}

///|
/// Implementation contract for Session.request_queued. Self is the retained MoonBit state; the second parameter is the invoked Session object.
pub(open) trait VSessionRequestQueued {
  fn request_queued(Self, Session, &IMessage) -> Unit
}

///|
/// Implementation contract for Session.request_unqueued. Self is the retained MoonBit state; the second parameter is the invoked Session object.
pub(open) trait VSessionRequestUnqueued {
  fn request_unqueued(Self, Session, &IMessage) -> Unit
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/ctor.Session.new.html).
pub extern "c" fn Session::new() -> Session = "moonbit_soup_session_new"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.abort.html).
#borrow(self)
pub extern "c" fn Session::abort(self : Session) = "moonbit_soup_session_abort"

///|
#borrow(self_, feature)
extern "c" fn moonbit_soup_session_add_feature(
  self_ : Session,
  feature : SessionFeature,
) = "moonbit_soup_session_add_feature"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.add_feature.html).
pub fn Session::add_feature(self : Session, feature : &ISessionFeature) -> Unit {
  moonbit_soup_session_add_feature(self, feature.as_session_feature())
}

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_accept_language(
  self_ : Session,
) -> @glib.Nullable[Bytes] = "moonbit_soup_session_get_accept_language"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_accept_language.html).
pub fn Session::get_accept_language(self : Session) -> String? {
  let result = moonbit_soup_session_get_accept_language(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_accept_language_auto.html).
#borrow(self)
pub extern "c" fn Session::get_accept_language_auto(self : Session) -> Bool = "moonbit_soup_session_get_accept_language_auto"

///|
#borrow(self_, result)
extern "c" fn moonbit_soup_session_get_async_result_message(
  self_ : Session,
  result : @gio.AsyncResult,
) -> @glib.Nullable[Message] = "moonbit_soup_session_get_async_result_message"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_async_result_message.html).
pub fn Session::get_async_result_message(
  self : Session,
  result : &@gio.IAsyncResult,
) -> Message? {
  let raw_result = moonbit_soup_session_get_async_result_message(
    self,
    result.as_async_result(),
  )
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_idle_timeout.html).
#borrow(self)
pub extern "c" fn Session::get_idle_timeout(self : Session) -> UInt = "moonbit_soup_session_get_idle_timeout"

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_local_address(
  self_ : Session,
) -> @glib.Nullable[@gio.InetSocketAddress] = "moonbit_soup_session_get_local_address"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_local_address.html).
pub fn Session::get_local_address(self : Session) -> @gio.InetSocketAddress? {
  let raw_result = moonbit_soup_session_get_local_address(self)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_max_conns.html).
#borrow(self)
pub extern "c" fn Session::get_max_conns(self : Session) -> UInt = "moonbit_soup_session_get_max_conns"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_max_conns_per_host.html).
#borrow(self)
pub extern "c" fn Session::get_max_conns_per_host(self : Session) -> UInt = "moonbit_soup_session_get_max_conns_per_host"

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_proxy_resolver(
  self_ : Session,
) -> @glib.Nullable[@gio.ProxyResolver] = "moonbit_soup_session_get_proxy_resolver"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_proxy_resolver.html).
pub fn Session::get_proxy_resolver(self : Session) -> @gio.ProxyResolver? {
  let raw_result = moonbit_soup_session_get_proxy_resolver(self)
  raw_result.to_option()
}

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_remote_connectable(
  self_ : Session,
) -> @glib.Nullable[@gio.SocketConnectable] = "moonbit_soup_session_get_remote_connectable"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_remote_connectable.html).
pub fn Session::get_remote_connectable(
  self : Session,
) -> @gio.SocketConnectable? {
  let raw_result = moonbit_soup_session_get_remote_connectable(self)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_timeout.html).
#borrow(self)
pub extern "c" fn Session::get_timeout(self : Session) -> UInt = "moonbit_soup_session_get_timeout"

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_tls_database(
  self_ : Session,
) -> @glib.Nullable[@gio.TlsDatabase] = "moonbit_soup_session_get_tls_database"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_tls_database.html).
pub fn Session::get_tls_database(self : Session) -> @gio.TlsDatabase? {
  let raw_result = moonbit_soup_session_get_tls_database(self)
  raw_result.to_option()
}

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_tls_interaction(
  self_ : Session,
) -> @glib.Nullable[@gio.TlsInteraction] = "moonbit_soup_session_get_tls_interaction"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_tls_interaction.html).
pub fn Session::get_tls_interaction(self : Session) -> @gio.TlsInteraction? {
  let raw_result = moonbit_soup_session_get_tls_interaction(self)
  raw_result.to_option()
}

///|
#borrow(self_)
extern "c" fn moonbit_soup_session_get_user_agent(
  self_ : Session,
) -> @glib.Nullable[Bytes] = "moonbit_soup_session_get_user_agent"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.get_user_agent.html).
pub fn Session::get_user_agent(self : Session) -> String? {
  let result = moonbit_soup_session_get_user_agent(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
#borrow(self_, feature)
extern "c" fn moonbit_soup_session_remove_feature(
  self_ : Session,
  feature : SessionFeature,
) = "moonbit_soup_session_remove_feature"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.remove_feature.html).
pub fn Session::remove_feature(
  self : Session,
  feature : &ISessionFeature,
) -> Unit {
  moonbit_soup_session_remove_feature(self, feature.as_session_feature())
}

///|
#borrow(self_, msg, cancellable, error)
extern "c" fn moonbit_soup_session_send(
  self_ : Session,
  msg : Message,
  cancellable : @glib.Nullable[@gio.Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> @gio.InputStream = "moonbit_soup_session_send"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send.html).
pub fn Session::send(
  self : Session,
  msg : &IMessage,
  cancellable : &@gio.ICancellable?,
) -> @gio.InputStream raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_soup_session_send(
    self,
    msg.as_message(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, msg, cancellable, error)
extern "c" fn moonbit_soup_session_send_and_read(
  self_ : Session,
  msg : Message,
  cancellable : @glib.Nullable[@gio.Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bytes = "moonbit_soup_session_send_and_read"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send_and_read.html).
pub fn Session::send_and_read(
  self : Session,
  msg : &IMessage,
  cancellable : &@gio.ICancellable?,
) -> Bytes raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_soup_session_send_and_read(
    self,
    msg.as_message(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, msg, out_stream, cancellable, error)
extern "c" fn moonbit_soup_session_send_and_splice(
  self_ : Session,
  msg : Message,
  out_stream : @gio.OutputStream,
  flags : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Int64 = "moonbit_soup_session_send_and_splice"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send_and_splice.html).
pub fn Session::send_and_splice(
  self : Session,
  msg : &IMessage,
  out_stream : &@gio.IOutputStream,
  flags : @gio.OutputStreamSpliceFlags,
  cancellable : &@gio.ICancellable?,
) -> Int64 raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_soup_session_send_and_splice(
    self,
    msg.as_message(),
    out_stream.as_output_stream(),
    flags.to_int(),
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  result
}

///|
#borrow(self_, accept_language)
extern "c" fn moonbit_soup_session_set_accept_language(
  self_ : Session,
  accept_language : Bytes,
) = "moonbit_soup_session_set_accept_language"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_accept_language.html).
pub fn Session::set_accept_language(
  self : Session,
  accept_language : String,
) -> Unit {
  moonbit_soup_session_set_accept_language(
    self,
    @encoding/utf8.encode(accept_language),
  )
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_accept_language_auto.html).
#borrow(self)
pub extern "c" fn Session::set_accept_language_auto(
  self : Session,
  accept_language_auto : Bool,
) = "moonbit_soup_session_set_accept_language_auto"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_idle_timeout.html).
#borrow(self)
pub extern "c" fn Session::set_idle_timeout(self : Session, timeout : UInt) = "moonbit_soup_session_set_idle_timeout"

///|
#borrow(self_, proxy_resolver)
extern "c" fn moonbit_soup_session_set_proxy_resolver(
  self_ : Session,
  proxy_resolver : @glib.Nullable[@gio.ProxyResolver],
) = "moonbit_soup_session_set_proxy_resolver"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_proxy_resolver.html).
pub fn Session::set_proxy_resolver(
  self : Session,
  proxy_resolver : &@gio.IProxyResolver?,
) -> Unit {
  moonbit_soup_session_set_proxy_resolver(
    self,
    match proxy_resolver {
      Some(v) => @glib.Nullable::some(v.as_proxy_resolver())
      None => @glib.Nullable::null()
    },
  )
}

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_timeout.html).
#borrow(self)
pub extern "c" fn Session::set_timeout(self : Session, timeout : UInt) = "moonbit_soup_session_set_timeout"

///|
#borrow(self_, tls_database)
extern "c" fn moonbit_soup_session_set_tls_database(
  self_ : Session,
  tls_database : @glib.Nullable[@gio.TlsDatabase],
) = "moonbit_soup_session_set_tls_database"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_tls_database.html).
pub fn Session::set_tls_database(
  self : Session,
  tls_database : &@gio.ITlsDatabase?,
) -> Unit {
  moonbit_soup_session_set_tls_database(
    self,
    match tls_database {
      Some(v) => @glib.Nullable::some(v.as_tls_database())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, tls_interaction)
extern "c" fn moonbit_soup_session_set_tls_interaction(
  self_ : Session,
  tls_interaction : @glib.Nullable[@gio.TlsInteraction],
) = "moonbit_soup_session_set_tls_interaction"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_tls_interaction.html).
pub fn Session::set_tls_interaction(
  self : Session,
  tls_interaction : &@gio.ITlsInteraction?,
) -> Unit {
  moonbit_soup_session_set_tls_interaction(
    self,
    match tls_interaction {
      Some(v) => @glib.Nullable::some(v.as_tls_interaction())
      None => @glib.Nullable::null()
    },
  )
}

///|
#borrow(self_, user_agent)
extern "c" fn moonbit_soup_session_set_user_agent(
  self_ : Session,
  user_agent : Bytes,
) = "moonbit_soup_session_set_user_agent"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.set_user_agent.html).
pub fn Session::set_user_agent(self : Session, user_agent : String) -> Unit {
  moonbit_soup_session_set_user_agent(self, @encoding/utf8.encode(user_agent))
}

///|
#borrow(instance)
extern "c" fn soup_session_connect_request_queued(
  instance : Session,
  function : FuncRef[(Session, Message, (Session, Message) -> Unit) -> Unit],
  closure : (Session, Message) -> Unit,
) -> UInt64 = "moonbit_soup_session_connect_request_queued"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/signal.Session.request-queued.html).
pub fn Session::connect_request_queued(
  self : Session,
  f : (Session, Message) -> Unit,
) -> UInt64 {
  soup_session_connect_request_queued(
    self,
    fn(instance_, msg, f) { f(instance_, msg) },
    f,
  )
}

///|
#borrow(instance)
extern "c" fn soup_session_connect_request_unqueued(
  instance : Session,
  function : FuncRef[(Session, Message, (Session, Message) -> Unit) -> Unit],
  closure : (Session, Message) -> Unit,
) -> UInt64 = "moonbit_soup_session_connect_request_unqueued"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/signal.Session.request-unqueued.html).
pub fn Session::connect_request_unqueued(
  self : Session,
  f : (Session, Message) -> Unit,
) -> UInt64 {
  soup_session_connect_request_unqueued(
    self,
    fn(instance_, msg, f) { f(instance_, msg) },
    f,
  )
}

///|
#borrow(self_, msg, cancellable)
extern "c" fn soup_session_preconnect_async(
  self_ : Session,
  msg : Message,
  io_priority : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  function : FuncRef[
    (
      Bool,
      @glib.Nullable[@glib.Error_],
      (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_soup_session_preconnect_async"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.preconnect_async.html).
pub fn Session::preconnect_async(
  self : Session,
  msg : &IMessage,
  io_priority : Int,
  cancellable : &@gio.ICancellable?,
  callback : (Result[Bool, @glib.Error_]) -> Unit,
) -> Unit {
  soup_session_preconnect_async(
    self,
    msg.as_message(),
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None => callback(Ok(result))
      }
    },
  )
}

///|
#borrow(self_, msg, cancellable)
extern "c" fn soup_session_send_and_read_async(
  self_ : Session,
  msg : Message,
  io_priority : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  function : FuncRef[
    (
      Bytes,
      @glib.Nullable[@glib.Error_],
      (Bytes, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Bytes, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_soup_session_send_and_read_async"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send_and_read_async.html).
pub fn Session::send_and_read_async(
  self : Session,
  msg : &IMessage,
  io_priority : Int,
  cancellable : &@gio.ICancellable?,
  callback : (Result[Bytes, @glib.Error_]) -> Unit,
) -> Unit {
  soup_session_send_and_read_async(
    self,
    msg.as_message(),
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None => callback(Ok(result))
      }
    },
  )
}

///|
#borrow(self_, msg, out_stream, cancellable)
extern "c" fn soup_session_send_and_splice_async(
  self_ : Session,
  msg : Message,
  out_stream : @gio.OutputStream,
  flags : Int,
  io_priority : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  function : FuncRef[
    (
      Int64,
      @glib.Nullable[@glib.Error_],
      (Int64, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Int64, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_soup_session_send_and_splice_async"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send_and_splice_async.html).
pub fn Session::send_and_splice_async(
  self : Session,
  msg : &IMessage,
  out_stream : &@gio.IOutputStream,
  flags : @gio.OutputStreamSpliceFlags,
  io_priority : Int,
  cancellable : &@gio.ICancellable?,
  callback : (Result[Int64, @glib.Error_]) -> Unit,
) -> Unit {
  soup_session_send_and_splice_async(
    self,
    msg.as_message(),
    out_stream.as_output_stream(),
    flags.to_int(),
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None => callback(Ok(result))
      }
    },
  )
}

///|
#borrow(self_, msg, cancellable)
extern "c" fn soup_session_send_async(
  self_ : Session,
  msg : Message,
  io_priority : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  function : FuncRef[
    (
      @glib.Nullable[@gio.InputStream],
      @glib.Nullable[@glib.Error_],
      (@glib.Nullable[@gio.InputStream], @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (@glib.Nullable[@gio.InputStream], @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_soup_session_send_async"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.send_async.html).
pub fn Session::send_async(
  self : Session,
  msg : &IMessage,
  io_priority : Int,
  cancellable : &@gio.ICancellable?,
  callback : (Result[@gio.InputStream, @glib.Error_]) -> Unit,
) -> Unit {
  soup_session_send_async(
    self,
    msg.as_message(),
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None =>
          match result.to_option() {
            Some(v) => callback(Ok(v))
            None => ()
          }
      }
    },
  )
}

///|
#borrow(self_, msg, origin, __sa_protocols, cancellable)
extern "c" fn soup_session_websocket_connect_async(
  self_ : Session,
  msg : Message,
  origin : @glib.Nullable[Bytes],
  __sa_protocols : @glib.Nullable[FixedArray[Bytes]],
  io_priority : Int,
  cancellable : @glib.Nullable[@gio.Cancellable],
  function : FuncRef[
    (
      @glib.Nullable[WebsocketConnection],
      @glib.Nullable[@glib.Error_],
      (@glib.Nullable[WebsocketConnection], @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (@glib.Nullable[WebsocketConnection], @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_soup_session_websocket_connect_async"

///|
/// [Upstream documentation](https://gnome.pages.gitlab.gnome.org/libsoup/libsoup-3.0/method.Session.websocket_connect_async.html).
pub fn Session::websocket_connect_async(
  self : Session,
  msg : &IMessage,
  origin : String?,
  protocols : Array[String]?,
  io_priority : Int,
  cancellable : &@gio.ICancellable?,
  callback : (Result[WebsocketConnection, @glib.Error_]) -> Unit,
) -> Unit {
  soup_session_websocket_connect_async(
    self,
    msg.as_message(),
    match origin {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    match protocols {
      Some(arr) =>
        @glib.Nullable::some(
          FixedArray::from_array(arr.map(fn(s) { @encoding/utf8.encode(s) })),
        )
      None => @glib.Nullable::null()
    },
    io_priority,
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    fn(result, error, f) { f(result, error) },
    fn(result, error) {
      match error.to_option() {
        Some(e) => callback(Err(e))
        None =>
          match result.to_option() {
            Some(v) => callback(Ok(v))
            None => ()
          }
      }
    },
  )
}

///|
impl ISession with fn abort(self) -> Unit {
  self.as_session().abort()
}

///|
impl ISession with fn add_feature(self, feature) -> Unit {
  self.as_session().add_feature(feature)
}

///|
impl ISession with fn get_accept_language(self) -> String? {
  self.as_session().get_accept_language()
}

///|
impl ISession with fn get_accept_language_auto(self) -> Bool {
  self.as_session().get_accept_language_auto()
}

///|
impl ISession with fn get_async_result_message(self, result) -> Message? {
  self.as_session().get_async_result_message(result)
}

///|
impl ISession with fn get_idle_timeout(self) -> UInt {
  self.as_session().get_idle_timeout()
}

///|
impl ISession with fn get_local_address(self) -> @gio.InetSocketAddress? {
  self.as_session().get_local_address()
}

///|
impl ISession with fn get_max_conns(self) -> UInt {
  self.as_session().get_max_conns()
}

///|
impl ISession with fn get_max_conns_per_host(self) -> UInt {
  self.as_session().get_max_conns_per_host()
}

///|
impl ISession with fn get_proxy_resolver(self) -> @gio.ProxyResolver? {
  self.as_session().get_proxy_resolver()
}

///|
impl ISession with fn get_remote_connectable(self) -> @gio.SocketConnectable? {
  self.as_session().get_remote_connectable()
}

///|
impl ISession with fn get_timeout(self) -> UInt {
  self.as_session().get_timeout()
}

///|
impl ISession with fn get_tls_database(self) -> @gio.TlsDatabase? {
  self.as_session().get_tls_database()
}

///|
impl ISession with fn get_tls_interaction(self) -> @gio.TlsInteraction? {
  self.as_session().get_tls_interaction()
}

///|
impl ISession with fn get_user_agent(self) -> String? {
  self.as_session().get_user_agent()
}

///|
impl ISession with fn remove_feature(self, feature) -> Unit {
  self.as_session().remove_feature(feature)
}

///|
impl ISession with fn send(self, msg, cancellable) -> @gio.InputStream raise @glib.Error_ {
  self.as_session().send(msg, cancellable)
}

///|
impl ISession with fn send_and_read(self, msg, cancellable) -> Bytes raise @glib.Error_ {
  self.as_session().send_and_read(msg, cancellable)
}

///|
impl ISession with fn send_and_splice(self, msg, out_stream, flags, cancellable) -> Int64 raise @glib.Error_ {
  self.as_session().send_and_splice(msg, out_stream, flags, cancellable)
}

///|
impl ISession with fn set_accept_language(self, accept_language) -> Unit {
  self.as_session().set_accept_language(accept_language)
}

///|
impl ISession with fn set_accept_language_auto(self, accept_language_auto) -> Unit {
  self.as_session().set_accept_language_auto(accept_language_auto)
}

///|
impl ISession with fn set_idle_timeout(self, timeout) -> Unit {
  self.as_session().set_idle_timeout(timeout)
}

///|
impl ISession with fn set_proxy_resolver(self, proxy_resolver) -> Unit {
  self.as_session().set_proxy_resolver(proxy_resolver)
}

///|
impl ISession with fn set_timeout(self, timeout) -> Unit {
  self.as_session().set_timeout(timeout)
}

///|
impl ISession with fn set_tls_database(self, tls_database) -> Unit {
  self.as_session().set_tls_database(tls_database)
}

///|
impl ISession with fn set_tls_interaction(self, tls_interaction) -> Unit {
  self.as_session().set_tls_interaction(tls_interaction)
}

///|
impl ISession with fn set_user_agent(self, user_agent) -> Unit {
  self.as_session().set_user_agent(user_agent)
}

///|
impl ISession with fn connect_request_queued(self, f) -> UInt64 {
  self.as_session().connect_request_queued(f)
}

///|
impl ISession with fn connect_request_unqueued(self, f) -> UInt64 {
  self.as_session().connect_request_unqueued(f)
}

///|
impl ISession with fn preconnect_async(
  self,
  msg,
  io_priority,
  cancellable,
  callback,
) -> Unit {
  self.as_session().preconnect_async(msg, io_priority, cancellable, callback)
}

///|
impl ISession with fn send_and_read_async(
  self,
  msg,
  io_priority,
  cancellable,
  callback,
) -> Unit {
  self.as_session().send_and_read_async(msg, io_priority, cancellable, callback)
}

///|
impl ISession with fn send_and_splice_async(
  self,
  msg,
  out_stream,
  flags,
  io_priority,
  cancellable,
  callback,
) -> Unit {
  self
  .as_session()
  .send_and_splice_async(
    msg, out_stream, flags, io_priority, cancellable, callback,
  )
}

///|
impl ISession with fn send_async(self, msg, io_priority, cancellable, callback) -> Unit {
  self.as_session().send_async(msg, io_priority, cancellable, callback)
}

///|
impl ISession with fn websocket_connect_async(
  self,
  msg,
  origin,
  protocols,
  io_priority,
  cancellable,
  callback,
) -> Unit {
  self
  .as_session()
  .websocket_connect_async(
    msg, origin, protocols, io_priority, cancellable, callback,
  )
}

///|
pub fn Session::as_gobject_object(self : Session) -> @gobject.Object = "%identity"

///|
pub impl @gobject.IObject for Session with fn as_object(self) {
  self.as_gobject_object()
}