    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- /No description available in the introspection data./

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Structs.InputStreamClass
        (

    -- * Exported types
        InputStreamClass(..)                    ,
        newZeroInputStreamClass                 ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveInputStreamClassMethod           ,
    #endif

     -- * Properties

    -- ** closeAsync #attr:closeAsync#
    -- | /No description available in the introspection data./

        clearInputStreamClassCloseAsync         ,
        getInputStreamClassCloseAsync           ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_closeAsync             ,
    #endif
        setInputStreamClassCloseAsync           ,

    -- ** closeFinish #attr:closeFinish#
    -- | /No description available in the introspection data./

        clearInputStreamClassCloseFinish        ,
        getInputStreamClassCloseFinish          ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_closeFinish            ,
    #endif
        setInputStreamClassCloseFinish          ,

    -- ** closeFn #attr:closeFn#
    -- | /No description available in the introspection data./

        clearInputStreamClassCloseFn            ,
        getInputStreamClassCloseFn              ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_closeFn                ,
    #endif
        setInputStreamClassCloseFn              ,

    -- ** parentClass #attr:parentClass#
    -- | /No description available in the introspection data./

        getInputStreamClassParentClass          ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_parentClass            ,
    #endif

    -- ** readAsync #attr:readAsync#
    -- | /No description available in the introspection data./

        clearInputStreamClassReadAsync          ,
        getInputStreamClassReadAsync            ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_readAsync              ,
    #endif
        setInputStreamClassReadAsync            ,

    -- ** readFinish #attr:readFinish#
    -- | /No description available in the introspection data./

        clearInputStreamClassReadFinish         ,
        getInputStreamClassReadFinish           ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_readFinish             ,
    #endif
        setInputStreamClassReadFinish           ,

    -- ** readFn #attr:readFn#
    -- | /No description available in the introspection data./

        clearInputStreamClassReadFn             ,
        getInputStreamClassReadFn               ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_readFn                 ,
    #endif
        setInputStreamClassReadFn               ,

    -- ** skip #attr:skip#
    -- | /No description available in the introspection data./

        clearInputStreamClassSkip               ,
        getInputStreamClassSkip                 ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_skip                   ,
    #endif
        setInputStreamClassSkip                 ,

    -- ** skipAsync #attr:skipAsync#
    -- | /No description available in the introspection data./

        clearInputStreamClassSkipAsync          ,
        getInputStreamClassSkipAsync            ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_skipAsync              ,
    #endif
        setInputStreamClassSkipAsync            ,

    -- ** skipFinish #attr:skipFinish#
    -- | /No description available in the introspection data./

        clearInputStreamClassSkipFinish         ,
        getInputStreamClassSkipFinish           ,
    #if defined(ENABLE_OVERLOADING)
        inputStreamClass_skipFinish             ,
    #endif
        setInputStreamClassSkipFinish           ,

        ) 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.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
    import qualified GI.Gio.Callbacks as Gio.Callbacks

    #else
    import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
    import qualified GI.Gio.Callbacks as Gio.Callbacks

    #endif

    -- | Memory-managed wrapper type.
    newtype InputStreamClass = InputStreamClass (SP.ManagedPtr InputStreamClass)
        deriving (InputStreamClass -> InputStreamClass -> Bool
    (InputStreamClass -> InputStreamClass -> Bool)
    -> (InputStreamClass -> InputStreamClass -> Bool)
    -> Eq InputStreamClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputStreamClass -> InputStreamClass -> Bool
    == :: InputStreamClass -> InputStreamClass -> Bool
    $c/= :: InputStreamClass -> InputStreamClass -> Bool
    /= :: InputStreamClass -> InputStreamClass -> Bool
    Eq)

    instance SP.ManagedPtrNewtype InputStreamClass where
        toManagedPtr :: InputStreamClass -> ManagedPtr InputStreamClass
    toManagedPtr (InputStreamClass ManagedPtr InputStreamClass
    p) = ManagedPtr InputStreamClass
    p

    instance BoxedPtr InputStreamClass where
        boxedPtrCopy :: InputStreamClass -> IO InputStreamClass
    boxedPtrCopy = \InputStreamClass
    p -> InputStreamClass
    -> (Ptr InputStreamClass -> IO InputStreamClass)
    -> IO InputStreamClass
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr InputStreamClass
    p (Int -> Ptr InputStreamClass -> IO (Ptr InputStreamClass)
    forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
    copyBytes Int
    248 (Ptr InputStreamClass -> IO (Ptr InputStreamClass))
    -> (Ptr InputStreamClass -> IO InputStreamClass)
    -> Ptr InputStreamClass
    -> IO InputStreamClass
    forall (m :: * -> *) a b c.
    Monad m =>
    (a -> m b) -> (b -> m c) -> a -> m c
    >=> (ManagedPtr InputStreamClass -> InputStreamClass)
    -> Ptr InputStreamClass -> IO InputStreamClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.wrapPtr ManagedPtr InputStreamClass -> InputStreamClass
    InputStreamClass)
        boxedPtrFree :: InputStreamClass -> IO ()
    boxedPtrFree = \InputStreamClass
    x -> InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    SP.withManagedPtr InputStreamClass
    x Ptr InputStreamClass -> IO ()
    forall a. Ptr a -> IO ()
    SP.freeMem
    instance CallocPtr InputStreamClass where
        boxedPtrCalloc :: IO (Ptr InputStreamClass)
    boxedPtrCalloc = Int -> IO (Ptr InputStreamClass)
    forall a. Int -> IO (Ptr a)
    callocBytes Int
    248

    -- | Construct a `InputStreamClass` struct initialized to zero.
    newZeroInputStreamClass :: MonadIO m => m InputStreamClass
    newZeroInputStreamClass :: forall (m :: * -> *). MonadIO m => m InputStreamClass
    newZeroInputStreamClass = IO InputStreamClass -> m InputStreamClass
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO InputStreamClass -> m InputStreamClass)
    -> IO InputStreamClass -> m InputStreamClass
    forall a b. (a -> b) -> a -> b
    $ IO (Ptr InputStreamClass)
    forall a. CallocPtr a => IO (Ptr a)
    boxedPtrCalloc IO (Ptr InputStreamClass)
    -> (Ptr InputStreamClass -> IO InputStreamClass)
    -> IO InputStreamClass
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr InputStreamClass -> InputStreamClass)
    -> Ptr InputStreamClass -> IO InputStreamClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr InputStreamClass -> InputStreamClass
    InputStreamClass

    instance tag ~ 'AttrSet => Constructible InputStreamClass tag where
        new :: forall (m :: * -> *).
    MonadIO m =>
    (ManagedPtr InputStreamClass -> InputStreamClass)
    -> [AttrOp InputStreamClass tag] -> m InputStreamClass
    new ManagedPtr InputStreamClass -> InputStreamClass
    _ [AttrOp InputStreamClass tag]
    attrs = do
            InputStreamClass
    o <- m InputStreamClass
    forall (m :: * -> *). MonadIO m => m InputStreamClass
    newZeroInputStreamClass
            InputStreamClass -> [AttrOp InputStreamClass 'AttrSet] -> m ()
    forall o (m :: * -> *).
    MonadIO m =>
    o -> [AttrOp o 'AttrSet] -> m ()
    GI.Attributes.set InputStreamClass
    o [AttrOp InputStreamClass tag]
    [AttrOp InputStreamClass 'AttrSet]
    attrs
            InputStreamClass -> m InputStreamClass
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClass
    o

    -- | Get the value of the “@parent_class@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #parentClass
    -- @
    getInputStreamClassParentClass :: MonadIO m => InputStreamClass -> m GObject.ObjectClass.ObjectClass
    getInputStreamClassParentClass :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass -> m ObjectClass
    getInputStreamClassParentClass InputStreamClass
    s = IO ObjectClass -> m ObjectClass
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ObjectClass -> m ObjectClass)
    -> IO ObjectClass -> m ObjectClass
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass)
    -> (Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        let val :: Ptr ObjectClass
    val = Ptr InputStreamClass
    ptr Ptr InputStreamClass -> Int -> Ptr ObjectClass
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0 :: (Ptr GObject.ObjectClass.ObjectClass)
        ObjectClass
    val' <- ((ManagedPtr ObjectClass -> ObjectClass)
    -> Ptr ObjectClass -> IO ObjectClass
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newPtr ManagedPtr ObjectClass -> ObjectClass
    GObject.ObjectClass.ObjectClass) Ptr ObjectClass
    val
        ObjectClass -> IO ObjectClass
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ObjectClass
    val'

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassParentClassFieldInfo
    instance AttrInfo InputStreamClassParentClassFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassParentClassFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassParentClassFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint InputStreamClassParentClassFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
        type AttrTransferTypeConstraint InputStreamClassParentClassFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
        type AttrTransferType InputStreamClassParentClassFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
        type AttrGetType InputStreamClassParentClassFieldInfo = GObject.ObjectClass.ObjectClass
        type AttrLabel InputStreamClassParentClassFieldInfo = "parent_class"
        type AttrOrigin InputStreamClassParentClassFieldInfo = InputStreamClass
        attrGet = getInputStreamClassParentClass
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.parentClass"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:parentClass"
            })

    inputStreamClass_parentClass :: AttrLabelProxy "parentClass"
    inputStreamClass_parentClass = AttrLabelProxy

    #endif

    -- | Get the value of the “@read_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #readFn
    -- @
    getInputStreamClassReadFn :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadFnFieldCallback)
    getInputStreamClassReadFn :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass -> m (Maybe InputStreamClassReadFnFieldCallback)
    getInputStreamClassReadFn InputStreamClass
    s = IO (Maybe InputStreamClassReadFnFieldCallback)
    -> m (Maybe InputStreamClassReadFnFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassReadFnFieldCallback)
     -> m (Maybe InputStreamClassReadFnFieldCallback))
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    -> m (Maybe InputStreamClassReadFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFnFieldCallback))
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassReadFnFieldCallback))
     -> IO (Maybe InputStreamClassReadFnFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFnFieldCallback))
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassReadFnFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    -> IO (FunPtr C_InputStreamClassReadFnFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
        Maybe InputStreamClassReadFnFieldCallback
    result <- FunPtr C_InputStreamClassReadFnFieldCallback
    -> (FunPtr C_InputStreamClassReadFnFieldCallback
        -> IO InputStreamClassReadFnFieldCallback)
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFnFieldCallback
    val ((FunPtr C_InputStreamClassReadFnFieldCallback
      -> IO InputStreamClassReadFnFieldCallback)
     -> IO (Maybe InputStreamClassReadFnFieldCallback))
    -> (FunPtr C_InputStreamClassReadFnFieldCallback
        -> IO InputStreamClassReadFnFieldCallback)
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassReadFnFieldCallback
    val' -> do
            let val'' :: InputStreamClassReadFnFieldCallback
    val'' = FunPtr C_InputStreamClassReadFnFieldCallback
    -> InputStreamClassReadFnFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassReadFnFieldCallback
    -> a -> Ptr () -> CSize -> Maybe b -> m Int64
    Gio.Callbacks.dynamic_InputStreamClassReadFnFieldCallback FunPtr C_InputStreamClassReadFnFieldCallback
    val'
            InputStreamClassReadFnFieldCallback
    -> IO InputStreamClassReadFnFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassReadFnFieldCallback
    val''
        Maybe InputStreamClassReadFnFieldCallback
    -> IO (Maybe InputStreamClassReadFnFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassReadFnFieldCallback
    result

    -- | Set the value of the “@read_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readFn 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassReadFn :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback -> m ()
    setInputStreamClassReadFn :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassReadFnFieldCallback -> m ()
    setInputStreamClassReadFn InputStreamClass
    s FunPtr C_InputStreamClassReadFnFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    -> FunPtr C_InputStreamClassReadFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) (FunPtr C_InputStreamClassReadFnFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)

    -- | Set the value of the “@read_fn@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #readFn
    -- @
    clearInputStreamClassReadFn :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadFn :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadFn InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    -> FunPtr C_InputStreamClassReadFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    136) (FunPtr C_InputStreamClassReadFnFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassReadFnFieldInfo
    instance AttrInfo InputStreamClassReadFnFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassReadFnFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassReadFnFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassReadFnFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassReadFnFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
        type AttrTransferType InputStreamClassReadFnFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
        type AttrGetType InputStreamClassReadFnFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadFnFieldCallback
        type AttrLabel InputStreamClassReadFnFieldInfo = "read_fn"
        type AttrOrigin InputStreamClassReadFnFieldInfo = InputStreamClass
        attrGet = getInputStreamClassReadFn
        attrSet = setInputStreamClassReadFn
        attrConstruct = undefined
        attrClear = clearInputStreamClassReadFn
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readFn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFn"
            })

    inputStreamClass_readFn :: AttrLabelProxy "readFn"
    inputStreamClass_readFn = AttrLabelProxy

    #endif

    -- | Get the value of the “@skip@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #skip
    -- @
    getInputStreamClassSkip :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipFieldCallback)
    getInputStreamClassSkip :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass -> m (Maybe InputStreamClassSkipFieldCallback)
    getInputStreamClassSkip InputStreamClass
    s = IO (Maybe InputStreamClassSkipFieldCallback)
    -> m (Maybe InputStreamClassSkipFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassSkipFieldCallback)
     -> m (Maybe InputStreamClassSkipFieldCallback))
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    -> m (Maybe InputStreamClassSkipFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassSkipFieldCallback))
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassSkipFieldCallback))
     -> IO (Maybe InputStreamClassSkipFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassSkipFieldCallback))
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassSkipFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    -> IO (FunPtr C_InputStreamClassSkipFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
        Maybe InputStreamClassSkipFieldCallback
    result <- FunPtr C_InputStreamClassSkipFieldCallback
    -> (FunPtr C_InputStreamClassSkipFieldCallback
        -> IO InputStreamClassSkipFieldCallback)
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassSkipFieldCallback
    val ((FunPtr C_InputStreamClassSkipFieldCallback
      -> IO InputStreamClassSkipFieldCallback)
     -> IO (Maybe InputStreamClassSkipFieldCallback))
    -> (FunPtr C_InputStreamClassSkipFieldCallback
        -> IO InputStreamClassSkipFieldCallback)
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassSkipFieldCallback
    val' -> do
            let val'' :: InputStreamClassSkipFieldCallback
    val'' = FunPtr C_InputStreamClassSkipFieldCallback
    -> InputStreamClassSkipFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassSkipFieldCallback
    -> a -> CSize -> Maybe b -> m Int64
    Gio.Callbacks.dynamic_InputStreamClassSkipFieldCallback FunPtr C_InputStreamClassSkipFieldCallback
    val'
            InputStreamClassSkipFieldCallback
    -> IO InputStreamClassSkipFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassSkipFieldCallback
    val''
        Maybe InputStreamClassSkipFieldCallback
    -> IO (Maybe InputStreamClassSkipFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassSkipFieldCallback
    result

    -- | Set the value of the “@skip@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skip 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassSkip :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback -> m ()
    setInputStreamClassSkip :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassSkipFieldCallback -> m ()
    setInputStreamClassSkip InputStreamClass
    s FunPtr C_InputStreamClassSkipFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    -> FunPtr C_InputStreamClassSkipFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) (FunPtr C_InputStreamClassSkipFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)

    -- | Set the value of the “@skip@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #skip
    -- @
    clearInputStreamClassSkip :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkip :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkip InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    -> FunPtr C_InputStreamClassSkipFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    144) (FunPtr C_InputStreamClassSkipFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassSkipFieldInfo
    instance AttrInfo InputStreamClassSkipFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassSkipFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassSkipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassSkipFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassSkipFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
        type AttrTransferType InputStreamClassSkipFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
        type AttrGetType InputStreamClassSkipFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipFieldCallback
        type AttrLabel InputStreamClassSkipFieldInfo = "skip"
        type AttrOrigin InputStreamClassSkipFieldInfo = InputStreamClass
        attrGet = getInputStreamClassSkip
        attrSet = setInputStreamClassSkip
        attrConstruct = undefined
        attrClear = clearInputStreamClassSkip
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skip"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skip"
            })

    inputStreamClass_skip :: AttrLabelProxy "skip"
    inputStreamClass_skip = AttrLabelProxy

    #endif

    -- | Get the value of the “@close_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #closeFn
    -- @
    getInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseFnFieldCallback)
    getInputStreamClassCloseFn :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass -> m (Maybe InputStreamClassCloseFnFieldCallback)
    getInputStreamClassCloseFn InputStreamClass
    s = IO (Maybe InputStreamClassCloseFnFieldCallback)
    -> m (Maybe InputStreamClassCloseFnFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassCloseFnFieldCallback)
     -> m (Maybe InputStreamClassCloseFnFieldCallback))
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    -> m (Maybe InputStreamClassCloseFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseFnFieldCallback))
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassCloseFnFieldCallback))
     -> IO (Maybe InputStreamClassCloseFnFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseFnFieldCallback))
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassCloseFnFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    -> IO (FunPtr C_InputStreamClassCloseFnFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
        Maybe InputStreamClassCloseFnFieldCallback
    result <- FunPtr C_InputStreamClassCloseFnFieldCallback
    -> (FunPtr C_InputStreamClassCloseFnFieldCallback
        -> IO InputStreamClassCloseFnFieldCallback)
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseFnFieldCallback
    val ((FunPtr C_InputStreamClassCloseFnFieldCallback
      -> IO InputStreamClassCloseFnFieldCallback)
     -> IO (Maybe InputStreamClassCloseFnFieldCallback))
    -> (FunPtr C_InputStreamClassCloseFnFieldCallback
        -> IO InputStreamClassCloseFnFieldCallback)
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassCloseFnFieldCallback
    val' -> do
            let val'' :: InputStreamClassCloseFnFieldCallback
    val'' = FunPtr C_InputStreamClassCloseFnFieldCallback
    -> InputStreamClassCloseFnFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassCloseFnFieldCallback
    -> a -> Maybe b -> m ()
    Gio.Callbacks.dynamic_InputStreamClassCloseFnFieldCallback FunPtr C_InputStreamClassCloseFnFieldCallback
    val'
            InputStreamClassCloseFnFieldCallback
    -> IO InputStreamClassCloseFnFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassCloseFnFieldCallback
    val''
        Maybe InputStreamClassCloseFnFieldCallback
    -> IO (Maybe InputStreamClassCloseFnFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassCloseFnFieldCallback
    result

    -- | Set the value of the “@close_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeFn 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback -> m ()
    setInputStreamClassCloseFn :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassCloseFnFieldCallback -> m ()
    setInputStreamClassCloseFn InputStreamClass
    s FunPtr C_InputStreamClassCloseFnFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    -> FunPtr C_InputStreamClassCloseFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) (FunPtr C_InputStreamClassCloseFnFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)

    -- | Set the value of the “@close_fn@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #closeFn
    -- @
    clearInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseFn :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseFn InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    -> FunPtr C_InputStreamClassCloseFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    152) (FunPtr C_InputStreamClassCloseFnFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassCloseFnFieldInfo
    instance AttrInfo InputStreamClassCloseFnFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassCloseFnFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassCloseFnFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassCloseFnFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassCloseFnFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
        type AttrTransferType InputStreamClassCloseFnFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
        type AttrGetType InputStreamClassCloseFnFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseFnFieldCallback
        type AttrLabel InputStreamClassCloseFnFieldInfo = "close_fn"
        type AttrOrigin InputStreamClassCloseFnFieldInfo = InputStreamClass
        attrGet = getInputStreamClassCloseFn
        attrSet = setInputStreamClassCloseFn
        attrConstruct = undefined
        attrClear = clearInputStreamClassCloseFn
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeFn"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeFn"
            })

    inputStreamClass_closeFn :: AttrLabelProxy "closeFn"
    inputStreamClass_closeFn = AttrLabelProxy

    #endif

    -- | Get the value of the “@read_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #readAsync
    -- @
    getInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures)
    getInputStreamClassReadAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    getInputStreamClassReadAsync InputStreamClass
    s = IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
     -> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
     -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassReadAsyncFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    -> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
        Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
    result <- FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> (FunPtr C_InputStreamClassReadAsyncFieldCallback
        -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadAsyncFieldCallback
    val ((FunPtr C_InputStreamClassReadAsyncFieldCallback
      -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
     -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
    -> (FunPtr C_InputStreamClassReadAsyncFieldCallback
        -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassReadAsyncFieldCallback
    val' -> do
            let val'' :: InputStreamClassReadAsyncFieldCallback_WithClosures
    val'' = FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> InputStreamClassReadAsyncFieldCallback_WithClosures
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> a
    -> Maybe ByteString
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback_WithClosures
    -> Ptr ()
    -> m (Maybe ByteString)
    Gio.Callbacks.dynamic_InputStreamClassReadAsyncFieldCallback FunPtr C_InputStreamClassReadAsyncFieldCallback
    val'
            InputStreamClassReadAsyncFieldCallback_WithClosures
    -> IO InputStreamClassReadAsyncFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassReadAsyncFieldCallback_WithClosures
    val''
        Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
    -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
    result

    -- | Set the value of the “@read_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readAsync 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback -> m ()
    setInputStreamClassReadAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassReadAsyncFieldCallback -> m ()
    setInputStreamClassReadAsync InputStreamClass
    s FunPtr C_InputStreamClassReadAsyncFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    -> FunPtr C_InputStreamClassReadAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) (FunPtr C_InputStreamClassReadAsyncFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)

    -- | Set the value of the “@read_async@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #readAsync
    -- @
    clearInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadAsync InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    -> FunPtr C_InputStreamClassReadAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    160) (FunPtr C_InputStreamClassReadAsyncFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassReadAsyncFieldInfo
    instance AttrInfo InputStreamClassReadAsyncFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassReadAsyncFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassReadAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassReadAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassReadAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures
        type AttrTransferType InputStreamClassReadAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
        type AttrGetType InputStreamClassReadAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures
        type AttrLabel InputStreamClassReadAsyncFieldInfo = "read_async"
        type AttrOrigin InputStreamClassReadAsyncFieldInfo = InputStreamClass
        attrGet = getInputStreamClassReadAsync
        attrSet = setInputStreamClassReadAsync
        attrConstruct = undefined
        attrClear = clearInputStreamClassReadAsync
        attrTransfer _ v = do
            Gio.Callbacks.mk_InputStreamClassReadAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassReadAsyncFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readAsync"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readAsync"
            })

    inputStreamClass_readAsync :: AttrLabelProxy "readAsync"
    inputStreamClass_readAsync = AttrLabelProxy

    #endif

    -- | Get the value of the “@read_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #readFinish
    -- @
    getInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadFinishFieldCallback)
    getInputStreamClassReadFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    getInputStreamClassReadFinish InputStreamClass
    s = IO (Maybe InputStreamClassReadFinishFieldCallback)
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassReadFinishFieldCallback)
     -> m (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassReadFinishFieldCallback))
     -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassReadFinishFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
        Maybe InputStreamClassReadFinishFieldCallback
    result <- FunPtr C_InputStreamClassReadFinishFieldCallback
    -> (FunPtr C_InputStreamClassReadFinishFieldCallback
        -> IO InputStreamClassReadFinishFieldCallback)
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFinishFieldCallback
    val ((FunPtr C_InputStreamClassReadFinishFieldCallback
      -> IO InputStreamClassReadFinishFieldCallback)
     -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> (FunPtr C_InputStreamClassReadFinishFieldCallback
        -> IO InputStreamClassReadFinishFieldCallback)
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassReadFinishFieldCallback
    val' -> do
            let val'' :: InputStreamClassReadFinishFieldCallback
    val'' = FunPtr C_InputStreamClassReadFinishFieldCallback
    -> InputStreamClassReadFinishFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
    FunPtr C_InputStreamClassReadFinishFieldCallback
    -> a -> b -> m Int64
    Gio.Callbacks.dynamic_InputStreamClassReadFinishFieldCallback FunPtr C_InputStreamClassReadFinishFieldCallback
    val'
            InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassReadFinishFieldCallback
    val''
        Maybe InputStreamClassReadFinishFieldCallback
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassReadFinishFieldCallback
    result

    -- | Set the value of the “@read_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readFinish 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback -> m ()
    setInputStreamClassReadFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> m ()
    setInputStreamClassReadFinish InputStreamClass
    s FunPtr C_InputStreamClassReadFinishFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) (FunPtr C_InputStreamClassReadFinishFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)

    -- | Set the value of the “@read_finish@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #readFinish
    -- @
    clearInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassReadFinish InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    168) (FunPtr C_InputStreamClassReadFinishFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassReadFinishFieldInfo
    instance AttrInfo InputStreamClassReadFinishFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassReadFinishFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassReadFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassReadFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassReadFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
        type AttrTransferType InputStreamClassReadFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
        type AttrGetType InputStreamClassReadFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadFinishFieldCallback
        type AttrLabel InputStreamClassReadFinishFieldInfo = "read_finish"
        type AttrOrigin InputStreamClassReadFinishFieldInfo = InputStreamClass
        attrGet = getInputStreamClassReadFinish
        attrSet = setInputStreamClassReadFinish
        attrConstruct = undefined
        attrClear = clearInputStreamClassReadFinish
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readFinish"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFinish"
            })

    inputStreamClass_readFinish :: AttrLabelProxy "readFinish"
    inputStreamClass_readFinish = AttrLabelProxy

    #endif

    -- | Get the value of the “@skip_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #skipAsync
    -- @
    getInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures)
    getInputStreamClassSkipAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    getInputStreamClassSkipAsync InputStreamClass
    s = IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
     -> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
     -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    -> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
        Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
    result <- FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> (FunPtr C_InputStreamClassSkipAsyncFieldCallback
        -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val ((FunPtr C_InputStreamClassSkipAsyncFieldCallback
      -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
     -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
    -> (FunPtr C_InputStreamClassSkipAsyncFieldCallback
        -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val' -> do
            let val'' :: InputStreamClassSkipAsyncFieldCallback_WithClosures
    val'' = FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> InputStreamClassSkipAsyncFieldCallback_WithClosures
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> a
    -> CSize
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback_WithClosures
    -> Ptr ()
    -> m ()
    Gio.Callbacks.dynamic_InputStreamClassSkipAsyncFieldCallback FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val'
            InputStreamClassSkipAsyncFieldCallback_WithClosures
    -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassSkipAsyncFieldCallback_WithClosures
    val''
        Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
    -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
    result

    -- | Set the value of the “@skip_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skipAsync 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback -> m ()
    setInputStreamClassSkipAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> m ()
    setInputStreamClassSkipAsync InputStreamClass
    s FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    -> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) (FunPtr C_InputStreamClassSkipAsyncFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)

    -- | Set the value of the “@skip_async@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #skipAsync
    -- @
    clearInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkipAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkipAsync InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    -> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    176) (FunPtr C_InputStreamClassSkipAsyncFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassSkipAsyncFieldInfo
    instance AttrInfo InputStreamClassSkipAsyncFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassSkipAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures
        type AttrTransferType InputStreamClassSkipAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
        type AttrGetType InputStreamClassSkipAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures
        type AttrLabel InputStreamClassSkipAsyncFieldInfo = "skip_async"
        type AttrOrigin InputStreamClassSkipAsyncFieldInfo = InputStreamClass
        attrGet = getInputStreamClassSkipAsync
        attrSet = setInputStreamClassSkipAsync
        attrConstruct = undefined
        attrClear = clearInputStreamClassSkipAsync
        attrTransfer _ v = do
            Gio.Callbacks.mk_InputStreamClassSkipAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassSkipAsyncFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skipAsync"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipAsync"
            })

    inputStreamClass_skipAsync :: AttrLabelProxy "skipAsync"
    inputStreamClass_skipAsync = AttrLabelProxy

    #endif

    -- | Get the value of the “@skip_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #skipFinish
    -- @
    getInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipFinishFieldCallback)
    getInputStreamClassSkipFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    getInputStreamClassSkipFinish InputStreamClass
    s = IO (Maybe InputStreamClassReadFinishFieldCallback)
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassReadFinishFieldCallback)
     -> m (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    -> m (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassReadFinishFieldCallback))
     -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassReadFinishFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
        Maybe InputStreamClassReadFinishFieldCallback
    result <- FunPtr C_InputStreamClassReadFinishFieldCallback
    -> (FunPtr C_InputStreamClassReadFinishFieldCallback
        -> IO InputStreamClassReadFinishFieldCallback)
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFinishFieldCallback
    val ((FunPtr C_InputStreamClassReadFinishFieldCallback
      -> IO InputStreamClassReadFinishFieldCallback)
     -> IO (Maybe InputStreamClassReadFinishFieldCallback))
    -> (FunPtr C_InputStreamClassReadFinishFieldCallback
        -> IO InputStreamClassReadFinishFieldCallback)
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassReadFinishFieldCallback
    val' -> do
            let val'' :: InputStreamClassReadFinishFieldCallback
    val'' = FunPtr C_InputStreamClassReadFinishFieldCallback
    -> InputStreamClassReadFinishFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
    FunPtr C_InputStreamClassReadFinishFieldCallback
    -> a -> b -> m Int64
    Gio.Callbacks.dynamic_InputStreamClassSkipFinishFieldCallback FunPtr C_InputStreamClassReadFinishFieldCallback
    val'
            InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassReadFinishFieldCallback
    val''
        Maybe InputStreamClassReadFinishFieldCallback
    -> IO (Maybe InputStreamClassReadFinishFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassReadFinishFieldCallback
    result

    -- | Set the value of the “@skip_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skipFinish 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback -> m ()
    setInputStreamClassSkipFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> m ()
    setInputStreamClassSkipFinish InputStreamClass
    s FunPtr C_InputStreamClassReadFinishFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) (FunPtr C_InputStreamClassReadFinishFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)

    -- | Set the value of the “@skip_finish@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #skipFinish
    -- @
    clearInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkipFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassSkipFinish InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    -> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    184) (FunPtr C_InputStreamClassReadFinishFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassSkipFinishFieldInfo
    instance AttrInfo InputStreamClassSkipFinishFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassSkipFinishFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassSkipFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassSkipFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassSkipFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
        type AttrTransferType InputStreamClassSkipFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
        type AttrGetType InputStreamClassSkipFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipFinishFieldCallback
        type AttrLabel InputStreamClassSkipFinishFieldInfo = "skip_finish"
        type AttrOrigin InputStreamClassSkipFinishFieldInfo = InputStreamClass
        attrGet = getInputStreamClassSkipFinish
        attrSet = setInputStreamClassSkipFinish
        attrConstruct = undefined
        attrClear = clearInputStreamClassSkipFinish
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skipFinish"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipFinish"
            })

    inputStreamClass_skipFinish :: AttrLabelProxy "skipFinish"
    inputStreamClass_skipFinish = AttrLabelProxy

    #endif

    -- | Get the value of the “@close_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #closeAsync
    -- @
    getInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures)
    getInputStreamClassCloseAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    getInputStreamClassCloseAsync InputStreamClass
    s = IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
     -> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    -> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
     -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    -> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
        Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
    result <- FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> (FunPtr C_InputStreamClassCloseAsyncFieldCallback
        -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val ((FunPtr C_InputStreamClassCloseAsyncFieldCallback
      -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
     -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
    -> (FunPtr C_InputStreamClassCloseAsyncFieldCallback
        -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val' -> do
            let val'' :: InputStreamClassCloseAsyncFieldCallback_WithClosures
    val'' = FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> InputStreamClassCloseAsyncFieldCallback_WithClosures
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
    FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> a
    -> Int32
    -> Maybe b
    -> Maybe AsyncReadyCallback_WithClosures
    -> Ptr ()
    -> m ()
    Gio.Callbacks.dynamic_InputStreamClassCloseAsyncFieldCallback FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val'
            InputStreamClassCloseAsyncFieldCallback_WithClosures
    -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassCloseAsyncFieldCallback_WithClosures
    val''
        Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
    -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
    result

    -- | Set the value of the “@close_async@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeAsync 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback -> m ()
    setInputStreamClassCloseAsync :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> m ()
    setInputStreamClassCloseAsync InputStreamClass
    s FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    -> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) (FunPtr C_InputStreamClassCloseAsyncFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)

    -- | Set the value of the “@close_async@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #closeAsync
    -- @
    clearInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseAsync InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    -> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    192) (FunPtr C_InputStreamClassCloseAsyncFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassCloseAsyncFieldInfo
    instance AttrInfo InputStreamClassCloseAsyncFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassCloseAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures
        type AttrTransferType InputStreamClassCloseAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
        type AttrGetType InputStreamClassCloseAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures
        type AttrLabel InputStreamClassCloseAsyncFieldInfo = "close_async"
        type AttrOrigin InputStreamClassCloseAsyncFieldInfo = InputStreamClass
        attrGet = getInputStreamClassCloseAsync
        attrSet = setInputStreamClassCloseAsync
        attrConstruct = undefined
        attrClear = clearInputStreamClassCloseAsync
        attrTransfer _ v = do
            Gio.Callbacks.mk_InputStreamClassCloseAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassCloseAsyncFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeAsync"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeAsync"
            })

    inputStreamClass_closeAsync :: AttrLabelProxy "closeAsync"
    inputStreamClass_closeAsync = AttrLabelProxy

    #endif

    -- | Get the value of the “@close_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' inputStreamClass #closeFinish
    -- @
    getInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseFinishFieldCallback)
    getInputStreamClassCloseFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> m (Maybe InputStreamClassCloseFinishFieldCallback)
    getInputStreamClassCloseFinish InputStreamClass
    s = IO (Maybe InputStreamClassCloseFinishFieldCallback)
    -> m (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe InputStreamClassCloseFinishFieldCallback)
     -> m (Maybe InputStreamClassCloseFinishFieldCallback))
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    -> m (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass
      -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
     -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
    -> (Ptr InputStreamClass
        -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        FunPtr C_InputStreamClassCloseFinishFieldCallback
    val <- Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    -> IO (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
        Maybe InputStreamClassCloseFinishFieldCallback
    result <- FunPtr C_InputStreamClassCloseFinishFieldCallback
    -> (FunPtr C_InputStreamClassCloseFinishFieldCallback
        -> IO InputStreamClassCloseFinishFieldCallback)
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseFinishFieldCallback
    val ((FunPtr C_InputStreamClassCloseFinishFieldCallback
      -> IO InputStreamClassCloseFinishFieldCallback)
     -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
    -> (FunPtr C_InputStreamClassCloseFinishFieldCallback
        -> IO InputStreamClassCloseFinishFieldCallback)
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_InputStreamClassCloseFinishFieldCallback
    val' -> do
            let val'' :: InputStreamClassCloseFinishFieldCallback
    val'' = FunPtr C_InputStreamClassCloseFinishFieldCallback
    -> InputStreamClassCloseFinishFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
    FunPtr C_InputStreamClassCloseFinishFieldCallback -> a -> b -> m ()
    Gio.Callbacks.dynamic_InputStreamClassCloseFinishFieldCallback FunPtr C_InputStreamClassCloseFinishFieldCallback
    val'
            InputStreamClassCloseFinishFieldCallback
    -> IO InputStreamClassCloseFinishFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return InputStreamClassCloseFinishFieldCallback
    val''
        Maybe InputStreamClassCloseFinishFieldCallback
    -> IO (Maybe InputStreamClassCloseFinishFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe InputStreamClassCloseFinishFieldCallback
    result

    -- | Set the value of the “@close_finish@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeFinish 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback -> m ()
    setInputStreamClassCloseFinish :: forall (m :: * -> *).
    MonadIO m =>
    InputStreamClass
    -> FunPtr C_InputStreamClassCloseFinishFieldCallback -> m ()
    setInputStreamClassCloseFinish InputStreamClass
    s FunPtr C_InputStreamClassCloseFinishFieldCallback
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    -> FunPtr C_InputStreamClassCloseFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) (FunPtr C_InputStreamClassCloseFinishFieldCallback
    val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)

    -- | Set the value of the “@close_finish@” field to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #closeFinish
    -- @
    clearInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
    clearInputStreamClassCloseFinish InputStreamClass
    s = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr InputStreamClass
    s ((Ptr InputStreamClass -> IO ()) -> IO ())
    -> (Ptr InputStreamClass -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr InputStreamClass
    ptr -> do
        Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    -> FunPtr C_InputStreamClassCloseFinishFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr InputStreamClass
    ptr Ptr InputStreamClass
    -> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    200) (FunPtr C_InputStreamClassCloseFinishFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data InputStreamClassCloseFinishFieldInfo
    instance AttrInfo InputStreamClassCloseFinishFieldInfo where
        type AttrBaseTypeConstraint InputStreamClassCloseFinishFieldInfo = (~) InputStreamClass
        type AttrAllowedOps InputStreamClassCloseFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint InputStreamClassCloseFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
        type AttrTransferTypeConstraint InputStreamClassCloseFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
        type AttrTransferType InputStreamClassCloseFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
        type AttrGetType InputStreamClassCloseFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseFinishFieldCallback
        type AttrLabel InputStreamClassCloseFinishFieldInfo = "close_finish"
        type AttrOrigin InputStreamClassCloseFinishFieldInfo = InputStreamClass
        attrGet = getInputStreamClassCloseFinish
        attrSet = setInputStreamClassCloseFinish
        attrConstruct = undefined
        attrClear = clearInputStreamClassCloseFinish
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeFinish"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeFinish"
            })

    inputStreamClass_closeFinish :: AttrLabelProxy "closeFinish"
    inputStreamClass_closeFinish = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList InputStreamClass
    type instance O.AttributeList InputStreamClass = InputStreamClassAttributeList
    type InputStreamClassAttributeList = ('[ '("parentClass", InputStreamClassParentClassFieldInfo), '("readFn", InputStreamClassReadFnFieldInfo), '("skip", InputStreamClassSkipFieldInfo), '("closeFn", InputStreamClassCloseFnFieldInfo), '("readAsync", InputStreamClassReadAsyncFieldInfo), '("readFinish", InputStreamClassReadFinishFieldInfo), '("skipAsync", InputStreamClassSkipAsyncFieldInfo), '("skipFinish", InputStreamClassSkipFinishFieldInfo), '("closeAsync", InputStreamClassCloseAsyncFieldInfo), '("closeFinish", InputStreamClassCloseFinishFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveInputStreamClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveInputStreamClassMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethod info InputStreamClass p) => OL.IsLabel t (InputStreamClass -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethod info InputStreamClass p, R.HasField t InputStreamClass p) => R.HasField t InputStreamClass p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethodInfo info InputStreamClass) => OL.IsLabel t (O.MethodProxy info InputStreamClass) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif