    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    'GI.Gio.Objects.Subprocess.Subprocess' allows the creation of and interaction with child
    processes.

    Processes can be communicated with using standard GIO-style APIs (ie:
    'GI.Gio.Objects.InputStream.InputStream', 'GI.Gio.Objects.OutputStream.OutputStream').  There are GIO-style APIs to wait for
    process termination (ie: cancellable and with an asynchronous
    variant).

    There is an API to force a process to terminate, as well as a
    race-free API for sending UNIX signals to a subprocess.

    One major advantage that GIO brings over the core GLib library is
    comprehensive API for asynchronous I\/O, such
    'GI.Gio.Objects.OutputStream.outputStreamSpliceAsync'.  This makes GSubprocess
    significantly more powerful and flexible than equivalent APIs in
    some other languages such as the @subprocess.py@
    included with Python.  For example, using 'GI.Gio.Objects.Subprocess.Subprocess' one could
    create two child processes, reading standard output from the first,
    processing it, and writing to the input stream of the second, all
    without blocking the main loop.

    A powerful 'GI.Gio.Objects.Subprocess.subprocessCommunicate' API is provided similar to the
    @communicate()@ method of @subprocess.py@. This enables very easy
    interaction with a subprocess that has been opened with pipes.

    'GI.Gio.Objects.Subprocess.Subprocess' defaults to tight control over the file descriptors open
    in the child process, avoiding dangling-fd issues that are caused by
    a simple @/fork()/@\/@/exec()/@.  The only open file descriptors in the
    spawned process are ones that were explicitly specified by the
    'GI.Gio.Objects.Subprocess.Subprocess' API (unless 'GI.Gio.Flags.SubprocessFlagsInheritFds' was
    specified).

    'GI.Gio.Objects.Subprocess.Subprocess' will quickly reap all child processes as they exit,
    avoiding \"zombie processes\" remaining around for long periods of
    time.  'GI.Gio.Objects.Subprocess.subprocessWait' can be used to wait for this to happen,
    but it will happen even without the call being explicitly made.

    As a matter of principle, 'GI.Gio.Objects.Subprocess.Subprocess' has no API that accepts
    shell-style space-separated strings.  It will, however, match the
    typical shell behaviour of searching the PATH for executables that do
    not contain a directory separator in their name.

    'GI.Gio.Objects.Subprocess.Subprocess' attempts to have a very simple API for most uses (ie:
    spawning a subprocess with arguments and support for most typical
    kinds of input and output redirection).  See @/g_subprocess_new()/@. The
    'GI.Gio.Objects.SubprocessLauncher.SubprocessLauncher' API is provided for more complicated cases
    (advanced types of redirection, environment variable manipulation,
    change of working directory, child setup functions, etc).

    A typical use of 'GI.Gio.Objects.Subprocess.Subprocess' will involve calling
    @/g_subprocess_new()/@, followed by 'GI.Gio.Objects.Subprocess.subprocessWaitAsync' or
    'GI.Gio.Objects.Subprocess.subprocessWait'.  After the process exits, the status can be
    checked using functions such as 'GI.Gio.Objects.Subprocess.subprocessGetIfExited' (which
    are similar to the familiar WIFEXITED-style POSIX macros).

    /Since: 2.40/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.Subprocess
        (

    -- * Exported types
        Subprocess(..)                          ,
        IsSubprocess                            ,
        toSubprocess                            ,
        noSubprocess                            ,

     -- * Methods
    -- ** communicate #method:communicate#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateMethodInfo         ,
    #endif
        subprocessCommunicate                   ,

    -- ** communicateAsync #method:communicateAsync#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateAsyncMethodInfo    ,
    #endif
        subprocessCommunicateAsync              ,

    -- ** communicateFinish #method:communicateFinish#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateFinishMethodInfo   ,
    #endif
        subprocessCommunicateFinish             ,

    -- ** communicateUtf8 #method:communicateUtf8#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateUtf8MethodInfo     ,
    #endif
        subprocessCommunicateUtf8               ,

    -- ** communicateUtf8Async #method:communicateUtf8Async#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateUtf8AsyncMethodInfo,
    #endif
        subprocessCommunicateUtf8Async          ,

    -- ** communicateUtf8Finish #method:communicateUtf8Finish#

    #if ENABLE_OVERLOADING
        SubprocessCommunicateUtf8FinishMethodInfo,
    #endif
        subprocessCommunicateUtf8Finish         ,

    -- ** forceExit #method:forceExit#

    #if ENABLE_OVERLOADING
        SubprocessForceExitMethodInfo           ,
    #endif
        subprocessForceExit                     ,

    -- ** getExitStatus #method:getExitStatus#

    #if ENABLE_OVERLOADING
        SubprocessGetExitStatusMethodInfo       ,
    #endif
        subprocessGetExitStatus                 ,

    -- ** getIdentifier #method:getIdentifier#

    #if ENABLE_OVERLOADING
        SubprocessGetIdentifierMethodInfo       ,
    #endif
        subprocessGetIdentifier                 ,

    -- ** getIfExited #method:getIfExited#

    #if ENABLE_OVERLOADING
        SubprocessGetIfExitedMethodInfo         ,
    #endif
        subprocessGetIfExited                   ,

    -- ** getIfSignaled #method:getIfSignaled#

    #if ENABLE_OVERLOADING
        SubprocessGetIfSignaledMethodInfo       ,
    #endif
        subprocessGetIfSignaled                 ,

    -- ** getStatus #method:getStatus#

    #if ENABLE_OVERLOADING
        SubprocessGetStatusMethodInfo           ,
    #endif
        subprocessGetStatus                     ,

    -- ** getStderrPipe #method:getStderrPipe#

    #if ENABLE_OVERLOADING
        SubprocessGetStderrPipeMethodInfo       ,
    #endif
        subprocessGetStderrPipe                 ,

    -- ** getStdinPipe #method:getStdinPipe#

    #if ENABLE_OVERLOADING
        SubprocessGetStdinPipeMethodInfo        ,
    #endif
        subprocessGetStdinPipe                  ,

    -- ** getStdoutPipe #method:getStdoutPipe#

    #if ENABLE_OVERLOADING
        SubprocessGetStdoutPipeMethodInfo       ,
    #endif
        subprocessGetStdoutPipe                 ,

    -- ** getSuccessful #method:getSuccessful#

    #if ENABLE_OVERLOADING
        SubprocessGetSuccessfulMethodInfo       ,
    #endif
        subprocessGetSuccessful                 ,

    -- ** getTermSig #method:getTermSig#

    #if ENABLE_OVERLOADING
        SubprocessGetTermSigMethodInfo          ,
    #endif
        subprocessGetTermSig                    ,

    -- ** new #method:new#

        subprocessNew                           ,

    -- ** sendSignal #method:sendSignal#

    #if ENABLE_OVERLOADING
        SubprocessSendSignalMethodInfo          ,
    #endif
        subprocessSendSignal                    ,

    -- ** wait #method:wait#

    #if ENABLE_OVERLOADING
        SubprocessWaitMethodInfo                ,
    #endif
        subprocessWait                          ,

    -- ** waitAsync #method:waitAsync#

    #if ENABLE_OVERLOADING
        SubprocessWaitAsyncMethodInfo           ,
    #endif
        subprocessWaitAsync                     ,

    -- ** waitCheck #method:waitCheck#

    #if ENABLE_OVERLOADING
        SubprocessWaitCheckMethodInfo           ,
    #endif
        subprocessWaitCheck                     ,

    -- ** waitCheckAsync #method:waitCheckAsync#

    #if ENABLE_OVERLOADING
        SubprocessWaitCheckAsyncMethodInfo      ,
    #endif
        subprocessWaitCheckAsync                ,

    -- ** waitCheckFinish #method:waitCheckFinish#

    #if ENABLE_OVERLOADING
        SubprocessWaitCheckFinishMethodInfo     ,
    #endif
        subprocessWaitCheckFinish               ,

    -- ** waitFinish #method:waitFinish#

    #if ENABLE_OVERLOADING
        SubprocessWaitFinishMethodInfo          ,
    #endif
        subprocessWaitFinish                    ,

     -- * Properties
    -- ** argv #attr:argv#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        SubprocessArgvPropertyInfo              ,
    #endif
        constructSubprocessArgv                 ,
    #if ENABLE_OVERLOADING
        subprocessArgv                          ,
    #endif

    -- ** flags #attr:flags#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        SubprocessFlagsPropertyInfo             ,
    #endif
        constructSubprocessFlags                ,
    #if ENABLE_OVERLOADING
        subprocessFlags                         ,
    #endif

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Initable as Gio.Initable
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.OutputStream as Gio.OutputStream

    -- | Memory-managed wrapper type.
    newtype Subprocess = Subprocess (ManagedPtr Subprocess)
    foreign import ccall "g_subprocess_get_type"
        c_g_subprocess_get_type :: IO GType

    instance GObject Subprocess where
        gobjectType _ = c_g_subprocess_get_type

    -- | Type class for types which can be safely cast to `Subprocess`, for instance with `toSubprocess`.
    class GObject o => IsSubprocess o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Subprocess a) =>
        IsSubprocess a
    #endif
    instance IsSubprocess Subprocess
    instance GObject.Object.IsObject Subprocess
    instance Gio.Initable.IsInitable Subprocess

    -- | Cast to `Subprocess`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toSubprocess :: (MonadIO m, IsSubprocess o) => o -> m Subprocess
    toSubprocess = liftIO . unsafeCastTo Subprocess

    -- | A convenience alias for `Nothing` :: `Maybe` `Subprocess`.
    noSubprocess :: Maybe Subprocess
    noSubprocess = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveSubprocessMethod (t :: Symbol) (o :: *) :: * where
        ResolveSubprocessMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSubprocessMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSubprocessMethod "communicate" o = SubprocessCommunicateMethodInfo
        ResolveSubprocessMethod "communicateAsync" o = SubprocessCommunicateAsyncMethodInfo
        ResolveSubprocessMethod "communicateFinish" o = SubprocessCommunicateFinishMethodInfo
        ResolveSubprocessMethod "communicateUtf8" o = SubprocessCommunicateUtf8MethodInfo
        ResolveSubprocessMethod "communicateUtf8Async" o = SubprocessCommunicateUtf8AsyncMethodInfo
        ResolveSubprocessMethod "communicateUtf8Finish" o = SubprocessCommunicateUtf8FinishMethodInfo
        ResolveSubprocessMethod "forceExit" o = SubprocessForceExitMethodInfo
        ResolveSubprocessMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSubprocessMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSubprocessMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSubprocessMethod "init" o = Gio.Initable.InitableInitMethodInfo
        ResolveSubprocessMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSubprocessMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSubprocessMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSubprocessMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSubprocessMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSubprocessMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSubprocessMethod "sendSignal" o = SubprocessSendSignalMethodInfo
        ResolveSubprocessMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSubprocessMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSubprocessMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSubprocessMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSubprocessMethod "wait" o = SubprocessWaitMethodInfo
        ResolveSubprocessMethod "waitAsync" o = SubprocessWaitAsyncMethodInfo
        ResolveSubprocessMethod "waitCheck" o = SubprocessWaitCheckMethodInfo
        ResolveSubprocessMethod "waitCheckAsync" o = SubprocessWaitCheckAsyncMethodInfo
        ResolveSubprocessMethod "waitCheckFinish" o = SubprocessWaitCheckFinishMethodInfo
        ResolveSubprocessMethod "waitFinish" o = SubprocessWaitFinishMethodInfo
        ResolveSubprocessMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSubprocessMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSubprocessMethod "getExitStatus" o = SubprocessGetExitStatusMethodInfo
        ResolveSubprocessMethod "getIdentifier" o = SubprocessGetIdentifierMethodInfo
        ResolveSubprocessMethod "getIfExited" o = SubprocessGetIfExitedMethodInfo
        ResolveSubprocessMethod "getIfSignaled" o = SubprocessGetIfSignaledMethodInfo
        ResolveSubprocessMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSubprocessMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSubprocessMethod "getStatus" o = SubprocessGetStatusMethodInfo
        ResolveSubprocessMethod "getStderrPipe" o = SubprocessGetStderrPipeMethodInfo
        ResolveSubprocessMethod "getStdinPipe" o = SubprocessGetStdinPipeMethodInfo
        ResolveSubprocessMethod "getStdoutPipe" o = SubprocessGetStdoutPipeMethodInfo
        ResolveSubprocessMethod "getSuccessful" o = SubprocessGetSuccessfulMethodInfo
        ResolveSubprocessMethod "getTermSig" o = SubprocessGetTermSigMethodInfo
        ResolveSubprocessMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSubprocessMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSubprocessMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveSubprocessMethod t Subprocess, O.MethodInfo info Subprocess p) => O.IsLabelProxy t (Subprocess -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveSubprocessMethod t Subprocess, O.MethodInfo info Subprocess p) => O.IsLabel t (Subprocess -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    -- VVV Prop "argv"
       -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
       -- Flags: [PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Construct a `GValueConstruct` with valid value for the “@argv@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSubprocessArgv :: (IsSubprocess o) => [T.Text] -> IO (GValueConstruct o)
    constructSubprocessArgv val = constructObjectPropertyStringArray "argv" (Just val)

    #if ENABLE_OVERLOADING
    data SubprocessArgvPropertyInfo
    instance AttrInfo SubprocessArgvPropertyInfo where
        type AttrAllowedOps SubprocessArgvPropertyInfo = '[ 'AttrConstruct, 'AttrClear]
        type AttrSetTypeConstraint SubprocessArgvPropertyInfo = (~) [T.Text]
        type AttrBaseTypeConstraint SubprocessArgvPropertyInfo = IsSubprocess
        type AttrGetType SubprocessArgvPropertyInfo = ()
        type AttrLabel SubprocessArgvPropertyInfo = "argv"
        type AttrOrigin SubprocessArgvPropertyInfo = Subprocess
        attrGet _ = undefined
        attrSet _ = undefined
        attrConstruct _ = constructSubprocessArgv
        attrClear _ = undefined
    #endif

    -- VVV Prop "flags"
       -- Type: TInterface (Name {namespace = "Gio", name = "SubprocessFlags"})
       -- Flags: [PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructSubprocessFlags :: (IsSubprocess o) => [Gio.Flags.SubprocessFlags] -> IO (GValueConstruct o)
    constructSubprocessFlags val = constructObjectPropertyFlags "flags" val

    #if ENABLE_OVERLOADING
    data SubprocessFlagsPropertyInfo
    instance AttrInfo SubprocessFlagsPropertyInfo where
        type AttrAllowedOps SubprocessFlagsPropertyInfo = '[ 'AttrConstruct]
        type AttrSetTypeConstraint SubprocessFlagsPropertyInfo = (~) [Gio.Flags.SubprocessFlags]
        type AttrBaseTypeConstraint SubprocessFlagsPropertyInfo = IsSubprocess
        type AttrGetType SubprocessFlagsPropertyInfo = ()
        type AttrLabel SubprocessFlagsPropertyInfo = "flags"
        type AttrOrigin SubprocessFlagsPropertyInfo = Subprocess
        attrGet _ = undefined
        attrSet _ = undefined
        attrConstruct _ = constructSubprocessFlags
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Subprocess
    type instance O.AttributeList Subprocess = SubprocessAttributeList
    type SubprocessAttributeList = ('[ '("argv", SubprocessArgvPropertyInfo), '("flags", SubprocessFlagsPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    subprocessArgv :: AttrLabelProxy "argv"
    subprocessArgv = AttrLabelProxy

    subprocessFlags :: AttrLabelProxy "flags"
    subprocessFlags = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList Subprocess = SubprocessSignalList
    type SubprocessSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method Subprocess::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "commandline arguments for the subprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "SubprocessFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags that define the behaviour of the subprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "Subprocess"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_newv" g_subprocess_newv ::
        Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
        CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "SubprocessFlags"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Subprocess)

    {- |
    Create a new process with the given flags and argument list.

    The argument list is expected to be 'Nothing'-terminated.

    /Since: 2.40/
    -}
    subprocessNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        [[Char]]
        {- ^ /@argv@/: commandline arguments for the subprocess -}
        -> [Gio.Flags.SubprocessFlags]
        {- ^ /@flags@/: flags that define the behaviour of the subprocess -}
        -> m Subprocess
        {- ^ __Returns:__ A newly created 'GI.Gio.Objects.Subprocess.Subprocess', or 'Nothing' on error (and /@error@/
      will be set) /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessNew argv flags = liftIO $ do
        argv' <- packZeroTerminatedFileNameArray argv
        let flags' = gflagsToWord flags
        onException (do
            result <- propagateGError $ g_subprocess_newv argv' flags'
            checkUnexpectedReturnNULL "subprocessNew" result
            result' <- (wrapObject Subprocess) result
            mapZeroTerminatedCArray freeMem argv'
            freeMem argv'
            return result'
         ) (do
            mapZeroTerminatedCArray freeMem argv'
            freeMem argv'
         )

    #if ENABLE_OVERLOADING
    #endif

    -- method Subprocess::communicate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdin_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the stdin of the subprocess, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdout_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data read from the subprocess stdout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stderr_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data read from the subprocess stderr", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate" g_subprocess_communicate ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr GLib.Bytes.Bytes ->                 -- stdin_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GLib.Bytes.Bytes) ->           -- stdout_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr (Ptr GLib.Bytes.Bytes) ->           -- stderr_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Communicate with the subprocess until it terminates, and all input
    and output has been completed.

    If /@stdinBuf@/ is given, the subprocess must have been created with
    'GI.Gio.Flags.SubprocessFlagsStdinPipe'.  The given data is fed to the
    stdin of the subprocess and the pipe is closed (ie: EOF).

    At the same time (as not to cause blocking when dealing with large
    amounts of data), if 'GI.Gio.Flags.SubprocessFlagsStdoutPipe' or
    'GI.Gio.Flags.SubprocessFlagsStderrPipe' were used, reads from those
    streams.  The data that was read is returned in /@stdout@/ and\/or
    the /@stderr@/.

    If the subprocess was created with 'GI.Gio.Flags.SubprocessFlagsStdoutPipe',
    /@stdoutBuf@/ will contain the data read from stdout.  Otherwise, for
    subprocesses not created with 'GI.Gio.Flags.SubprocessFlagsStdoutPipe',
    /@stdoutBuf@/ will be set to 'Nothing'.  Similar provisions apply to
    /@stderrBuf@/ and 'GI.Gio.Flags.SubprocessFlagsStderrPipe'.

    As usual, any output variable may be given as 'Nothing' to ignore it.

    If you desire the stdout and stderr data to be interleaved, create
    the subprocess with 'GI.Gio.Flags.SubprocessFlagsStdoutPipe' and
    'GI.Gio.Flags.SubprocessFlagsStderrMerge'.  The merged result will be returned
    in /@stdoutBuf@/ and /@stderrBuf@/ will be set to 'Nothing'.

    In case of any error (including cancellation), 'False' will be
    returned with /@error@/ set.  Some or all of the stdin data may have
    been written.  Any stdout or stderr data that has been read will be
    discarded. None of the out variables (aside from /@error@/) will have
    been set to anything in particular and should not be inspected.

    In the case that 'True' is returned, the subprocess has exited and the
    exit status inspection APIs (eg: 'GI.Gio.Objects.Subprocess.subprocessGetIfExited',
    'GI.Gio.Objects.Subprocess.subprocessGetExitStatus') may be used.

    You should not attempt to use any of the subprocess pipes after
    starting this function, since they may be left in strange states,
    even if the operation was cancelled.  You should especially not
    attempt to interact with the pipes while the operation is in progress
    (either from another thread or if using the asynchronous version).

    /Since: 2.40/
    -}
    subprocessCommunicate ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (GLib.Bytes.Bytes)
        {- ^ /@stdinBuf@/: data to send to the stdin of the subprocess, or 'Nothing' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
        -> m ((Maybe GLib.Bytes.Bytes, Maybe GLib.Bytes.Bytes))
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessCommunicate subprocess stdinBuf cancellable = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeStdinBuf <- case stdinBuf of
            Nothing -> return nullPtr
            Just jStdinBuf -> do
                jStdinBuf' <- unsafeManagedPtrGetPtr jStdinBuf
                return jStdinBuf'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        stdoutBuf <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
        stderrBuf <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
        onException (do
            _ <- propagateGError $ g_subprocess_communicate subprocess' maybeStdinBuf maybeCancellable stdoutBuf stderrBuf
            stdoutBuf' <- peek stdoutBuf
            maybeStdoutBuf' <- convertIfNonNull stdoutBuf' $ \stdoutBuf'' -> do
                stdoutBuf''' <- (wrapBoxed GLib.Bytes.Bytes) stdoutBuf''
                return stdoutBuf'''
            stderrBuf' <- peek stderrBuf
            maybeStderrBuf' <- convertIfNonNull stderrBuf' $ \stderrBuf'' -> do
                stderrBuf''' <- (wrapBoxed GLib.Bytes.Bytes) stderrBuf''
                return stderrBuf'''
            touchManagedPtr subprocess
            whenJust stdinBuf touchManagedPtr
            whenJust cancellable touchManagedPtr
            freeMem stdoutBuf
            freeMem stderrBuf
            return (maybeStdoutBuf', maybeStderrBuf')
         ) (do
            freeMem stdoutBuf
            freeMem stderrBuf
         )

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateMethodInfo
    instance (signature ~ (Maybe (GLib.Bytes.Bytes) -> Maybe (b) -> m ((Maybe GLib.Bytes.Bytes, Maybe GLib.Bytes.Bytes))), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessCommunicateMethodInfo a signature where
        overloadedMethod _ = subprocessCommunicate

    #endif

    -- method Subprocess::communicate_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdin_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Input data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate_async" g_subprocess_communicate_async ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr GLib.Bytes.Bytes ->                 -- stdin_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronous version of 'GI.Gio.Objects.Subprocess.subprocessCommunicate'.  Complete
    invocation with 'GI.Gio.Objects.Subprocess.subprocessCommunicateFinish'.
    -}
    subprocessCommunicateAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: Self -}
        -> Maybe (GLib.Bytes.Bytes)
        {- ^ /@stdinBuf@/: Input data, or 'Nothing' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: Cancellable -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: Callback -}
        -> m ()
    subprocessCommunicateAsync subprocess stdinBuf cancellable callback = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeStdinBuf <- case stdinBuf of
            Nothing -> return nullPtr
            Just jStdinBuf -> do
                jStdinBuf' <- unsafeManagedPtrGetPtr jStdinBuf
                return jStdinBuf'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_subprocess_communicate_async subprocess' maybeStdinBuf maybeCancellable maybeCallback userData
        touchManagedPtr subprocess
        whenJust stdinBuf touchManagedPtr
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateAsyncMethodInfo
    instance (signature ~ (Maybe (GLib.Bytes.Bytes) -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessCommunicateAsyncMethodInfo a signature where
        overloadedMethod _ = subprocessCommunicateAsync

    #endif

    -- method Subprocess::communicate_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdout_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for stdout data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stderr_buf", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for stderr data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate_finish" g_subprocess_communicate_finish ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GLib.Bytes.Bytes) ->           -- stdout_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr (Ptr GLib.Bytes.Bytes) ->           -- stderr_buf : TInterface (Name {namespace = "GLib", name = "Bytes"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Complete an invocation of 'GI.Gio.Objects.Subprocess.subprocessCommunicateAsync'.
    -}
    subprocessCommunicateFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@subprocess@/: Self -}
        -> b
        {- ^ /@result@/: Result -}
        -> m ((Maybe GLib.Bytes.Bytes, Maybe GLib.Bytes.Bytes))
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessCommunicateFinish subprocess result_ = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result_' <- unsafeManagedPtrCastPtr result_
        stdoutBuf <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
        stderrBuf <- allocMem :: IO (Ptr (Ptr GLib.Bytes.Bytes))
        onException (do
            _ <- propagateGError $ g_subprocess_communicate_finish subprocess' result_' stdoutBuf stderrBuf
            stdoutBuf' <- peek stdoutBuf
            maybeStdoutBuf' <- convertIfNonNull stdoutBuf' $ \stdoutBuf'' -> do
                stdoutBuf''' <- (wrapBoxed GLib.Bytes.Bytes) stdoutBuf''
                return stdoutBuf'''
            stderrBuf' <- peek stderrBuf
            maybeStderrBuf' <- convertIfNonNull stderrBuf' $ \stderrBuf'' -> do
                stderrBuf''' <- (wrapBoxed GLib.Bytes.Bytes) stderrBuf''
                return stderrBuf'''
            touchManagedPtr subprocess
            touchManagedPtr result_
            freeMem stdoutBuf
            freeMem stderrBuf
            return (maybeStdoutBuf', maybeStderrBuf')
         ) (do
            freeMem stdoutBuf
            freeMem stderrBuf
         )

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateFinishMethodInfo
    instance (signature ~ (b -> m ((Maybe GLib.Bytes.Bytes, Maybe GLib.Bytes.Bytes))), MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SubprocessCommunicateFinishMethodInfo a signature where
        overloadedMethod _ = subprocessCommunicateFinish

    #endif

    -- method Subprocess::communicate_utf8
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the stdin of the subprocess, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdout_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data read from the subprocess stdout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stderr_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data read from the subprocess stderr", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate_utf8" g_subprocess_communicate_utf8 ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        CString ->                              -- stdin_buf : TBasicType TUTF8
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr CString ->                          -- stdout_buf : TBasicType TUTF8
        Ptr CString ->                          -- stderr_buf : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Like 'GI.Gio.Objects.Subprocess.subprocessCommunicate', but validates the output of the
    process as UTF-8, and returns it as a regular NUL terminated string.

    On error, /@stdoutBuf@/ and /@stderrBuf@/ will be set to undefined values and
    should not be used.
    -}
    subprocessCommunicateUtf8 ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (T.Text)
        {- ^ /@stdinBuf@/: data to send to the stdin of the subprocess, or 'Nothing' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
        -> m ((Maybe T.Text, Maybe T.Text))
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessCommunicateUtf8 subprocess stdinBuf cancellable = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeStdinBuf <- case stdinBuf of
            Nothing -> return nullPtr
            Just jStdinBuf -> do
                jStdinBuf' <- textToCString jStdinBuf
                return jStdinBuf'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        stdoutBuf <- allocMem :: IO (Ptr CString)
        stderrBuf <- allocMem :: IO (Ptr CString)
        onException (do
            _ <- propagateGError $ g_subprocess_communicate_utf8 subprocess' maybeStdinBuf maybeCancellable stdoutBuf stderrBuf
            stdoutBuf' <- peek stdoutBuf
            maybeStdoutBuf' <- convertIfNonNull stdoutBuf' $ \stdoutBuf'' -> do
                stdoutBuf''' <- cstringToText stdoutBuf''
                return stdoutBuf'''
            freeMem stdoutBuf'
            stderrBuf' <- peek stderrBuf
            maybeStderrBuf' <- convertIfNonNull stderrBuf' $ \stderrBuf'' -> do
                stderrBuf''' <- cstringToText stderrBuf''
                return stderrBuf'''
            freeMem stderrBuf'
            touchManagedPtr subprocess
            whenJust cancellable touchManagedPtr
            freeMem maybeStdinBuf
            freeMem stdoutBuf
            freeMem stderrBuf
            return (maybeStdoutBuf', maybeStderrBuf')
         ) (do
            freeMem maybeStdinBuf
            freeMem stdoutBuf
            freeMem stderrBuf
         )

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateUtf8MethodInfo
    instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> m ((Maybe T.Text, Maybe T.Text))), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessCommunicateUtf8MethodInfo a signature where
        overloadedMethod _ = subprocessCommunicateUtf8

    #endif

    -- method Subprocess::communicate_utf8_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdin_buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Input data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Cancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Callback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate_utf8_async" g_subprocess_communicate_utf8_async ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        CString ->                              -- stdin_buf : TBasicType TUTF8
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Asynchronous version of 'GI.Gio.Objects.Subprocess.subprocessCommunicateUtf8'.  Complete
    invocation with 'GI.Gio.Objects.Subprocess.subprocessCommunicateUtf8Finish'.
    -}
    subprocessCommunicateUtf8Async ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: Self -}
        -> Maybe (T.Text)
        {- ^ /@stdinBuf@/: Input data, or 'Nothing' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: Cancellable -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: Callback -}
        -> m ()
    subprocessCommunicateUtf8Async subprocess stdinBuf cancellable callback = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeStdinBuf <- case stdinBuf of
            Nothing -> return nullPtr
            Just jStdinBuf -> do
                jStdinBuf' <- textToCString jStdinBuf
                return jStdinBuf'
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_subprocess_communicate_utf8_async subprocess' maybeStdinBuf maybeCancellable maybeCallback userData
        touchManagedPtr subprocess
        whenJust cancellable touchManagedPtr
        freeMem maybeStdinBuf
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateUtf8AsyncMethodInfo
    instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessCommunicateUtf8AsyncMethodInfo a signature where
        overloadedMethod _ = subprocessCommunicateUtf8Async

    #endif

    -- method Subprocess::communicate_utf8_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Self", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Result", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stdout_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for stdout data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stderr_buf", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Return location for stderr data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_communicate_utf8_finish" g_subprocess_communicate_utf8_finish ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr CString ->                          -- stdout_buf : TBasicType TUTF8
        Ptr CString ->                          -- stderr_buf : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Complete an invocation of 'GI.Gio.Objects.Subprocess.subprocessCommunicateUtf8Async'.
    -}
    subprocessCommunicateUtf8Finish ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@subprocess@/: Self -}
        -> b
        {- ^ /@result@/: Result -}
        -> m ((Maybe T.Text, Maybe T.Text))
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessCommunicateUtf8Finish subprocess result_ = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result_' <- unsafeManagedPtrCastPtr result_
        stdoutBuf <- allocMem :: IO (Ptr CString)
        stderrBuf <- allocMem :: IO (Ptr CString)
        onException (do
            _ <- propagateGError $ g_subprocess_communicate_utf8_finish subprocess' result_' stdoutBuf stderrBuf
            stdoutBuf' <- peek stdoutBuf
            maybeStdoutBuf' <- convertIfNonNull stdoutBuf' $ \stdoutBuf'' -> do
                stdoutBuf''' <- cstringToText stdoutBuf''
                return stdoutBuf'''
            freeMem stdoutBuf'
            stderrBuf' <- peek stderrBuf
            maybeStderrBuf' <- convertIfNonNull stderrBuf' $ \stderrBuf'' -> do
                stderrBuf''' <- cstringToText stderrBuf''
                return stderrBuf'''
            freeMem stderrBuf'
            touchManagedPtr subprocess
            touchManagedPtr result_
            freeMem stdoutBuf
            freeMem stderrBuf
            return (maybeStdoutBuf', maybeStderrBuf')
         ) (do
            freeMem stdoutBuf
            freeMem stderrBuf
         )

    #if ENABLE_OVERLOADING
    data SubprocessCommunicateUtf8FinishMethodInfo
    instance (signature ~ (b -> m ((Maybe T.Text, Maybe T.Text))), MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SubprocessCommunicateUtf8FinishMethodInfo a signature where
        overloadedMethod _ = subprocessCommunicateUtf8Finish

    #endif

    -- method Subprocess::force_exit
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_force_exit" g_subprocess_force_exit ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO ()

    {- |
    Use an operating-system specific method to attempt an immediate,
    forceful termination of the process.  There is no mechanism to
    determine whether or not the request itself was successful;
    however, you can use 'GI.Gio.Objects.Subprocess.subprocessWait' to monitor the status of
    the process after calling this function.

    On Unix, this function sends @/SIGKILL/@.

    /Since: 2.40/
    -}
    subprocessForceExit ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m ()
    subprocessForceExit subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        g_subprocess_force_exit subprocess'
        touchManagedPtr subprocess
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessForceExitMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessForceExitMethodInfo a signature where
        overloadedMethod _ = subprocessForceExit

    #endif

    -- method Subprocess::get_exit_status
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_exit_status" g_subprocess_get_exit_status ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO Int32

    {- |
    Check the exit status of the subprocess, given that it exited
    normally.  This is the value passed to the @/exit()/@ system call or the
    return value from main.

    This is equivalent to the system WEXITSTATUS macro.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' and
    unless 'GI.Gio.Objects.Subprocess.subprocessGetIfExited' returned 'True'.

    /Since: 2.40/
    -}
    subprocessGetExitStatus ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Int32
        {- ^ __Returns:__ the exit status -}
    subprocessGetExitStatus subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_exit_status subprocess'
        touchManagedPtr subprocess
        return result

    #if ENABLE_OVERLOADING
    data SubprocessGetExitStatusMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetExitStatusMethodInfo a signature where
        overloadedMethod _ = subprocessGetExitStatus

    #endif

    -- method Subprocess::get_identifier
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_identifier" g_subprocess_get_identifier ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO CString

    {- |
    On UNIX, returns the process ID as a decimal string.
    On Windows, returns the result of @/GetProcessId()/@ also as a string.
    -}
    subprocessGetIdentifier ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m T.Text
    subprocessGetIdentifier subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_identifier subprocess'
        checkUnexpectedReturnNULL "subprocessGetIdentifier" result
        result' <- cstringToText result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetIdentifierMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetIdentifierMethodInfo a signature where
        overloadedMethod _ = subprocessGetIdentifier

    #endif

    -- method Subprocess::get_if_exited
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_if_exited" g_subprocess_get_if_exited ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO CInt

    {- |
    Check if the given subprocess exited normally (ie: by way of @/exit()/@
    or return from @/main()/@).

    This is equivalent to the system WIFEXITED macro.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' has
    returned.

    /Since: 2.40/
    -}
    subprocessGetIfExited ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the case of a normal exit -}
    subprocessGetIfExited subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_if_exited subprocess'
        let result' = (/= 0) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetIfExitedMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetIfExitedMethodInfo a signature where
        overloadedMethod _ = subprocessGetIfExited

    #endif

    -- method Subprocess::get_if_signaled
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_if_signaled" g_subprocess_get_if_signaled ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO CInt

    {- |
    Check if the given subprocess terminated in response to a signal.

    This is equivalent to the system WIFSIGNALED macro.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' has
    returned.

    /Since: 2.40/
    -}
    subprocessGetIfSignaled ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the case of termination due to a signal -}
    subprocessGetIfSignaled subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_if_signaled subprocess'
        let result' = (/= 0) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetIfSignaledMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetIfSignaledMethodInfo a signature where
        overloadedMethod _ = subprocessGetIfSignaled

    #endif

    -- method Subprocess::get_status
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_status" g_subprocess_get_status ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO Int32

    {- |
    Gets the raw status code of the process, as from @/waitpid()/@.

    This value has no particular meaning, but it can be used with the
    macros defined by the system headers such as WIFEXITED.  It can also
    be used with 'GI.GLib.Functions.spawnCheckExitStatus'.

    It is more likely that you want to use 'GI.Gio.Objects.Subprocess.subprocessGetIfExited'
    followed by 'GI.Gio.Objects.Subprocess.subprocessGetExitStatus'.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' has
    returned.

    /Since: 2.40/
    -}
    subprocessGetStatus ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Int32
        {- ^ __Returns:__ the (meaningless) @/waitpid()/@ exit status from the kernel -}
    subprocessGetStatus subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_status subprocess'
        touchManagedPtr subprocess
        return result

    #if ENABLE_OVERLOADING
    data SubprocessGetStatusMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetStatusMethodInfo a signature where
        overloadedMethod _ = subprocessGetStatus

    #endif

    -- method Subprocess::get_stderr_pipe
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_stderr_pipe" g_subprocess_get_stderr_pipe ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO (Ptr Gio.InputStream.InputStream)

    {- |
    Gets the 'GI.Gio.Objects.InputStream.InputStream' from which to read the stderr output of
    /@subprocess@/.

    The process must have been created with
    'GI.Gio.Flags.SubprocessFlagsStderrPipe'.

    /Since: 2.40/
    -}
    subprocessGetStderrPipe ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Gio.InputStream.InputStream
        {- ^ __Returns:__ the stderr pipe -}
    subprocessGetStderrPipe subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_stderr_pipe subprocess'
        checkUnexpectedReturnNULL "subprocessGetStderrPipe" result
        result' <- (newObject Gio.InputStream.InputStream) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetStderrPipeMethodInfo
    instance (signature ~ (m Gio.InputStream.InputStream), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetStderrPipeMethodInfo a signature where
        overloadedMethod _ = subprocessGetStderrPipe

    #endif

    -- method Subprocess::get_stdin_pipe
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "OutputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_stdin_pipe" g_subprocess_get_stdin_pipe ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO (Ptr Gio.OutputStream.OutputStream)

    {- |
    Gets the 'GI.Gio.Objects.OutputStream.OutputStream' that you can write to in order to give data
    to the stdin of /@subprocess@/.

    The process must have been created with
    'GI.Gio.Flags.SubprocessFlagsStdinPipe'.

    /Since: 2.40/
    -}
    subprocessGetStdinPipe ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Gio.OutputStream.OutputStream
        {- ^ __Returns:__ the stdout pipe -}
    subprocessGetStdinPipe subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_stdin_pipe subprocess'
        checkUnexpectedReturnNULL "subprocessGetStdinPipe" result
        result' <- (newObject Gio.OutputStream.OutputStream) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetStdinPipeMethodInfo
    instance (signature ~ (m Gio.OutputStream.OutputStream), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetStdinPipeMethodInfo a signature where
        overloadedMethod _ = subprocessGetStdinPipe

    #endif

    -- method Subprocess::get_stdout_pipe
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_stdout_pipe" g_subprocess_get_stdout_pipe ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO (Ptr Gio.InputStream.InputStream)

    {- |
    Gets the 'GI.Gio.Objects.InputStream.InputStream' from which to read the stdout output of
    /@subprocess@/.

    The process must have been created with
    'GI.Gio.Flags.SubprocessFlagsStdoutPipe'.

    /Since: 2.40/
    -}
    subprocessGetStdoutPipe ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Gio.InputStream.InputStream
        {- ^ __Returns:__ the stdout pipe -}
    subprocessGetStdoutPipe subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_stdout_pipe subprocess'
        checkUnexpectedReturnNULL "subprocessGetStdoutPipe" result
        result' <- (newObject Gio.InputStream.InputStream) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetStdoutPipeMethodInfo
    instance (signature ~ (m Gio.InputStream.InputStream), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetStdoutPipeMethodInfo a signature where
        overloadedMethod _ = subprocessGetStdoutPipe

    #endif

    -- method Subprocess::get_successful
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_successful" g_subprocess_get_successful ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO CInt

    {- |
    Checks if the process was \"successful\".  A process is considered
    successful if it exited cleanly with an exit status of 0, either by
    way of the @/exit()/@ system call or return from @/main()/@.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' has
    returned.

    /Since: 2.40/
    -}
    subprocessGetSuccessful ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the process exited cleanly with a exit status of 0 -}
    subprocessGetSuccessful subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_successful subprocess'
        let result' = (/= 0) result
        touchManagedPtr subprocess
        return result'

    #if ENABLE_OVERLOADING
    data SubprocessGetSuccessfulMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetSuccessfulMethodInfo a signature where
        overloadedMethod _ = subprocessGetSuccessful

    #endif

    -- method Subprocess::get_term_sig
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_get_term_sig" g_subprocess_get_term_sig ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        IO Int32

    {- |
    Get the signal number that caused the subprocess to terminate, given
    that it terminated due to a signal.

    This is equivalent to the system WTERMSIG macro.

    It is an error to call this function before 'GI.Gio.Objects.Subprocess.subprocessWait' and
    unless 'GI.Gio.Objects.Subprocess.subprocessGetIfSignaled' returned 'True'.

    /Since: 2.40/
    -}
    subprocessGetTermSig ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> m Int32
        {- ^ __Returns:__ the signal causing termination -}
    subprocessGetTermSig subprocess = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result <- g_subprocess_get_term_sig subprocess'
        touchManagedPtr subprocess
        return result

    #if ENABLE_OVERLOADING
    data SubprocessGetTermSigMethodInfo
    instance (signature ~ (m Int32), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessGetTermSigMethodInfo a signature where
        overloadedMethod _ = subprocessGetTermSig

    #endif

    -- method Subprocess::send_signal
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal_num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the signal number to send", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_send_signal" g_subprocess_send_signal ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Int32 ->                                -- signal_num : TBasicType TInt
        IO ()

    {- |
    Sends the UNIX signal /@signalNum@/ to the subprocess, if it is still
    running.

    This API is race-free.  If the subprocess has terminated, it will not
    be signalled.

    This API is not available on Windows.

    /Since: 2.40/
    -}
    subprocessSendSignal ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Int32
        {- ^ /@signalNum@/: the signal number to send -}
        -> m ()
    subprocessSendSignal subprocess signalNum = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        g_subprocess_send_signal subprocess' signalNum
        touchManagedPtr subprocess
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessSendSignalMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m, IsSubprocess a) => O.MethodInfo SubprocessSendSignalMethodInfo a signature where
        overloadedMethod _ = subprocessSendSignal

    #endif

    -- method Subprocess::wait
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_wait" g_subprocess_wait ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Synchronously wait for the subprocess to terminate.

    After the process terminates you can query its exit status with
    functions such as 'GI.Gio.Objects.Subprocess.subprocessGetIfExited' and
    'GI.Gio.Objects.Subprocess.subprocessGetExitStatus'.

    This function does not fail in the case of the subprocess having
    abnormal termination.  See 'GI.Gio.Objects.Subprocess.subprocessWaitCheck' for that.

    Cancelling /@cancellable@/ doesn\'t kill the subprocess.  Call
    'GI.Gio.Objects.Subprocess.subprocessForceExit' if it is desirable.

    /Since: 2.40/
    -}
    subprocessWait ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessWait subprocess cancellable = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_subprocess_wait subprocess' maybeCancellable
            touchManagedPtr subprocess
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data SubprocessWaitMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessWaitMethodInfo a signature where
        overloadedMethod _ = subprocessWait

    #endif

    -- method Subprocess::wait_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_wait_async" g_subprocess_wait_async ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Wait for the subprocess to terminate.

    This is the asynchronous version of 'GI.Gio.Objects.Subprocess.subprocessWait'.

    /Since: 2.40/
    -}
    subprocessWaitAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the operation is complete -}
        -> m ()
    subprocessWaitAsync subprocess cancellable callback = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_subprocess_wait_async subprocess' maybeCancellable maybeCallback userData
        touchManagedPtr subprocess
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessWaitAsyncMethodInfo
    instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessWaitAsyncMethodInfo a signature where
        overloadedMethod _ = subprocessWaitAsync

    #endif

    -- method Subprocess::wait_check
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_wait_check" g_subprocess_wait_check ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Combines 'GI.Gio.Objects.Subprocess.subprocessWait' with 'GI.GLib.Functions.spawnCheckExitStatus'.

    /Since: 2.40/
    -}
    subprocessWaitCheck ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessWaitCheck subprocess cancellable = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        onException (do
            _ <- propagateGError $ g_subprocess_wait_check subprocess' maybeCancellable
            touchManagedPtr subprocess
            whenJust cancellable touchManagedPtr
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data SubprocessWaitCheckMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessWaitCheckMethodInfo a signature where
        overloadedMethod _ = subprocessWaitCheck

    #endif

    -- method Subprocess::wait_check_async
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user_data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_subprocess_wait_check_async" g_subprocess_wait_check_async ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    {- |
    Combines 'GI.Gio.Objects.Subprocess.subprocessWaitAsync' with 'GI.GLib.Functions.spawnCheckExitStatus'.

    This is the asynchronous version of 'GI.Gio.Objects.Subprocess.subprocessWaitCheck'.

    /Since: 2.40/
    -}
    subprocessWaitCheckAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> Maybe (b)
        {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the operation is complete -}
        -> m ()
    subprocessWaitCheckAsync subprocess cancellable callback = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        maybeCancellable <- case cancellable of
            Nothing -> return nullPtr
            Just jCancellable -> do
                jCancellable' <- unsafeManagedPtrCastPtr jCancellable
                return jCancellable'
        maybeCallback <- case callback of
            Nothing -> return (castPtrToFunPtr nullPtr)
            Just jCallback -> do
                ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
                poke ptrcallback jCallback'
                return jCallback'
        let userData = nullPtr
        g_subprocess_wait_check_async subprocess' maybeCancellable maybeCallback userData
        touchManagedPtr subprocess
        whenJust cancellable touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data SubprocessWaitCheckAsyncMethodInfo
    instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSubprocess a, Gio.Cancellable.IsCancellable b) => O.MethodInfo SubprocessWaitCheckAsyncMethodInfo a signature where
        overloadedMethod _ = subprocessWaitCheckAsync

    #endif

    -- method Subprocess::wait_check_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_wait_check_finish" g_subprocess_wait_check_finish ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Collects the result of a previous call to
    'GI.Gio.Objects.Subprocess.subprocessWaitCheckAsync'.

    /Since: 2.40/
    -}
    subprocessWaitCheckFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessWaitCheckFinish subprocess result_ = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_subprocess_wait_check_finish subprocess' result_'
            touchManagedPtr subprocess
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data SubprocessWaitCheckFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SubprocessWaitCheckFinishMethodInfo a signature where
        overloadedMethod _ = subprocessWaitCheckFinish

    #endif

    -- method Subprocess::wait_finish
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "subprocess", argType = TInterface (Name {namespace = "Gio", name = "Subprocess"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSubprocess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_subprocess_wait_finish" g_subprocess_wait_finish ::
        Ptr Subprocess ->                       -- subprocess : TInterface (Name {namespace = "Gio", name = "Subprocess"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    {- |
    Collects the result of a previous call to
    'GI.Gio.Objects.Subprocess.subprocessWaitAsync'.

    /Since: 2.40/
    -}
    subprocessWaitFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        {- ^ /@subprocess@/: a 'GI.Gio.Objects.Subprocess.Subprocess' -}
        -> b
        {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
        -> m ()
        {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
    subprocessWaitFinish subprocess result_ = liftIO $ do
        subprocess' <- unsafeManagedPtrCastPtr subprocess
        result_' <- unsafeManagedPtrCastPtr result_
        onException (do
            _ <- propagateGError $ g_subprocess_wait_finish subprocess' result_'
            touchManagedPtr subprocess
            touchManagedPtr result_
            return ()
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data SubprocessWaitFinishMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsSubprocess a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SubprocessWaitFinishMethodInfo a signature where
        overloadedMethod _ = subprocessWaitFinish

    #endif