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

    A data structure representing an IO Channel. The fields should be
    considered private and should only be accessed with the following
    functions.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.GLib.Structs.IOChannel
        (

    -- * Exported types
        IOChannel(..)                           ,
        newZeroIOChannel                        ,
        noIOChannel                             ,

     -- * Methods
    -- ** close #method:close#

    #if ENABLE_OVERLOADING
        IOChannelCloseMethodInfo                ,
    #endif
        iOChannelClose                          ,

    -- ** errorFromErrno #method:errorFromErrno#

        iOChannelErrorFromErrno                 ,

    -- ** errorQuark #method:errorQuark#

        iOChannelErrorQuark                     ,

    -- ** flush #method:flush#

    #if ENABLE_OVERLOADING
        IOChannelFlushMethodInfo                ,
    #endif
        iOChannelFlush                          ,

    -- ** getBufferCondition #method:getBufferCondition#

    #if ENABLE_OVERLOADING
        IOChannelGetBufferConditionMethodInfo   ,
    #endif
        iOChannelGetBufferCondition             ,

    -- ** getBufferSize #method:getBufferSize#

    #if ENABLE_OVERLOADING
        IOChannelGetBufferSizeMethodInfo        ,
    #endif
        iOChannelGetBufferSize                  ,

    -- ** getBuffered #method:getBuffered#

    #if ENABLE_OVERLOADING
        IOChannelGetBufferedMethodInfo          ,
    #endif
        iOChannelGetBuffered                    ,

    -- ** getCloseOnUnref #method:getCloseOnUnref#

    #if ENABLE_OVERLOADING
        IOChannelGetCloseOnUnrefMethodInfo      ,
    #endif
        iOChannelGetCloseOnUnref                ,

    -- ** getEncoding #method:getEncoding#

    #if ENABLE_OVERLOADING
        IOChannelGetEncodingMethodInfo          ,
    #endif
        iOChannelGetEncoding                    ,

    -- ** getFlags #method:getFlags#

    #if ENABLE_OVERLOADING
        IOChannelGetFlagsMethodInfo             ,
    #endif
        iOChannelGetFlags                       ,

    -- ** getLineTerm #method:getLineTerm#

    #if ENABLE_OVERLOADING
        IOChannelGetLineTermMethodInfo          ,
    #endif
        iOChannelGetLineTerm                    ,

    -- ** init #method:init#

    #if ENABLE_OVERLOADING
        IOChannelInitMethodInfo                 ,
    #endif
        iOChannelInit                           ,

    -- ** newFile #method:newFile#

        iOChannelNewFile                        ,

    -- ** read #method:read#

    #if ENABLE_OVERLOADING
        IOChannelReadMethodInfo                 ,
    #endif
        iOChannelRead                           ,

    -- ** readChars #method:readChars#

    #if ENABLE_OVERLOADING
        IOChannelReadCharsMethodInfo            ,
    #endif
        iOChannelReadChars                      ,

    -- ** readLine #method:readLine#

    #if ENABLE_OVERLOADING
        IOChannelReadLineMethodInfo             ,
    #endif
        iOChannelReadLine                       ,

    -- ** readToEnd #method:readToEnd#

    #if ENABLE_OVERLOADING
        IOChannelReadToEndMethodInfo            ,
    #endif
        iOChannelReadToEnd                      ,

    -- ** readUnichar #method:readUnichar#

    #if ENABLE_OVERLOADING
        IOChannelReadUnicharMethodInfo          ,
    #endif
        iOChannelReadUnichar                    ,

    -- ** ref #method:ref#

    #if ENABLE_OVERLOADING
        IOChannelRefMethodInfo                  ,
    #endif
        iOChannelRef                            ,

    -- ** seek #method:seek#

    #if ENABLE_OVERLOADING
        IOChannelSeekMethodInfo                 ,
    #endif
        iOChannelSeek                           ,

    -- ** seekPosition #method:seekPosition#

    #if ENABLE_OVERLOADING
        IOChannelSeekPositionMethodInfo         ,
    #endif
        iOChannelSeekPosition                   ,

    -- ** setBufferSize #method:setBufferSize#

    #if ENABLE_OVERLOADING
        IOChannelSetBufferSizeMethodInfo        ,
    #endif
        iOChannelSetBufferSize                  ,

    -- ** setBuffered #method:setBuffered#

    #if ENABLE_OVERLOADING
        IOChannelSetBufferedMethodInfo          ,
    #endif
        iOChannelSetBuffered                    ,

    -- ** setCloseOnUnref #method:setCloseOnUnref#

    #if ENABLE_OVERLOADING
        IOChannelSetCloseOnUnrefMethodInfo      ,
    #endif
        iOChannelSetCloseOnUnref                ,

    -- ** setEncoding #method:setEncoding#

    #if ENABLE_OVERLOADING
        IOChannelSetEncodingMethodInfo          ,
    #endif
        iOChannelSetEncoding                    ,

    -- ** setFlags #method:setFlags#

    #if ENABLE_OVERLOADING
        IOChannelSetFlagsMethodInfo             ,
    #endif
        iOChannelSetFlags                       ,

    -- ** setLineTerm #method:setLineTerm#

    #if ENABLE_OVERLOADING
        IOChannelSetLineTermMethodInfo          ,
    #endif
        iOChannelSetLineTerm                    ,

    -- ** shutdown #method:shutdown#

    #if ENABLE_OVERLOADING
        IOChannelShutdownMethodInfo             ,
    #endif
        iOChannelShutdown                       ,

    -- ** unixGetFd #method:unixGetFd#

    #if ENABLE_OVERLOADING
        IOChannelUnixGetFdMethodInfo            ,
    #endif
        iOChannelUnixGetFd                      ,

    -- ** unixNew #method:unixNew#

        iOChannelUnixNew                        ,

    -- ** unref #method:unref#

    #if ENABLE_OVERLOADING
        IOChannelUnrefMethodInfo                ,
    #endif
        iOChannelUnref                          ,

    -- ** write #method:write#

    #if ENABLE_OVERLOADING
        IOChannelWriteMethodInfo                ,
    #endif
        iOChannelWrite                          ,

    -- ** writeChars #method:writeChars#

    #if ENABLE_OVERLOADING
        IOChannelWriteCharsMethodInfo           ,
    #endif
        iOChannelWriteChars                     ,

    -- ** writeUnichar #method:writeUnichar#

    #if ENABLE_OVERLOADING
        IOChannelWriteUnicharMethodInfo         ,
    #endif
        iOChannelWriteUnichar                   ,

        ) 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 {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
    import {-# SOURCE #-} qualified GI.GLib.Flags as GLib.Flags

    -- | Memory-managed wrapper type.
    newtype IOChannel = IOChannel (ManagedPtr IOChannel)
    foreign import ccall "g_io_channel_get_type" c_g_io_channel_get_type ::
        IO GType

    instance BoxedObject IOChannel where
        boxedType _ = c_g_io_channel_get_type

    -- | Construct a `IOChannel` struct initialized to zero.
    newZeroIOChannel :: MonadIO m => m IOChannel
    newZeroIOChannel = liftIO $ callocBoxedBytes 136 >>= wrapBoxed IOChannel

    instance tag ~ 'AttrSet => Constructible IOChannel tag where
        new _ attrs = do
            o <- newZeroIOChannel
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `IOChannel`.
    noIOChannel :: Maybe IOChannel
    noIOChannel = Nothing

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList IOChannel
    type instance O.AttributeList IOChannel = IOChannelAttributeList
    type IOChannelAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    -- method IOChannel::new_file
    -- method type : Constructor
    -- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A string containing the name of a file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "One of \"r\", \"w\", \"a\", \"r+\", \"w+\", \"a+\". These have\n       the same meaning as in fopen()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannel"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_new_file" g_io_channel_new_file ::
        CString ->                              -- filename : TBasicType TFileName
        CString ->                              -- mode : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr IOChannel)

    {- |
    Open a file /@filename@/ as a 'GI.GLib.Structs.IOChannel.IOChannel' using mode /@mode@/. This
    channel will be closed when the last reference to it is dropped,
    so there is no need to call 'GI.GLib.Structs.IOChannel.iOChannelClose' (though doing
    so will not cause problems, as long as no attempt is made to
    access the channel after it is closed).
    -}
    iOChannelNewFile ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        [Char]
        {- ^ /@filename@/: A string containing the name of a file -}
        -> T.Text
        {- ^ /@mode@/: One of \"r\", \"w\", \"a\", \"r+\", \"w+\", \"a+\". These have
           the same meaning as in @/fopen()/@ -}
        -> m IOChannel
        {- ^ __Returns:__ A 'GI.GLib.Structs.IOChannel.IOChannel' on success, 'Nothing' on failure. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelNewFile filename mode = liftIO $ do
        filename' <- stringToCString filename
        mode' <- textToCString mode
        onException (do
            result <- propagateGError $ g_io_channel_new_file filename' mode'
            checkUnexpectedReturnNULL "iOChannelNewFile" result
            result' <- (wrapBoxed IOChannel) result
            freeMem filename'
            freeMem mode'
            return result'
         ) (do
            freeMem filename'
            freeMem mode'
         )

    #if ENABLE_OVERLOADING
    #endif

    -- method IOChannel::unix_new
    -- method type : Constructor
    -- Args : [Arg {argCName = "fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file descriptor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannel"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_unix_new" g_io_channel_unix_new ::
        Int32 ->                                -- fd : TBasicType TInt
        IO (Ptr IOChannel)

    {- |
    Creates a new 'GI.GLib.Structs.IOChannel.IOChannel' given a file descriptor. On UNIX systems
    this works for plain files, pipes, and sockets.

    The returned 'GI.GLib.Structs.IOChannel.IOChannel' has a reference count of 1.

    The default encoding for 'GI.GLib.Structs.IOChannel.IOChannel' is UTF-8. If your application
    is reading output from a command using via pipe, you may need to set
    the encoding to the encoding of the current locale (see
    'GI.GLib.Functions.getCharset') with the 'GI.GLib.Structs.IOChannel.iOChannelSetEncoding' function.
    By default, the fd passed will not be closed when the final reference
    to the 'GI.GLib.Structs.IOChannel.IOChannel' data structure is dropped.

    If you want to read raw binary data without interpretation, then
    call the 'GI.GLib.Structs.IOChannel.iOChannelSetEncoding' function with 'Nothing' for the
    encoding argument.

    This function is available in GLib on Windows, too, but you should
    avoid using it on Windows. The domain of file descriptors and
    sockets overlap. There is no way for GLib to know which one you mean
    in case the argument you pass to this function happens to be both a
    valid file descriptor and socket. If that happens a warning is
    issued, and GLib assumes that it is the file descriptor you mean.
    -}
    iOChannelUnixNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Int32
        {- ^ /@fd@/: a file descriptor. -}
        -> m IOChannel
        {- ^ __Returns:__ a new 'GI.GLib.Structs.IOChannel.IOChannel'. -}
    iOChannelUnixNew fd = liftIO $ do
        result <- g_io_channel_unix_new fd
        checkUnexpectedReturnNULL "iOChannelUnixNew" result
        result' <- (wrapBoxed IOChannel) result
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method IOChannel::close
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_close" g_io_channel_close ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO ()

    {-# DEPRECATED iOChannelClose ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelShutdown' instead."] #-}
    {- |
    Close an IO channel. Any pending data to be written will be
    flushed, ignoring errors. The channel will not be freed until the
    last reference is dropped using 'GI.GLib.Structs.IOChannel.iOChannelUnref'.
    -}
    iOChannelClose ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: A 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ()
    iOChannelClose channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        g_io_channel_close channel'
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelCloseMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelCloseMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelClose

    #endif

    -- method IOChannel::flush
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_flush" g_io_channel_flush ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Flushes the write buffer for the GIOChannel.
    -}
    iOChannelFlush ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ the status of the operation: One of
      @/G_IO_STATUS_NORMAL/@, @/G_IO_STATUS_AGAIN/@, or
      @/G_IO_STATUS_ERROR/@. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelFlush channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        onException (do
            result <- propagateGError $ g_io_channel_flush channel'
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOChannelFlushMethodInfo
    instance (signature ~ (m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelFlushMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelFlush

    #endif

    -- method IOChannel::get_buffer_condition
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOCondition"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_get_buffer_condition" g_io_channel_get_buffer_condition ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO CUInt

    {- |
    This function returns a 'GI.GLib.Flags.IOCondition' depending on whether there
    is data to be read\/space to write data in the internal buffers in
    the 'GI.GLib.Structs.IOChannel.IOChannel'. Only the flags 'GI.GLib.Flags.IOConditionIn' and 'GI.GLib.Flags.IOConditionOut' may be set.
    -}
    iOChannelGetBufferCondition ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: A 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m [GLib.Flags.IOCondition]
        {- ^ __Returns:__ A 'GI.GLib.Flags.IOCondition' -}
    iOChannelGetBufferCondition channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_buffer_condition channel'
        let result' = wordToGFlags result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetBufferConditionMethodInfo
    instance (signature ~ (m [GLib.Flags.IOCondition]), MonadIO m) => O.MethodInfo IOChannelGetBufferConditionMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetBufferCondition

    #endif

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

    foreign import ccall "g_io_channel_get_buffer_size" g_io_channel_get_buffer_size ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO Word64

    {- |
    Gets the buffer size.
    -}
    iOChannelGetBufferSize ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m Word64
        {- ^ __Returns:__ the size of the buffer. -}
    iOChannelGetBufferSize channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_buffer_size channel'
        touchManagedPtr channel
        return result

    #if ENABLE_OVERLOADING
    data IOChannelGetBufferSizeMethodInfo
    instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo IOChannelGetBufferSizeMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetBufferSize

    #endif

    -- method IOChannel::get_buffered
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", 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_io_channel_get_buffered" g_io_channel_get_buffered ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO CInt

    {- |
    Returns whether /@channel@/ is buffered.
    -}
    iOChannelGetBuffered ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the /@channel@/ is buffered. -}
    iOChannelGetBuffered channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_buffered channel'
        let result' = (/= 0) result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetBufferedMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IOChannelGetBufferedMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetBuffered

    #endif

    -- method IOChannel::get_close_on_unref
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel.", 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_io_channel_get_close_on_unref" g_io_channel_get_close_on_unref ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO CInt

    {- |
    Returns whether the file\/socket\/whatever associated with /@channel@/
    will be closed when /@channel@/ receives its final unref and is
    destroyed. The default value of this is 'True' for channels created
    by g_io_channel_new_file (), and 'False' for all other channels.
    -}
    iOChannelGetCloseOnUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel'. -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the channel will be closed, 'False' otherwise. -}
    iOChannelGetCloseOnUnref channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_close_on_unref channel'
        let result' = (/= 0) result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetCloseOnUnrefMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IOChannelGetCloseOnUnrefMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetCloseOnUnref

    #endif

    -- method IOChannel::get_encoding
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", 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_io_channel_get_encoding" g_io_channel_get_encoding ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO CString

    {- |
    Gets the encoding for the input\/output of the channel.
    The internal encoding is always UTF-8. The encoding 'Nothing'
    makes the channel safe for binary data.
    -}
    iOChannelGetEncoding ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m T.Text
        {- ^ __Returns:__ A string containing the encoding, this string is
      owned by GLib and must not be freed. -}
    iOChannelGetEncoding channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_encoding channel'
        checkUnexpectedReturnNULL "iOChannelGetEncoding" result
        result' <- cstringToText result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetEncodingMethodInfo
    instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo IOChannelGetEncodingMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetEncoding

    #endif

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

    foreign import ccall "g_io_channel_get_flags" g_io_channel_get_flags ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO CUInt

    {- |
    Gets the current flags for a 'GI.GLib.Structs.IOChannel.IOChannel', including read-only
    flags such as 'GI.GLib.Flags.IOFlagsIsReadable'.

    The values of the flags 'GI.GLib.Flags.IOFlagsIsReadable' and 'GI.GLib.Flags.IOFlagsIsWritable'
    are cached for internal use by the channel when it is created.
    If they should change at some later point (e.g. partial shutdown
    of a socket with the UNIX @/shutdown()/@ function), the user
    should immediately call 'GI.GLib.Structs.IOChannel.iOChannelGetFlags' to update
    the internal values of these flags.
    -}
    iOChannelGetFlags ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m [GLib.Flags.IOFlags]
        {- ^ __Returns:__ the flags which are set on the channel -}
    iOChannelGetFlags channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_flags channel'
        let result' = wordToGFlags result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetFlagsMethodInfo
    instance (signature ~ (m [GLib.Flags.IOFlags]), MonadIO m) => O.MethodInfo IOChannelGetFlagsMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetFlags

    #endif

    -- method IOChannel::get_line_term
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to return the length of the line terminator", 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_io_channel_get_line_term" g_io_channel_get_line_term ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Int32 ->                                -- length : TBasicType TInt
        IO CString

    {- |
    This returns the string that 'GI.GLib.Structs.IOChannel.IOChannel' uses to determine
    where in the file a line break occurs. A value of 'Nothing'
    indicates autodetection.
    -}
    iOChannelGetLineTerm ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Int32
        {- ^ /@length@/: a location to return the length of the line terminator -}
        -> m T.Text
        {- ^ __Returns:__ The line termination string. This value
      is owned by GLib and must not be freed. -}
    iOChannelGetLineTerm channel length_ = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_get_line_term channel' length_
        checkUnexpectedReturnNULL "iOChannelGetLineTerm" result
        result' <- cstringToText result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelGetLineTermMethodInfo
    instance (signature ~ (Int32 -> m T.Text), MonadIO m) => O.MethodInfo IOChannelGetLineTermMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelGetLineTerm

    #endif

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

    foreign import ccall "g_io_channel_init" g_io_channel_init ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO ()

    {- |
    Initializes a 'GI.GLib.Structs.IOChannel.IOChannel' struct.

    This is called by each of the above functions when creating a
    'GI.GLib.Structs.IOChannel.IOChannel', and so is not often needed by the application
    programmer (unless you are creating a new type of 'GI.GLib.Structs.IOChannel.IOChannel').
    -}
    iOChannelInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ()
    iOChannelInit channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        g_io_channel_init channel'
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelInitMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelInitMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelInit

    #endif

    -- method IOChannel::read
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to read the data into (which should be at least\n      count bytes long)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to read from the #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "returns the number of bytes actually read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_read" g_io_channel_read ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CString ->                              -- buf : TBasicType TUTF8
        Word64 ->                               -- count : TBasicType TUInt64
        Word64 ->                               -- bytes_read : TBasicType TUInt64
        IO CUInt

    {-# DEPRECATED iOChannelRead ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelReadChars' instead."] #-}
    {- |
    Reads data from a 'GI.GLib.Structs.IOChannel.IOChannel'.
    -}
    iOChannelRead ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> T.Text
        {- ^ /@buf@/: a buffer to read the data into (which should be at least
          count bytes long) -}
        -> Word64
        {- ^ /@count@/: the number of bytes to read from the 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Word64
        {- ^ /@bytesRead@/: returns the number of bytes actually read -}
        -> m GLib.Enums.IOError
        {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -}
    iOChannelRead channel buf count bytesRead = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        buf' <- textToCString buf
        result <- g_io_channel_read channel' buf' count bytesRead
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr channel
        freeMem buf'
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelReadMethodInfo
    instance (signature ~ (T.Text -> Word64 -> Word64 -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelReadMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelRead

    #endif

    -- method IOChannel::read_chars
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n    a buffer to read data into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. Note that the buffer may not be\n    complelely filled even if there is data in the buffer if the\n    remaining data is not a complete character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of bytes read. This may be\n    zero even on success if count < 6 and the channel's encoding\n    is non-%NULL. This indicates that the next UTF-8 character is\n    too wide for the buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. Note that the buffer may not be\n    complelely filled even if there is data in the buffer if the\n    remaining data is not a complete character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_read_chars" g_io_channel_read_chars ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr Word8 ->                            -- buf : TCArray False (-1) 2 (TBasicType TUInt8)
        Word64 ->                               -- count : TBasicType TUInt64
        Ptr Word64 ->                           -- bytes_read : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Replacement for 'GI.GLib.Structs.IOChannel.iOChannelRead' with the new API.
    -}
    iOChannelReadChars ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> ByteString
        {- ^ /@buf@/:
        a buffer to read data into -}
        -> m ((GLib.Enums.IOStatus, ByteString, Word64))
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelReadChars channel buf = liftIO $ do
        let count = fromIntegral $ B.length buf
        channel' <- unsafeManagedPtrGetPtr channel
        buf' <- packByteString buf
        bytesRead <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_io_channel_read_chars channel' buf' count bytesRead
            let result' = (toEnum . fromIntegral) result
            buf'' <- (unpackByteStringWithLength count) buf'
            bytesRead' <- peek bytesRead
            touchManagedPtr channel
            freeMem bytesRead
            return (result', buf'', bytesRead')
         ) (do
            freeMem buf'
            freeMem bytesRead
         )

    #if ENABLE_OVERLOADING
    data IOChannelReadCharsMethodInfo
    instance (signature ~ (ByteString -> m ((GLib.Enums.IOStatus, ByteString, Word64))), MonadIO m) => O.MethodInfo IOChannelReadCharsMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelReadChars

    #endif

    -- method IOChannel::read_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str_return", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The line read from the #GIOChannel, including the\n             line terminator. This data should be freed with g_free()\n             when no longer needed. This is a nul-terminated string.\n             If a @length of zero is returned, this will be %NULL instead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the read data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "terminator_pos", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store position of line terminator, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_read_line" g_io_channel_read_line ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr CString ->                          -- str_return : TBasicType TUTF8
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr Word64 ->                           -- terminator_pos : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Reads a line, including the terminating character(s),
    from a 'GI.GLib.Structs.IOChannel.IOChannel' into a newly-allocated string.
    /@strReturn@/ will contain allocated memory if the return
    is 'GI.GLib.Enums.IOStatusNormal'.
    -}
    iOChannelReadLine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ((GLib.Enums.IOStatus, T.Text, Word64, Word64))
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelReadLine channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        strReturn <- allocMem :: IO (Ptr CString)
        length_ <- allocMem :: IO (Ptr Word64)
        terminatorPos <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_io_channel_read_line channel' strReturn length_ terminatorPos
            let result' = (toEnum . fromIntegral) result
            strReturn' <- peek strReturn
            strReturn'' <- cstringToText strReturn'
            freeMem strReturn'
            length_' <- peek length_
            terminatorPos' <- peek terminatorPos
            touchManagedPtr channel
            freeMem strReturn
            freeMem length_
            freeMem terminatorPos
            return (result', strReturn'', length_', terminatorPos')
         ) (do
            freeMem strReturn
            freeMem length_
            freeMem terminatorPos
         )

    #if ENABLE_OVERLOADING
    data IOChannelReadLineMethodInfo
    instance (signature ~ (m ((GLib.Enums.IOStatus, T.Text, Word64, Word64))), MonadIO m) => O.MethodInfo IOChannelReadLineMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelReadLine

    #endif

    -- method IOChannel::read_to_end
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str_return", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Location to\n             store a pointer to a string holding the remaining data in the\n             #GIOChannel. This data should be freed with g_free() when no\n             longer needed. This data is terminated by an extra nul\n             character, but there may be other nuls in the intervening data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_read_to_end" g_io_channel_read_to_end ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr (Ptr Word8) ->                      -- str_return : TCArray False (-1) 2 (TBasicType TUInt8)
        Ptr Word64 ->                           -- length : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Reads all the remaining data from the file.
    -}
    iOChannelReadToEnd ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ((GLib.Enums.IOStatus, ByteString))
        {- ^ __Returns:__ 'GI.GLib.Enums.IOStatusNormal' on success.
        This function never returns 'GI.GLib.Enums.IOStatusEof'. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelReadToEnd channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        strReturn <- allocMem :: IO (Ptr (Ptr Word8))
        length_ <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_io_channel_read_to_end channel' strReturn length_
            length_' <- peek length_
            let result' = (toEnum . fromIntegral) result
            strReturn' <- peek strReturn
            strReturn'' <- (unpackByteStringWithLength length_') strReturn'
            freeMem strReturn'
            touchManagedPtr channel
            freeMem strReturn
            freeMem length_
            return (result', strReturn'')
         ) (do
            freeMem strReturn
            freeMem length_
         )

    #if ENABLE_OVERLOADING
    data IOChannelReadToEndMethodInfo
    instance (signature ~ (m ((GLib.Enums.IOStatus, ByteString))), MonadIO m) => O.MethodInfo IOChannelReadToEndMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelReadToEnd

    #endif

    -- method IOChannel::read_unichar
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "thechar", argType = TBasicType TUniChar, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to return a character", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_read_unichar" g_io_channel_read_unichar ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr CInt ->                             -- thechar : TBasicType TUniChar
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Reads a Unicode character from /@channel@/.
    This function cannot be called on a channel with 'Nothing' encoding.
    -}
    iOChannelReadUnichar ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ((GLib.Enums.IOStatus, Char))
        {- ^ __Returns:__ a 'GI.GLib.Enums.IOStatus' /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelReadUnichar channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        thechar <- allocMem :: IO (Ptr CInt)
        onException (do
            result <- propagateGError $ g_io_channel_read_unichar channel' thechar
            let result' = (toEnum . fromIntegral) result
            thechar' <- peek thechar
            let thechar'' = (chr . fromIntegral) thechar'
            touchManagedPtr channel
            freeMem thechar
            return (result', thechar'')
         ) (do
            freeMem thechar
         )

    #if ENABLE_OVERLOADING
    data IOChannelReadUnicharMethodInfo
    instance (signature ~ (m ((GLib.Enums.IOStatus, Char))), MonadIO m) => O.MethodInfo IOChannelReadUnicharMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelReadUnichar

    #endif

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

    foreign import ccall "g_io_channel_ref" g_io_channel_ref ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO (Ptr IOChannel)

    {- |
    Increments the reference count of a 'GI.GLib.Structs.IOChannel.IOChannel'.
    -}
    iOChannelRef ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m IOChannel
        {- ^ __Returns:__ the /@channel@/ that was passed in (since 2.6) -}
    iOChannelRef channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_ref channel'
        checkUnexpectedReturnNULL "iOChannelRef" result
        result' <- (wrapBoxed IOChannel) result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelRefMethodInfo
    instance (signature ~ (m IOChannel), MonadIO m) => O.MethodInfo IOChannelRefMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelRef

    #endif

    -- method IOChannel::seek
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an offset, in bytes, which is added to the position specified\n         by @type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GLib", name = "SeekType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position in the file, which can be %G_SEEK_CUR (the current\n       position), %G_SEEK_SET (the start of the file), or %G_SEEK_END\n       (the end of the file)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_seek" g_io_channel_seek ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Int64 ->                                -- offset : TBasicType TInt64
        CUInt ->                                -- type : TInterface (Name {namespace = "GLib", name = "SeekType"})
        IO CUInt

    {-# DEPRECATED iOChannelSeek ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelSeekPosition' instead."] #-}
    {- |
    Sets the current position in the 'GI.GLib.Structs.IOChannel.IOChannel', similar to the standard
    library function @/fseek()/@.
    -}
    iOChannelSeek ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Int64
        {- ^ /@offset@/: an offset, in bytes, which is added to the position specified
             by /@type@/ -}
        -> GLib.Enums.SeekType
        {- ^ /@type@/: the position in the file, which can be 'GI.GLib.Enums.SeekTypeCur' (the current
           position), 'GI.GLib.Enums.SeekTypeSet' (the start of the file), or 'GI.GLib.Enums.SeekTypeEnd'
           (the end of the file) -}
        -> m GLib.Enums.IOError
        {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -}
    iOChannelSeek channel offset type_ = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let type_' = (fromIntegral . fromEnum) type_
        result <- g_io_channel_seek channel' offset type_'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr channel
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelSeekMethodInfo
    instance (signature ~ (Int64 -> GLib.Enums.SeekType -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelSeekMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSeek

    #endif

    -- method IOChannel::seek_position
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The offset in bytes from the position specified by @type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GLib", name = "SeekType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSeekType. The type %G_SEEK_CUR is only allowed in those\n                     cases where a call to g_io_channel_set_encoding ()\n                     is allowed. See the documentation for\n                     g_io_channel_set_encoding () for details.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_seek_position" g_io_channel_seek_position ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Int64 ->                                -- offset : TBasicType TInt64
        CUInt ->                                -- type : TInterface (Name {namespace = "GLib", name = "SeekType"})
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Replacement for 'GI.GLib.Structs.IOChannel.iOChannelSeek' with the new API.
    -}
    iOChannelSeekPosition ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Int64
        {- ^ /@offset@/: The offset in bytes from the position specified by /@type@/ -}
        -> GLib.Enums.SeekType
        {- ^ /@type@/: a 'GI.GLib.Enums.SeekType'. The type 'GI.GLib.Enums.SeekTypeCur' is only allowed in those
                         cases where a call to g_io_channel_set_encoding ()
                         is allowed. See the documentation for
                         g_io_channel_set_encoding () for details. -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelSeekPosition channel offset type_ = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let type_' = (fromIntegral . fromEnum) type_
        onException (do
            result <- propagateGError $ g_io_channel_seek_position channel' offset type_'
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOChannelSeekPositionMethodInfo
    instance (signature ~ (Int64 -> GLib.Enums.SeekType -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSeekPositionMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSeekPosition

    #endif

    -- method IOChannel::set_buffer_size
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer, or 0 to let GLib pick a good size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_set_buffer_size" g_io_channel_set_buffer_size ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Word64 ->                               -- size : TBasicType TUInt64
        IO ()

    {- |
    Sets the buffer size.
    -}
    iOChannelSetBufferSize ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Word64
        {- ^ /@size@/: the size of the buffer, or 0 to let GLib pick a good size -}
        -> m ()
    iOChannelSetBufferSize channel size = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        g_io_channel_set_buffer_size channel' size
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelSetBufferSizeMethodInfo
    instance (signature ~ (Word64 -> m ()), MonadIO m) => O.MethodInfo IOChannelSetBufferSizeMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetBufferSize

    #endif

    -- method IOChannel::set_buffered
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffered", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to set the channel buffered or unbuffered", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_set_buffered" g_io_channel_set_buffered ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CInt ->                                 -- buffered : TBasicType TBoolean
        IO ()

    {- |
    The buffering state can only be set if the channel\'s encoding
    is 'Nothing'. For any other encoding, the channel must be buffered.

    A buffered channel can only be set unbuffered if the channel\'s
    internal buffers have been flushed. Newly created channels or
    channels which have returned 'GI.GLib.Enums.IOStatusEof'
    not require such a flush. For write-only channels, a call to
    g_io_channel_flush () is sufficient. For all other channels,
    the buffers may be flushed by a call to g_io_channel_seek_position ().
    This includes the possibility of seeking with seek type 'GI.GLib.Enums.SeekTypeCur'
    and an offset of zero. Note that this means that socket-based
    channels cannot be set unbuffered once they have had data
    read from them.

    On unbuffered channels, it is safe to mix read and write
    calls from the new and old APIs, if this is necessary for
    maintaining old code.

    The default state of the channel is buffered.
    -}
    iOChannelSetBuffered ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Bool
        {- ^ /@buffered@/: whether to set the channel buffered or unbuffered -}
        -> m ()
    iOChannelSetBuffered channel buffered = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let buffered' = (fromIntegral . fromEnum) buffered
        g_io_channel_set_buffered channel' buffered'
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelSetBufferedMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo IOChannelSetBufferedMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetBuffered

    #endif

    -- method IOChannel::set_close_on_unref
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "do_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to close the channel on the final unref of\n           the GIOChannel data structure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_set_close_on_unref" g_io_channel_set_close_on_unref ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CInt ->                                 -- do_close : TBasicType TBoolean
        IO ()

    {- |
    Whether to close the channel on the final unref of the 'GI.GLib.Structs.IOChannel.IOChannel'
    data structure. The default value of this is 'True' for channels
    created by g_io_channel_new_file (), and 'False' for all other channels.

    Setting this flag to 'True' for a channel you have already closed
    can cause problems when the final reference to the 'GI.GLib.Structs.IOChannel.IOChannel' is dropped.
    -}
    iOChannelSetCloseOnUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Bool
        {- ^ /@doClose@/: Whether to close the channel on the final unref of
               the GIOChannel data structure. -}
        -> m ()
    iOChannelSetCloseOnUnref channel doClose = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let doClose' = (fromIntegral . fromEnum) doClose
        g_io_channel_set_close_on_unref channel' doClose'
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelSetCloseOnUnrefMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo IOChannelSetCloseOnUnrefMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetCloseOnUnref

    #endif

    -- method IOChannel::set_encoding
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the encoding type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_set_encoding" g_io_channel_set_encoding ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CString ->                              -- encoding : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Sets the encoding for the input\/output of the channel.
    The internal encoding is always UTF-8. The default encoding
    for the external file is UTF-8.

    The encoding 'Nothing' is safe to use with binary data.

    The encoding can only be set if one of the following conditions
    is true:

    * The channel was just created, and has not been written to or read from yet.
    * The channel is write-only.
    * The channel is a file, and the file pointer was just repositioned
    by a call to 'GI.GLib.Structs.IOChannel.iOChannelSeekPosition'. (This flushes all the
    internal buffers.)
    * The current encoding is 'Nothing' or UTF-8.
    * One of the (new API) read functions has just returned 'GI.GLib.Enums.IOStatusEof'
    (or, in the case of 'GI.GLib.Structs.IOChannel.iOChannelReadToEnd', 'GI.GLib.Enums.IOStatusNormal').
    *  One of the functions 'GI.GLib.Structs.IOChannel.iOChannelReadChars' or
     'GI.GLib.Structs.IOChannel.iOChannelReadUnichar' has returned 'GI.GLib.Enums.IOStatusAgain' or
     'GI.GLib.Enums.IOStatusError'. This may be useful in the case of
     'GI.GLib.Enums.ConvertErrorIllegalSequence'.
     Returning one of these statuses from 'GI.GLib.Structs.IOChannel.iOChannelReadLine',
     @/g_io_channel_read_line_string()/@, or 'GI.GLib.Structs.IOChannel.iOChannelReadToEnd'
     does not guarantee that the encoding can be changed.

    Channels which do not meet one of the above conditions cannot call
    'GI.GLib.Structs.IOChannel.iOChannelSeekPosition' with an offset of 'GI.GLib.Enums.SeekTypeCur', and, if
    they are \"seekable\", cannot call 'GI.GLib.Structs.IOChannel.iOChannelWriteChars' after
    calling one of the API \"read\" functions.
    -}
    iOChannelSetEncoding ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Maybe (T.Text)
        {- ^ /@encoding@/: the encoding type -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ 'GI.GLib.Enums.IOStatusNormal' if the encoding was successfully set /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelSetEncoding channel encoding = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        maybeEncoding <- case encoding of
            Nothing -> return nullPtr
            Just jEncoding -> do
                jEncoding' <- textToCString jEncoding
                return jEncoding'
        onException (do
            result <- propagateGError $ g_io_channel_set_encoding channel' maybeEncoding
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            freeMem maybeEncoding
            return result'
         ) (do
            freeMem maybeEncoding
         )

    #if ENABLE_OVERLOADING
    data IOChannelSetEncodingMethodInfo
    instance (signature ~ (Maybe (T.Text) -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSetEncodingMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetEncoding

    #endif

    -- method IOChannel::set_flags
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GLib", name = "IOFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the flags to set on the IO channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_set_flags" g_io_channel_set_flags ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CUInt ->                                -- flags : TInterface (Name {namespace = "GLib", name = "IOFlags"})
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Sets the (writeable) flags in /@channel@/ to (/@flags@/ & 'GI.GLib.Flags.IOFlagsSetMask').
    -}
    iOChannelSetFlags ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> [GLib.Flags.IOFlags]
        {- ^ /@flags@/: the flags to set on the IO channel -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelSetFlags channel flags = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let flags' = gflagsToWord flags
        onException (do
            result <- propagateGError $ g_io_channel_set_flags channel' flags'
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOChannelSetFlagsMethodInfo
    instance (signature ~ ([GLib.Flags.IOFlags] -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSetFlagsMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetFlags

    #endif

    -- method IOChannel::set_line_term
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_term", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The line termination string. Use %NULL for\n            autodetect.  Autodetection breaks on \"\\n\", \"\\r\\n\", \"\\r\", \"\\0\",\n            and the Unicode paragraph separator. Autodetection should not be\n            used for anything other than file-based channels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the termination string. If -1 is passed, the\n         string is assumed to be nul-terminated. This option allows\n         termination strings with embedded nuls.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_set_line_term" g_io_channel_set_line_term ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CString ->                              -- line_term : TBasicType TUTF8
        Int32 ->                                -- length : TBasicType TInt
        IO ()

    {- |
    This sets the string that 'GI.GLib.Structs.IOChannel.IOChannel' uses to determine
    where in the file a line break occurs.
    -}
    iOChannelSetLineTerm ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Maybe (T.Text)
        {- ^ /@lineTerm@/: The line termination string. Use 'Nothing' for
                autodetect.  Autodetection breaks on \"\\n\", \"\\r\\n\", \"\\r\", \"\\0\",
                and the Unicode paragraph separator. Autodetection should not be
                used for anything other than file-based channels. -}
        -> Int32
        {- ^ /@length@/: The length of the termination string. If -1 is passed, the
             string is assumed to be nul-terminated. This option allows
             termination strings with embedded nuls. -}
        -> m ()
    iOChannelSetLineTerm channel lineTerm length_ = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        maybeLineTerm <- case lineTerm of
            Nothing -> return nullPtr
            Just jLineTerm -> do
                jLineTerm' <- textToCString jLineTerm
                return jLineTerm'
        g_io_channel_set_line_term channel' maybeLineTerm length_
        touchManagedPtr channel
        freeMem maybeLineTerm
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelSetLineTermMethodInfo
    instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m) => O.MethodInfo IOChannelSetLineTermMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelSetLineTerm

    #endif

    -- method IOChannel::shutdown
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, flush pending", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_shutdown" g_io_channel_shutdown ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CInt ->                                 -- flush : TBasicType TBoolean
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Close an IO channel. Any pending data to be written will be
    flushed if /@flush@/ is 'True'. The channel will not be freed until the
    last reference is dropped using 'GI.GLib.Structs.IOChannel.iOChannelUnref'.
    -}
    iOChannelShutdown ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Bool
        {- ^ /@flush@/: if 'True', flush pending -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelShutdown channel flush = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let flush' = (fromIntegral . fromEnum) flush
        onException (do
            result <- propagateGError $ g_io_channel_shutdown channel' flush'
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOChannelShutdownMethodInfo
    instance (signature ~ (Bool -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelShutdownMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelShutdown

    #endif

    -- method IOChannel::unix_get_fd
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel, created with g_io_channel_unix_new().", 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_io_channel_unix_get_fd" g_io_channel_unix_get_fd ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO Int32

    {- |
    Returns the file descriptor of the 'GI.GLib.Structs.IOChannel.IOChannel'.

    On Windows this function returns the file descriptor or socket of
    the 'GI.GLib.Structs.IOChannel.IOChannel'.
    -}
    iOChannelUnixGetFd ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel', created with 'GI.GLib.Structs.IOChannel.iOChannelUnixNew'. -}
        -> m Int32
        {- ^ __Returns:__ the file descriptor of the 'GI.GLib.Structs.IOChannel.IOChannel'. -}
    iOChannelUnixGetFd channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        result <- g_io_channel_unix_get_fd channel'
        touchManagedPtr channel
        return result

    #if ENABLE_OVERLOADING
    data IOChannelUnixGetFdMethodInfo
    instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo IOChannelUnixGetFdMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelUnixGetFd

    #endif

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

    foreign import ccall "g_io_channel_unref" g_io_channel_unref ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        IO ()

    {- |
    Decrements the reference count of a 'GI.GLib.Structs.IOChannel.IOChannel'.
    -}
    iOChannelUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> m ()
    iOChannelUnref channel = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        g_io_channel_unref channel'
        touchManagedPtr channel
        return ()

    #if ENABLE_OVERLOADING
    data IOChannelUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelUnrefMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelUnref

    #endif

    -- method IOChannel::write
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes actually written", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_write" g_io_channel_write ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CString ->                              -- buf : TBasicType TUTF8
        Word64 ->                               -- count : TBasicType TUInt64
        Word64 ->                               -- bytes_written : TBasicType TUInt64
        IO CUInt

    {-# DEPRECATED iOChannelWrite ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelWriteChars' instead."] #-}
    {- |
    Writes data to a 'GI.GLib.Structs.IOChannel.IOChannel'.
    -}
    iOChannelWrite ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> T.Text
        {- ^ /@buf@/: the buffer containing the data to write -}
        -> Word64
        {- ^ /@count@/: the number of bytes to write -}
        -> Word64
        {- ^ /@bytesWritten@/: the number of bytes actually written -}
        -> m GLib.Enums.IOError
        {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -}
    iOChannelWrite channel buf count bytesWritten = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        buf' <- textToCString buf
        result <- g_io_channel_write channel' buf' count bytesWritten
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr channel
        freeMem buf'
        return result'

    #if ENABLE_OVERLOADING
    data IOChannelWriteMethodInfo
    instance (signature ~ (T.Text -> Word64 -> Word64 -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelWriteMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelWrite

    #endif

    -- method IOChannel::write_chars
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to write data from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. If -1, the buffer\n        is taken to be a nul-terminated string.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of bytes written. This can be nonzero\n                even if the return value is not %G_IO_STATUS_NORMAL.\n                If the return value is %G_IO_STATUS_NORMAL and the\n                channel is blocking, this will always be equal\n                to @count if @count >= 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_write_chars" g_io_channel_write_chars ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        Ptr Word8 ->                            -- buf : TCArray False (-1) (-1) (TBasicType TUInt8)
        Int64 ->                                -- count : TBasicType TInt64
        Ptr Word64 ->                           -- bytes_written : TBasicType TUInt64
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Replacement for 'GI.GLib.Structs.IOChannel.iOChannelWrite' with the new API.

    On seekable channels with encodings other than 'Nothing' or UTF-8, generic
    mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
    may only be made on a channel from which data has been read in the
    cases described in the documentation for g_io_channel_set_encoding ().
    -}
    iOChannelWriteChars ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Ptr Word8
        {- ^ /@buf@/: a buffer to write data from -}
        -> Int64
        {- ^ /@count@/: the size of the buffer. If -1, the buffer
            is taken to be a nul-terminated string. -}
        -> m ((GLib.Enums.IOStatus, Word64))
        {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelWriteChars channel buf count = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        bytesWritten <- allocMem :: IO (Ptr Word64)
        onException (do
            result <- propagateGError $ g_io_channel_write_chars channel' buf count bytesWritten
            let result' = (toEnum . fromIntegral) result
            bytesWritten' <- peek bytesWritten
            touchManagedPtr channel
            freeMem bytesWritten
            return (result', bytesWritten')
         ) (do
            freeMem bytesWritten
         )

    #if ENABLE_OVERLOADING
    data IOChannelWriteCharsMethodInfo
    instance (signature ~ (Ptr Word8 -> Int64 -> m ((GLib.Enums.IOStatus, Word64))), MonadIO m) => O.MethodInfo IOChannelWriteCharsMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelWriteChars

    #endif

    -- method IOChannel::write_unichar
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "thechar", argType = TBasicType TUniChar, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_io_channel_write_unichar" g_io_channel_write_unichar ::
        Ptr IOChannel ->                        -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"})
        CInt ->                                 -- thechar : TBasicType TUniChar
        Ptr (Ptr GError) ->                     -- error
        IO CUInt

    {- |
    Writes a Unicode character to /@channel@/.
    This function cannot be called on a channel with 'Nothing' encoding.
    -}
    iOChannelWriteUnichar ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        IOChannel
        {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -}
        -> Char
        {- ^ /@thechar@/: a character -}
        -> m GLib.Enums.IOStatus
        {- ^ __Returns:__ a 'GI.GLib.Enums.IOStatus' /(Can throw 'Data.GI.Base.GError.GError')/ -}
    iOChannelWriteUnichar channel thechar = liftIO $ do
        channel' <- unsafeManagedPtrGetPtr channel
        let thechar' = (fromIntegral . ord) thechar
        onException (do
            result <- propagateGError $ g_io_channel_write_unichar channel' thechar'
            let result' = (toEnum . fromIntegral) result
            touchManagedPtr channel
            return result'
         ) (do
            return ()
         )

    #if ENABLE_OVERLOADING
    data IOChannelWriteUnicharMethodInfo
    instance (signature ~ (Char -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelWriteUnicharMethodInfo IOChannel signature where
        overloadedMethod _ = iOChannelWriteUnichar

    #endif

    -- method IOChannel::error_from_errno
    -- method type : MemberFunction
    -- Args : [Arg {argCName = "en", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an `errno` error number, e.g. `EINVAL`", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannelError"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_error_from_errno" g_io_channel_error_from_errno ::
        Int32 ->                                -- en : TBasicType TInt
        IO CUInt

    {- |
    Converts an @errno@ error number to a 'GI.GLib.Enums.IOChannelError'.
    -}
    iOChannelErrorFromErrno ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Int32
        {- ^ /@en@/: an @errno@ error number, e.g. @EINVAL@ -}
        -> m GLib.Enums.IOChannelError
        {- ^ __Returns:__ a 'GI.GLib.Enums.IOChannelError' error number, e.g.
         'GI.GLib.Enums.IOChannelErrorInval'. -}
    iOChannelErrorFromErrno en = liftIO $ do
        result <- g_io_channel_error_from_errno en
        let result' = (toEnum . fromIntegral) result
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method IOChannel::error_quark
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt32)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_io_channel_error_quark" g_io_channel_error_quark ::
        IO Word32

    {- |
    /No description available in the introspection data./
    -}
    iOChannelErrorQuark ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Word32
    iOChannelErrorQuark  = liftIO $ do
        result <- g_io_channel_error_quark
        return result

    #if ENABLE_OVERLOADING
    #endif

    #if ENABLE_OVERLOADING
    type family ResolveIOChannelMethod (t :: Symbol) (o :: *) :: * where
        ResolveIOChannelMethod "close" o = IOChannelCloseMethodInfo
        ResolveIOChannelMethod "flush" o = IOChannelFlushMethodInfo
        ResolveIOChannelMethod "init" o = IOChannelInitMethodInfo
        ResolveIOChannelMethod "read" o = IOChannelReadMethodInfo
        ResolveIOChannelMethod "readChars" o = IOChannelReadCharsMethodInfo
        ResolveIOChannelMethod "readLine" o = IOChannelReadLineMethodInfo
        ResolveIOChannelMethod "readToEnd" o = IOChannelReadToEndMethodInfo
        ResolveIOChannelMethod "readUnichar" o = IOChannelReadUnicharMethodInfo
        ResolveIOChannelMethod "ref" o = IOChannelRefMethodInfo
        ResolveIOChannelMethod "seek" o = IOChannelSeekMethodInfo
        ResolveIOChannelMethod "seekPosition" o = IOChannelSeekPositionMethodInfo
        ResolveIOChannelMethod "shutdown" o = IOChannelShutdownMethodInfo
        ResolveIOChannelMethod "unixGetFd" o = IOChannelUnixGetFdMethodInfo
        ResolveIOChannelMethod "unref" o = IOChannelUnrefMethodInfo
        ResolveIOChannelMethod "write" o = IOChannelWriteMethodInfo
        ResolveIOChannelMethod "writeChars" o = IOChannelWriteCharsMethodInfo
        ResolveIOChannelMethod "writeUnichar" o = IOChannelWriteUnicharMethodInfo
        ResolveIOChannelMethod "getBufferCondition" o = IOChannelGetBufferConditionMethodInfo
        ResolveIOChannelMethod "getBufferSize" o = IOChannelGetBufferSizeMethodInfo
        ResolveIOChannelMethod "getBuffered" o = IOChannelGetBufferedMethodInfo
        ResolveIOChannelMethod "getCloseOnUnref" o = IOChannelGetCloseOnUnrefMethodInfo
        ResolveIOChannelMethod "getEncoding" o = IOChannelGetEncodingMethodInfo
        ResolveIOChannelMethod "getFlags" o = IOChannelGetFlagsMethodInfo
        ResolveIOChannelMethod "getLineTerm" o = IOChannelGetLineTermMethodInfo
        ResolveIOChannelMethod "setBufferSize" o = IOChannelSetBufferSizeMethodInfo
        ResolveIOChannelMethod "setBuffered" o = IOChannelSetBufferedMethodInfo
        ResolveIOChannelMethod "setCloseOnUnref" o = IOChannelSetCloseOnUnrefMethodInfo
        ResolveIOChannelMethod "setEncoding" o = IOChannelSetEncodingMethodInfo
        ResolveIOChannelMethod "setFlags" o = IOChannelSetFlagsMethodInfo
        ResolveIOChannelMethod "setLineTerm" o = IOChannelSetLineTermMethodInfo
        ResolveIOChannelMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveIOChannelMethod t IOChannel, O.MethodInfo info IOChannel p) => O.IsLabel t (IOChannel -> 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