    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Provides an interface for implementing seekable functionality on I\/O Streams.

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

    module GI.Gio.Structs.SeekableIface
        (

    -- * Exported types
        SeekableIface(..)                       ,
        newZeroSeekableIface                    ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveSeekableIfaceMethod              ,
    #endif

     -- * Properties

    -- ** canSeek #attr:canSeek#
    -- | Checks if seeking is supported by the stream.

        clearSeekableIfaceCanSeek               ,
        getSeekableIfaceCanSeek                 ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_canSeek                   ,
    #endif
        setSeekableIfaceCanSeek                 ,

    -- ** canTruncate #attr:canTruncate#
    -- | Checks if truncation is supported by the stream.

        clearSeekableIfaceCanTruncate           ,
        getSeekableIfaceCanTruncate             ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_canTruncate               ,
    #endif
        setSeekableIfaceCanTruncate             ,

    -- ** gIface #attr:gIface#
    -- | The parent interface.

        getSeekableIfaceGIface                  ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_gIface                    ,
    #endif

    -- ** seek #attr:seek#
    -- | Seeks to a location within a stream.

        clearSeekableIfaceSeek                  ,
        getSeekableIfaceSeek                    ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_seek                      ,
    #endif
        setSeekableIfaceSeek                    ,

    -- ** tell #attr:tell#
    -- | Tells the current location within a stream.

        clearSeekableIfaceTell                  ,
        getSeekableIfaceTell                    ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_tell                      ,
    #endif
        setSeekableIfaceTell                    ,

    -- ** truncateFn #attr:truncateFn#
    -- | Truncates a stream.

        clearSeekableIfaceTruncateFn            ,
        getSeekableIfaceTruncateFn              ,
    #if defined(ENABLE_OVERLOADING)
        seekableIface_truncateFn                ,
    #endif
        setSeekableIfaceTruncateFn              ,

        ) 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.TypeInterface as GObject.TypeInterface
    import qualified GI.Gio.Callbacks as Gio.Callbacks

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

    #endif

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

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

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

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

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

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

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

    seekableIface_gIface :: AttrLabelProxy "gIface"
    seekableIface_gIface = AttrLabelProxy

    #endif

    -- | Get the value of the “@tell@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' seekableIface #tell
    -- @
    getSeekableIfaceTell :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceTellFieldCallback)
    getSeekableIfaceTell :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> m (Maybe SeekableIfaceTellFieldCallback)
    getSeekableIfaceTell SeekableIface
    s = IO (Maybe SeekableIfaceTellFieldCallback)
    -> m (Maybe SeekableIfaceTellFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SeekableIfaceTellFieldCallback)
     -> m (Maybe SeekableIfaceTellFieldCallback))
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    -> m (Maybe SeekableIfaceTellFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ SeekableIface
    -> (Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
     -> IO (Maybe SeekableIfaceTellFieldCallback))
    -> (Ptr SeekableIface -> IO (Maybe SeekableIfaceTellFieldCallback))
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        FunPtr C_SeekableIfaceTellFieldCallback
    val <- Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
    -> IO (FunPtr C_SeekableIfaceTellFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
        Maybe SeekableIfaceTellFieldCallback
    result <- FunPtr C_SeekableIfaceTellFieldCallback
    -> (FunPtr C_SeekableIfaceTellFieldCallback
        -> IO SeekableIfaceTellFieldCallback)
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceTellFieldCallback
    val ((FunPtr C_SeekableIfaceTellFieldCallback
      -> IO SeekableIfaceTellFieldCallback)
     -> IO (Maybe SeekableIfaceTellFieldCallback))
    -> (FunPtr C_SeekableIfaceTellFieldCallback
        -> IO SeekableIfaceTellFieldCallback)
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_SeekableIfaceTellFieldCallback
    val' -> do
            let val'' :: SeekableIfaceTellFieldCallback
    val'' = FunPtr C_SeekableIfaceTellFieldCallback
    -> SeekableIfaceTellFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSeekable a) =>
    FunPtr C_SeekableIfaceTellFieldCallback -> a -> m Int64
    Gio.Callbacks.dynamic_SeekableIfaceTellFieldCallback FunPtr C_SeekableIfaceTellFieldCallback
    val'
            SeekableIfaceTellFieldCallback -> IO SeekableIfaceTellFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SeekableIfaceTellFieldCallback
    val''
        Maybe SeekableIfaceTellFieldCallback
    -> IO (Maybe SeekableIfaceTellFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SeekableIfaceTellFieldCallback
    result

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

    -- | Set the value of the “@tell@” 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' #tell
    -- @
    clearSeekableIfaceTell :: MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceTell :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceTell SeekableIface
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
    -> FunPtr C_SeekableIfaceTellFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceTellFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) (FunPtr C_SeekableIfaceTellFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data SeekableIfaceTellFieldInfo
    instance AttrInfo SeekableIfaceTellFieldInfo where
        type AttrBaseTypeConstraint SeekableIfaceTellFieldInfo = (~) SeekableIface
        type AttrAllowedOps SeekableIfaceTellFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SeekableIfaceTellFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
        type AttrTransferTypeConstraint SeekableIfaceTellFieldInfo = (~)Gio.Callbacks.SeekableIfaceTellFieldCallback
        type AttrTransferType SeekableIfaceTellFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceTellFieldCallback)
        type AttrGetType SeekableIfaceTellFieldInfo = Maybe Gio.Callbacks.SeekableIfaceTellFieldCallback
        type AttrLabel SeekableIfaceTellFieldInfo = "tell"
        type AttrOrigin SeekableIfaceTellFieldInfo = SeekableIface
        attrGet = getSeekableIfaceTell
        attrSet = setSeekableIfaceTell
        attrConstruct = undefined
        attrClear = clearSeekableIfaceTell
        attrTransfer _ v = do
            Gio.Callbacks.mk_SeekableIfaceTellFieldCallback (Gio.Callbacks.wrap_SeekableIfaceTellFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.tell"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-SeekableIface.html#g:attr:tell"
            })

    seekableIface_tell :: AttrLabelProxy "tell"
    seekableIface_tell = AttrLabelProxy

    #endif

    -- | Get the value of the “@can_seek@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' seekableIface #canSeek
    -- @
    getSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceCanSeekFieldCallback)
    getSeekableIfaceCanSeek :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    getSeekableIfaceCanSeek SeekableIface
    s = IO (Maybe SeekableIfaceCanSeekFieldCallback)
    -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SeekableIfaceCanSeekFieldCallback)
     -> m (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ SeekableIface
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface
      -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
     -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        FunPtr C_SeekableIfaceCanSeekFieldCallback
    val <- Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
        Maybe SeekableIfaceCanSeekFieldCallback
    result <- FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> (FunPtr C_SeekableIfaceCanSeekFieldCallback
        -> IO SeekableIfaceCanSeekFieldCallback)
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceCanSeekFieldCallback
    val ((FunPtr C_SeekableIfaceCanSeekFieldCallback
      -> IO SeekableIfaceCanSeekFieldCallback)
     -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> (FunPtr C_SeekableIfaceCanSeekFieldCallback
        -> IO SeekableIfaceCanSeekFieldCallback)
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_SeekableIfaceCanSeekFieldCallback
    val' -> do
            let val'' :: SeekableIfaceCanSeekFieldCallback
    val'' = FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> SeekableIfaceCanSeekFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSeekable a) =>
    FunPtr C_SeekableIfaceCanSeekFieldCallback -> a -> m Bool
    Gio.Callbacks.dynamic_SeekableIfaceCanSeekFieldCallback FunPtr C_SeekableIfaceCanSeekFieldCallback
    val'
            SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SeekableIfaceCanSeekFieldCallback
    val''
        Maybe SeekableIfaceCanSeekFieldCallback
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SeekableIfaceCanSeekFieldCallback
    result

    -- | Set the value of the “@can_seek@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' seekableIface [ #canSeek 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback -> m ()
    setSeekableIfaceCanSeek :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> m ()
    setSeekableIfaceCanSeek SeekableIface
    s FunPtr C_SeekableIfaceCanSeekFieldCallback
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (FunPtr C_SeekableIfaceCanSeekFieldCallback
    val :: FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)

    -- | Set the value of the “@can_seek@” 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' #canSeek
    -- @
    clearSeekableIfaceCanSeek :: MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceCanSeek :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceCanSeek SeekableIface
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (FunPtr C_SeekableIfaceCanSeekFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data SeekableIfaceCanSeekFieldInfo
    instance AttrInfo SeekableIfaceCanSeekFieldInfo where
        type AttrBaseTypeConstraint SeekableIfaceCanSeekFieldInfo = (~) SeekableIface
        type AttrAllowedOps SeekableIfaceCanSeekFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SeekableIfaceCanSeekFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
        type AttrTransferTypeConstraint SeekableIfaceCanSeekFieldInfo = (~)Gio.Callbacks.SeekableIfaceCanSeekFieldCallback
        type AttrTransferType SeekableIfaceCanSeekFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceCanSeekFieldCallback)
        type AttrGetType SeekableIfaceCanSeekFieldInfo = Maybe Gio.Callbacks.SeekableIfaceCanSeekFieldCallback
        type AttrLabel SeekableIfaceCanSeekFieldInfo = "can_seek"
        type AttrOrigin SeekableIfaceCanSeekFieldInfo = SeekableIface
        attrGet = getSeekableIfaceCanSeek
        attrSet = setSeekableIfaceCanSeek
        attrConstruct = undefined
        attrClear = clearSeekableIfaceCanSeek
        attrTransfer _ v = do
            Gio.Callbacks.mk_SeekableIfaceCanSeekFieldCallback (Gio.Callbacks.wrap_SeekableIfaceCanSeekFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.canSeek"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-SeekableIface.html#g:attr:canSeek"
            })

    seekableIface_canSeek :: AttrLabelProxy "canSeek"
    seekableIface_canSeek = AttrLabelProxy

    #endif

    -- | Get the value of the “@seek@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' seekableIface #seek
    -- @
    getSeekableIfaceSeek :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceSeekFieldCallback)
    getSeekableIfaceSeek :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> m (Maybe SeekableIfaceSeekFieldCallback)
    getSeekableIfaceSeek SeekableIface
    s = IO (Maybe SeekableIfaceSeekFieldCallback)
    -> m (Maybe SeekableIfaceSeekFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SeekableIfaceSeekFieldCallback)
     -> m (Maybe SeekableIfaceSeekFieldCallback))
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    -> m (Maybe SeekableIfaceSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ SeekableIface
    -> (Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
     -> IO (Maybe SeekableIfaceSeekFieldCallback))
    -> (Ptr SeekableIface -> IO (Maybe SeekableIfaceSeekFieldCallback))
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        FunPtr C_SeekableIfaceSeekFieldCallback
    val <- Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
    -> IO (FunPtr C_SeekableIfaceSeekFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)
        Maybe SeekableIfaceSeekFieldCallback
    result <- FunPtr C_SeekableIfaceSeekFieldCallback
    -> (FunPtr C_SeekableIfaceSeekFieldCallback
        -> IO SeekableIfaceSeekFieldCallback)
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceSeekFieldCallback
    val ((FunPtr C_SeekableIfaceSeekFieldCallback
      -> IO SeekableIfaceSeekFieldCallback)
     -> IO (Maybe SeekableIfaceSeekFieldCallback))
    -> (FunPtr C_SeekableIfaceSeekFieldCallback
        -> IO SeekableIfaceSeekFieldCallback)
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_SeekableIfaceSeekFieldCallback
    val' -> do
            let val'' :: SeekableIfaceSeekFieldCallback
    val'' = FunPtr C_SeekableIfaceSeekFieldCallback
    -> SeekableIfaceSeekFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
    FunPtr C_SeekableIfaceSeekFieldCallback
    -> a -> Int64 -> SeekType -> Maybe b -> m ()
    Gio.Callbacks.dynamic_SeekableIfaceSeekFieldCallback FunPtr C_SeekableIfaceSeekFieldCallback
    val'
            SeekableIfaceSeekFieldCallback -> IO SeekableIfaceSeekFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SeekableIfaceSeekFieldCallback
    val''
        Maybe SeekableIfaceSeekFieldCallback
    -> IO (Maybe SeekableIfaceSeekFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SeekableIfaceSeekFieldCallback
    result

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

    -- | Set the value of the “@seek@” 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' #seek
    -- @
    clearSeekableIfaceSeek :: MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceSeek :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceSeek SeekableIface
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
    -> FunPtr C_SeekableIfaceSeekFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) (FunPtr C_SeekableIfaceSeekFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceSeekFieldCallback)

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

    seekableIface_seek :: AttrLabelProxy "seek"
    seekableIface_seek = AttrLabelProxy

    #endif

    -- | Get the value of the “@can_truncate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' seekableIface #canTruncate
    -- @
    getSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback)
    getSeekableIfaceCanTruncate :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    getSeekableIfaceCanTruncate SeekableIface
    s = IO (Maybe SeekableIfaceCanSeekFieldCallback)
    -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SeekableIfaceCanSeekFieldCallback)
     -> m (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    -> m (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ SeekableIface
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface
      -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
     -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        FunPtr C_SeekableIfaceCanSeekFieldCallback
    val <- Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> IO (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
        Maybe SeekableIfaceCanSeekFieldCallback
    result <- FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> (FunPtr C_SeekableIfaceCanSeekFieldCallback
        -> IO SeekableIfaceCanSeekFieldCallback)
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceCanSeekFieldCallback
    val ((FunPtr C_SeekableIfaceCanSeekFieldCallback
      -> IO SeekableIfaceCanSeekFieldCallback)
     -> IO (Maybe SeekableIfaceCanSeekFieldCallback))
    -> (FunPtr C_SeekableIfaceCanSeekFieldCallback
        -> IO SeekableIfaceCanSeekFieldCallback)
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_SeekableIfaceCanSeekFieldCallback
    val' -> do
            let val'' :: SeekableIfaceCanSeekFieldCallback
    val'' = FunPtr C_SeekableIfaceCanSeekFieldCallback
    -> SeekableIfaceCanSeekFieldCallback
    forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSeekable a) =>
    FunPtr C_SeekableIfaceCanSeekFieldCallback -> a -> m Bool
    Gio.Callbacks.dynamic_SeekableIfaceCanTruncateFieldCallback FunPtr C_SeekableIfaceCanSeekFieldCallback
    val'
            SeekableIfaceCanSeekFieldCallback
    -> IO SeekableIfaceCanSeekFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SeekableIfaceCanSeekFieldCallback
    val''
        Maybe SeekableIfaceCanSeekFieldCallback
    -> IO (Maybe SeekableIfaceCanSeekFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SeekableIfaceCanSeekFieldCallback
    result

    -- | Set the value of the “@can_truncate@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' seekableIface [ #canTruncate 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback -> m ()
    setSeekableIfaceCanTruncate :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> m ()
    setSeekableIfaceCanTruncate SeekableIface
    s FunPtr C_SeekableIfaceCanSeekFieldCallback
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) (FunPtr C_SeekableIfaceCanSeekFieldCallback
    val :: FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)

    -- | Set the value of the “@can_truncate@” 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' #canTruncate
    -- @
    clearSeekableIfaceCanTruncate :: MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceCanTruncate :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceCanTruncate SeekableIface
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    -> FunPtr C_SeekableIfaceCanSeekFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceCanSeekFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) (FunPtr C_SeekableIfaceCanSeekFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)

    #if defined(ENABLE_OVERLOADING)
    data SeekableIfaceCanTruncateFieldInfo
    instance AttrInfo SeekableIfaceCanTruncateFieldInfo where
        type AttrBaseTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~) SeekableIface
        type AttrAllowedOps SeekableIfaceCanTruncateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~) (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
        type AttrTransferTypeConstraint SeekableIfaceCanTruncateFieldInfo = (~)Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback
        type AttrTransferType SeekableIfaceCanTruncateFieldInfo = (FunPtr Gio.Callbacks.C_SeekableIfaceCanTruncateFieldCallback)
        type AttrGetType SeekableIfaceCanTruncateFieldInfo = Maybe Gio.Callbacks.SeekableIfaceCanTruncateFieldCallback
        type AttrLabel SeekableIfaceCanTruncateFieldInfo = "can_truncate"
        type AttrOrigin SeekableIfaceCanTruncateFieldInfo = SeekableIface
        attrGet = getSeekableIfaceCanTruncate
        attrSet = setSeekableIfaceCanTruncate
        attrConstruct = undefined
        attrClear = clearSeekableIfaceCanTruncate
        attrTransfer _ v = do
            Gio.Callbacks.mk_SeekableIfaceCanTruncateFieldCallback (Gio.Callbacks.wrap_SeekableIfaceCanTruncateFieldCallback Nothing v)
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gio.Structs.SeekableIface.canTruncate"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-SeekableIface.html#g:attr:canTruncate"
            })

    seekableIface_canTruncate :: AttrLabelProxy "canTruncate"
    seekableIface_canTruncate = AttrLabelProxy

    #endif

    -- | Get the value of the “@truncate_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' seekableIface #truncateFn
    -- @
    getSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> m (Maybe Gio.Callbacks.SeekableIfaceTruncateFnFieldCallback)
    getSeekableIfaceTruncateFn :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface -> m (Maybe SeekableIfaceTruncateFnFieldCallback)
    getSeekableIfaceTruncateFn SeekableIface
    s = IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    -> m (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe SeekableIfaceTruncateFnFieldCallback)
     -> m (Maybe SeekableIfaceTruncateFnFieldCallback))
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    -> m (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ SeekableIface
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface
      -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
     -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
    -> (Ptr SeekableIface
        -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        FunPtr C_SeekableIfaceTruncateFnFieldCallback
    val <- Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    -> IO (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    48) :: IO (FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)
        Maybe SeekableIfaceTruncateFnFieldCallback
    result <- FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> (FunPtr C_SeekableIfaceTruncateFnFieldCallback
        -> IO SeekableIfaceTruncateFnFieldCallback)
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
    SP.convertFunPtrIfNonNull FunPtr C_SeekableIfaceTruncateFnFieldCallback
    val ((FunPtr C_SeekableIfaceTruncateFnFieldCallback
      -> IO SeekableIfaceTruncateFnFieldCallback)
     -> IO (Maybe SeekableIfaceTruncateFnFieldCallback))
    -> (FunPtr C_SeekableIfaceTruncateFnFieldCallback
        -> IO SeekableIfaceTruncateFnFieldCallback)
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a b. (a -> b) -> a -> b
    $ \FunPtr C_SeekableIfaceTruncateFnFieldCallback
    val' -> do
            let val'' :: SeekableIfaceTruncateFnFieldCallback
    val'' = FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> SeekableIfaceTruncateFnFieldCallback
    forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSeekable a, IsCancellable b) =>
    FunPtr C_SeekableIfaceTruncateFnFieldCallback
    -> a -> Int64 -> Maybe b -> m ()
    Gio.Callbacks.dynamic_SeekableIfaceTruncateFnFieldCallback FunPtr C_SeekableIfaceTruncateFnFieldCallback
    val'
            SeekableIfaceTruncateFnFieldCallback
    -> IO SeekableIfaceTruncateFnFieldCallback
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return SeekableIfaceTruncateFnFieldCallback
    val''
        Maybe SeekableIfaceTruncateFnFieldCallback
    -> IO (Maybe SeekableIfaceTruncateFnFieldCallback)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe SeekableIfaceTruncateFnFieldCallback
    result

    -- | Set the value of the “@truncate_fn@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' seekableIface [ #truncateFn 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback -> m ()
    setSeekableIfaceTruncateFn :: forall (m :: * -> *).
    MonadIO m =>
    SeekableIface
    -> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> m ()
    setSeekableIfaceTruncateFn SeekableIface
    s FunPtr C_SeekableIfaceTruncateFnFieldCallback
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    -> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    48) (FunPtr C_SeekableIfaceTruncateFnFieldCallback
    val :: FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)

    -- | Set the value of the “@truncate_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' #truncateFn
    -- @
    clearSeekableIfaceTruncateFn :: MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceTruncateFn :: forall (m :: * -> *). MonadIO m => SeekableIface -> m ()
    clearSeekableIfaceTruncateFn SeekableIface
    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
    $ SeekableIface -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SeekableIface
    s ((Ptr SeekableIface -> IO ()) -> IO ())
    -> (Ptr SeekableIface -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SeekableIface
    ptr -> do
        Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    -> FunPtr C_SeekableIfaceTruncateFnFieldCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SeekableIface
    ptr Ptr SeekableIface
    -> Int -> Ptr (FunPtr C_SeekableIfaceTruncateFnFieldCallback)
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    48) (FunPtr C_SeekableIfaceTruncateFnFieldCallback
    forall a. FunPtr a
    FP.nullFunPtr :: FunPtr Gio.Callbacks.C_SeekableIfaceTruncateFnFieldCallback)

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

    seekableIface_truncateFn :: AttrLabelProxy "truncateFn"
    seekableIface_truncateFn = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList SeekableIface
    type instance O.AttributeList SeekableIface = SeekableIfaceAttributeList
    type SeekableIfaceAttributeList = ('[ '("gIface", SeekableIfaceGIfaceFieldInfo), '("tell", SeekableIfaceTellFieldInfo), '("canSeek", SeekableIfaceCanSeekFieldInfo), '("seek", SeekableIfaceSeekFieldInfo), '("canTruncate", SeekableIfaceCanTruncateFieldInfo), '("truncateFn", SeekableIfaceTruncateFnFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

    instance (info ~ ResolveSeekableIfaceMethod t SeekableIface, O.OverloadedMethod info SeekableIface p) => OL.IsLabel t (SeekableIface -> 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 ~ ResolveSeekableIfaceMethod t SeekableIface, O.OverloadedMethod info SeekableIface p, R.HasField t SeekableIface p) => R.HasField t SeekableIface p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif