// GENERATED — DO NOT EDIT

///|
/// [Upstream documentation](https://docs.gtk.org/gio/class.Subprocess.html).
pub type Subprocess

///|
pub(open) trait ISubprocess {
  fn as_subprocess(Self) -> Subprocess
  fn communicate_utf8(Self, String?, &ICancellable?) -> (Bool, String?, String?) raise @glib.Error_ = _
  fn communicate_utf8_finish(Self, &IAsyncResult) -> (Bool, String?, String?) raise @glib.Error_ = _
  fn force_exit(Self) -> Unit = _
  fn get_exit_status(Self) -> Int = _
  fn get_identifier(Self) -> String? = _
  fn get_if_exited(Self) -> Bool = _
  fn get_if_signaled(Self) -> Bool = _
  fn get_status(Self) -> Int = _
  fn get_stderr_pipe(Self) -> InputStream? = _
  fn get_stdin_pipe(Self) -> OutputStream? = _
  fn get_stdout_pipe(Self) -> InputStream? = _
  fn get_successful(Self) -> Bool = _
  fn get_term_sig(Self) -> Int = _
  fn send_signal(Self, Int) -> Unit = _
  fn wait(Self, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn wait_check(Self, &ICancellable?) -> Bool raise @glib.Error_ = _
  fn wait_async(Self, &ICancellable?, (Result[Bool, @glib.Error_]) -> Unit) -> Unit = _
  fn wait_check_async(
    Self,
    &ICancellable?,
    (Result[Bool, @glib.Error_]) -> Unit,
  ) -> Unit = _
}

///|
pub impl ISubprocess for Subprocess with fn as_subprocess(self) {
  self
}

///|
#borrow(__sa_argv, error)
extern "c" fn moonbit_g_subprocess_newv(
  __sa_argv : FixedArray[Bytes],
  flags : Int,
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Subprocess = "moonbit_g_subprocess_newv"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/ctor.Subprocess.newv.html).
pub fn Subprocess::newv(
  argv : Array[String],
  flags : SubprocessFlags,
) -> Subprocess raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_subprocess_newv(
    FixedArray::from_array(argv.map(fn(s) { @encoding/utf8.encode(s) })),
    flags.to_int(),
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => result
  }
}

///|
#borrow(self_, stdin_buf, cancellable, stdout_buf, stderr_buf, error)
extern "c" fn moonbit_g_subprocess_communicate_utf8(
  self_ : Subprocess,
  stdin_buf : @glib.Nullable[Bytes],
  cancellable : @glib.Nullable[Cancellable],
  stdout_buf : Ref[@glib.Nullable[Bytes]],
  stderr_buf : Ref[@glib.Nullable[Bytes]],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_subprocess_communicate_utf8"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.communicate_utf8.html).
pub fn Subprocess::communicate_utf8(
  self : Subprocess,
  stdin_buf : String?,
  cancellable : &ICancellable?,
) -> (Bool, String?, String?) raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let stdout_buf : Ref[@glib.Nullable[Bytes]] = Ref(@glib.Nullable::null())
  let stderr_buf : Ref[@glib.Nullable[Bytes]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_subprocess_communicate_utf8(
    self,
    match stdin_buf {
      Some(s) => @glib.Nullable::some(@encoding/utf8.encode(s))
      None => @glib.Nullable::null()
    },
    match cancellable {
      Some(v) => @glib.Nullable::some(v.as_cancellable())
      None => @glib.Nullable::null()
    },
    stdout_buf,
    stderr_buf,
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  (
    result,
    match stdout_buf.val.to_option() {
      Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
      None => None
    },
    match stderr_buf.val.to_option() {
      Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
      None => None
    },
  )
}

///|
#borrow(self_, result, stdout_buf, stderr_buf, error)
extern "c" fn moonbit_g_subprocess_communicate_utf8_finish(
  self_ : Subprocess,
  result : AsyncResult,
  stdout_buf : Ref[@glib.Nullable[Bytes]],
  stderr_buf : Ref[@glib.Nullable[Bytes]],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_subprocess_communicate_utf8_finish"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.communicate_utf8_finish.html).
pub fn Subprocess::communicate_utf8_finish(
  self : Subprocess,
  result : &IAsyncResult,
) -> (Bool, String?, String?) raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let stdout_buf : Ref[@glib.Nullable[Bytes]] = Ref(@glib.Nullable::null())
  let stderr_buf : Ref[@glib.Nullable[Bytes]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_subprocess_communicate_utf8_finish(
    self,
    result.as_async_result(),
    stdout_buf,
    stderr_buf,
    error_,
  )
  match error_.val.to_option() {
    Some(e) => raise e
    None => ()
  }
  (
    result,
    match stdout_buf.val.to_option() {
      Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
      None => None
    },
    match stderr_buf.val.to_option() {
      Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
      None => None
    },
  )
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.force_exit.html).
#borrow(self)
pub extern "c" fn Subprocess::force_exit(self : Subprocess) = "moonbit_g_subprocess_force_exit"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_exit_status.html).
#borrow(self)
pub extern "c" fn Subprocess::get_exit_status(self : Subprocess) -> Int = "moonbit_g_subprocess_get_exit_status"

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

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_identifier.html).
pub fn Subprocess::get_identifier(self : Subprocess) -> String? {
  let result = moonbit_g_subprocess_get_identifier(self)
  match result.to_option() {
    Some(bytes) => Some(@encoding/utf8.decode_lossy(bytes))
    None => None
  }
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_if_exited.html).
#borrow(self)
pub extern "c" fn Subprocess::get_if_exited(self : Subprocess) -> Bool = "moonbit_g_subprocess_get_if_exited"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_if_signaled.html).
#borrow(self)
pub extern "c" fn Subprocess::get_if_signaled(self : Subprocess) -> Bool = "moonbit_g_subprocess_get_if_signaled"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_status.html).
#borrow(self)
pub extern "c" fn Subprocess::get_status(self : Subprocess) -> Int = "moonbit_g_subprocess_get_status"

///|
#borrow(self_)
extern "c" fn moonbit_g_subprocess_get_stderr_pipe(
  self_ : Subprocess,
) -> @glib.Nullable[InputStream] = "moonbit_g_subprocess_get_stderr_pipe"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_stderr_pipe.html).
pub fn Subprocess::get_stderr_pipe(self : Subprocess) -> InputStream? {
  let raw_result = moonbit_g_subprocess_get_stderr_pipe(self)
  raw_result.to_option()
}

///|
#borrow(self_)
extern "c" fn moonbit_g_subprocess_get_stdin_pipe(
  self_ : Subprocess,
) -> @glib.Nullable[OutputStream] = "moonbit_g_subprocess_get_stdin_pipe"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_stdin_pipe.html).
pub fn Subprocess::get_stdin_pipe(self : Subprocess) -> OutputStream? {
  let raw_result = moonbit_g_subprocess_get_stdin_pipe(self)
  raw_result.to_option()
}

///|
#borrow(self_)
extern "c" fn moonbit_g_subprocess_get_stdout_pipe(
  self_ : Subprocess,
) -> @glib.Nullable[InputStream] = "moonbit_g_subprocess_get_stdout_pipe"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_stdout_pipe.html).
pub fn Subprocess::get_stdout_pipe(self : Subprocess) -> InputStream? {
  let raw_result = moonbit_g_subprocess_get_stdout_pipe(self)
  raw_result.to_option()
}

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_successful.html).
#borrow(self)
pub extern "c" fn Subprocess::get_successful(self : Subprocess) -> Bool = "moonbit_g_subprocess_get_successful"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.get_term_sig.html).
#borrow(self)
pub extern "c" fn Subprocess::get_term_sig(self : Subprocess) -> Int = "moonbit_g_subprocess_get_term_sig"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.send_signal.html).
#borrow(self)
pub extern "c" fn Subprocess::send_signal(self : Subprocess, signal_num : Int) = "moonbit_g_subprocess_send_signal"

///|
#borrow(self_, cancellable, error)
extern "c" fn moonbit_g_subprocess_wait(
  self_ : Subprocess,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_subprocess_wait"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.wait.html).
pub fn Subprocess::wait(
  self : Subprocess,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_subprocess_wait(
    self,
    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_, cancellable, error)
extern "c" fn moonbit_g_subprocess_wait_check(
  self_ : Subprocess,
  cancellable : @glib.Nullable[Cancellable],
  error : Ref[@glib.Nullable[@glib.Error_]],
) -> Bool = "moonbit_g_subprocess_wait_check"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.wait_check.html).
pub fn Subprocess::wait_check(
  self : Subprocess,
  cancellable : &ICancellable?,
) -> Bool raise @glib.Error_ {
  let error_ : Ref[@glib.Nullable[@glib.Error_]] = Ref(@glib.Nullable::null())
  let result = moonbit_g_subprocess_wait_check(
    self,
    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_, cancellable)
extern "c" fn g_subprocess_wait_async(
  self_ : Subprocess,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      Bool,
      @glib.Nullable[@glib.Error_],
      (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_subprocess_wait_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.wait_async.html).
pub fn Subprocess::wait_async(
  self : Subprocess,
  cancellable : &ICancellable?,
  callback : (Result[Bool, @glib.Error_]) -> Unit,
) -> Unit {
  g_subprocess_wait_async(
    self,
    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_, cancellable)
extern "c" fn g_subprocess_wait_check_async(
  self_ : Subprocess,
  cancellable : @glib.Nullable[Cancellable],
  function : FuncRef[
    (
      Bool,
      @glib.Nullable[@glib.Error_],
      (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
    ) -> Unit,
  ],
  closure : (Bool, @glib.Nullable[@glib.Error_]) -> Unit,
) = "moonbit_g_subprocess_wait_check_async"

///|
/// [Upstream documentation](https://docs.gtk.org/gio/method.Subprocess.wait_check_async.html).
pub fn Subprocess::wait_check_async(
  self : Subprocess,
  cancellable : &ICancellable?,
  callback : (Result[Bool, @glib.Error_]) -> Unit,
) -> Unit {
  g_subprocess_wait_check_async(
    self,
    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))
      }
    },
  )
}

///|
impl ISubprocess with fn communicate_utf8(self, stdin_buf, cancellable) -> (
  Bool,
  String?,
  String?,
) raise @glib.Error_ {
  self.as_subprocess().communicate_utf8(stdin_buf, cancellable)
}

///|
impl ISubprocess with fn communicate_utf8_finish(self, result) -> (
  Bool,
  String?,
  String?,
) raise @glib.Error_ {
  self.as_subprocess().communicate_utf8_finish(result)
}

///|
impl ISubprocess with fn force_exit(self) -> Unit {
  self.as_subprocess().force_exit()
}

///|
impl ISubprocess with fn get_exit_status(self) -> Int {
  self.as_subprocess().get_exit_status()
}

///|
impl ISubprocess with fn get_identifier(self) -> String? {
  self.as_subprocess().get_identifier()
}

///|
impl ISubprocess with fn get_if_exited(self) -> Bool {
  self.as_subprocess().get_if_exited()
}

///|
impl ISubprocess with fn get_if_signaled(self) -> Bool {
  self.as_subprocess().get_if_signaled()
}

///|
impl ISubprocess with fn get_status(self) -> Int {
  self.as_subprocess().get_status()
}

///|
impl ISubprocess with fn get_stderr_pipe(self) -> InputStream? {
  self.as_subprocess().get_stderr_pipe()
}

///|
impl ISubprocess with fn get_stdin_pipe(self) -> OutputStream? {
  self.as_subprocess().get_stdin_pipe()
}

///|
impl ISubprocess with fn get_stdout_pipe(self) -> InputStream? {
  self.as_subprocess().get_stdout_pipe()
}

///|
impl ISubprocess with fn get_successful(self) -> Bool {
  self.as_subprocess().get_successful()
}

///|
impl ISubprocess with fn get_term_sig(self) -> Int {
  self.as_subprocess().get_term_sig()
}

///|
impl ISubprocess with fn send_signal(self, signal_num) -> Unit {
  self.as_subprocess().send_signal(signal_num)
}

///|
impl ISubprocess with fn wait(self, cancellable) -> Bool raise @glib.Error_ {
  self.as_subprocess().wait(cancellable)
}

///|
impl ISubprocess with fn wait_check(self, cancellable) -> Bool raise @glib.Error_ {
  self.as_subprocess().wait_check(cancellable)
}

///|
impl ISubprocess with fn wait_async(self, cancellable, callback) -> Unit {
  self.as_subprocess().wait_async(cancellable, callback)
}

///|
impl ISubprocess with fn wait_check_async(self, cancellable, callback) -> Unit {
  self.as_subprocess().wait_check_async(cancellable, callback)
}

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

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

///|
pub fn Subprocess::as_initable(self : Subprocess) -> Initable = "%identity"

///|
pub impl IInitable for Subprocess with fn as_initable(self) {
  self.as_initable()
}