    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A structure holding in-depth information for a specific signal.
    --
    -- See also: 'GI.GObject.Functions.signalQuery'

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

    module GI.GObject.Structs.SignalQuery
        (

    -- * Exported types
        SignalQuery(..)                         ,
        newZeroSignalQuery                      ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveSignalQueryMethod                ,
    #endif

     -- * Properties

    -- ** itype #attr:itype#
    -- | The interface\/instance type that this signal can be emitted for.

        getSignalQueryItype                     ,
        setSignalQueryItype                     ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_itype                       ,
    #endif

    -- ** nParams #attr:nParams#
    -- | The number of parameters that user callbacks take.

        getSignalQueryNParams                   ,
        setSignalQueryNParams                   ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_nParams                     ,
    #endif

    -- ** returnType #attr:returnType#
    -- | The return type for user callbacks.

        getSignalQueryReturnType                ,
        setSignalQueryReturnType                ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_returnType                  ,
    #endif

    -- ** signalFlags #attr:signalFlags#
    -- | The signal flags as passed in to @/g_signal_new()/@.

        getSignalQuerySignalFlags               ,
        setSignalQuerySignalFlags               ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_signalFlags                 ,
    #endif

    -- ** signalId #attr:signalId#
    -- | The signal id of the signal being queried, or 0 if the
    --  signal to be queried was unknown.

        getSignalQuerySignalId                  ,
        setSignalQuerySignalId                  ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_signalId                    ,
    #endif

    -- ** signalName #attr:signalName#
    -- | The signal name.

        clearSignalQuerySignalName              ,
        getSignalQuerySignalName                ,
        setSignalQuerySignalName                ,
    #if defined(ENABLE_OVERLOADING)
        signalQuery_signalName                  ,
    #endif

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.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 {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

    #else
    import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

    #endif

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

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

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

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

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

    -- | Get the value of the “@signal_id@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #signalId
    -- @
    getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32
    getSignalQuerySignalId :: forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
    getSignalQuerySignalId SignalQuery
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ SignalQuery -> (Ptr SignalQuery -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO Word32) -> IO Word32)
    -> (Ptr SignalQuery -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0) :: IO Word32
        return val

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

    #if defined(ENABLE_OVERLOADING)
    data SignalQuerySignalIdFieldInfo
    instance AttrInfo SignalQuerySignalIdFieldInfo where
        type AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQuerySignalIdFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SignalQuerySignalIdFieldInfo = (~) Word32
        type AttrTransferTypeConstraint SignalQuerySignalIdFieldInfo = (~)Word32
        type AttrTransferType SignalQuerySignalIdFieldInfo = Word32
        type AttrGetType SignalQuerySignalIdFieldInfo = Word32
        type AttrLabel SignalQuerySignalIdFieldInfo = "signal_id"
        type AttrOrigin SignalQuerySignalIdFieldInfo = SignalQuery
        attrGet = getSignalQuerySignalId
        attrSet = setSignalQuerySignalId
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalId"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalId"
            })

    signalQuery_signalId :: AttrLabelProxy "signalId"
    signalQuery_signalId = AttrLabelProxy

    #endif

    -- | Get the value of the “@signal_name@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #signalName
    -- @
    getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe T.Text)
    getSignalQuerySignalName :: forall (m :: * -> *). MonadIO m => SignalQuery -> m (Maybe Text)
    getSignalQuerySignalName SignalQuery
    s = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ SignalQuery
    -> (Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text))
    -> (Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr CString -> IO CString
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) :: IO CString
        result <- SP.convertIfNonNull val $ \CString
    val' -> do
            val'' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    val'
            return val''
        return result

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

    -- | Set the value of the “@signal_name@” 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' #signalName
    -- @
    clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()
    clearSignalQuerySignalName :: forall (m :: * -> *). MonadIO m => SignalQuery -> m ()
    clearSignalQuerySignalName SignalQuery
    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
    $ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO ()) -> IO ())
    -> (Ptr SignalQuery -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        Ptr CString -> CString -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CString
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    8) (CString
    forall a. Ptr a
    FP.nullPtr :: CString)

    #if defined(ENABLE_OVERLOADING)
    data SignalQuerySignalNameFieldInfo
    instance AttrInfo SignalQuerySignalNameFieldInfo where
        type AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQuerySignalNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint SignalQuerySignalNameFieldInfo = (~) CString
        type AttrTransferTypeConstraint SignalQuerySignalNameFieldInfo = (~)CString
        type AttrTransferType SignalQuerySignalNameFieldInfo = CString
        type AttrGetType SignalQuerySignalNameFieldInfo = Maybe T.Text
        type AttrLabel SignalQuerySignalNameFieldInfo = "signal_name"
        type AttrOrigin SignalQuerySignalNameFieldInfo = SignalQuery
        attrGet = getSignalQuerySignalName
        attrSet = setSignalQuerySignalName
        attrConstruct = undefined
        attrClear = clearSignalQuerySignalName
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalName"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalName"
            })

    signalQuery_signalName :: AttrLabelProxy "signalName"
    signalQuery_signalName = AttrLabelProxy

    #endif

    -- | Get the value of the “@itype@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #itype
    -- @
    getSignalQueryItype :: MonadIO m => SignalQuery -> m GType
    getSignalQueryItype :: forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
    getSignalQueryItype SignalQuery
    s = IO GType -> m GType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GType -> m GType) -> IO GType -> m GType
    forall a b. (a -> b) -> a -> b
    $ SignalQuery -> (Ptr SignalQuery -> IO GType) -> IO GType
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO GType) -> IO GType)
    -> (Ptr SignalQuery -> IO GType) -> IO GType
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr CGType -> IO CGType
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CGType
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    16) :: IO CGType
        let val' = CGType -> GType
    GType CGType
    val
        return val'

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

    #if defined(ENABLE_OVERLOADING)
    data SignalQueryItypeFieldInfo
    instance AttrInfo SignalQueryItypeFieldInfo where
        type AttrBaseTypeConstraint SignalQueryItypeFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQueryItypeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SignalQueryItypeFieldInfo = (~) GType
        type AttrTransferTypeConstraint SignalQueryItypeFieldInfo = (~)GType
        type AttrTransferType SignalQueryItypeFieldInfo = GType
        type AttrGetType SignalQueryItypeFieldInfo = GType
        type AttrLabel SignalQueryItypeFieldInfo = "itype"
        type AttrOrigin SignalQueryItypeFieldInfo = SignalQuery
        attrGet = getSignalQueryItype
        attrSet = setSignalQueryItype
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.itype"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:itype"
            })

    signalQuery_itype :: AttrLabelProxy "itype"
    signalQuery_itype = AttrLabelProxy

    #endif

    -- | Get the value of the “@signal_flags@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #signalFlags
    -- @
    getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [GObject.Flags.SignalFlags]
    getSignalQuerySignalFlags :: forall (m :: * -> *). MonadIO m => SignalQuery -> m [SignalFlags]
    getSignalQuerySignalFlags SignalQuery
    s = IO [SignalFlags] -> m [SignalFlags]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [SignalFlags] -> m [SignalFlags])
    -> IO [SignalFlags] -> m [SignalFlags]
    forall a b. (a -> b) -> a -> b
    $ SignalQuery
    -> (Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags]
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags])
    -> (Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags]
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr CUInt -> IO CUInt
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) :: IO CUInt
        let val' = CUInt -> [SignalFlags]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    val
        return val'

    -- | Set the value of the “@signal_flags@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' signalQuery [ #signalFlags 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [GObject.Flags.SignalFlags] -> m ()
    setSignalQuerySignalFlags :: forall (m :: * -> *).
    MonadIO m =>
    SignalQuery -> [SignalFlags] -> m ()
    setSignalQuerySignalFlags SignalQuery
    s [SignalFlags]
    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
    $ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO ()) -> IO ())
    -> (Ptr SignalQuery -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        let val' :: CUInt
    val' = [SignalFlags] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SignalFlags]
    val
        Ptr CUInt -> CUInt -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CUInt
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (CUInt
    val' :: CUInt)

    #if defined(ENABLE_OVERLOADING)
    data SignalQuerySignalFlagsFieldInfo
    instance AttrInfo SignalQuerySignalFlagsFieldInfo where
        type AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQuerySignalFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SignalQuerySignalFlagsFieldInfo = (~) [GObject.Flags.SignalFlags]
        type AttrTransferTypeConstraint SignalQuerySignalFlagsFieldInfo = (~)[GObject.Flags.SignalFlags]
        type AttrTransferType SignalQuerySignalFlagsFieldInfo = [GObject.Flags.SignalFlags]
        type AttrGetType SignalQuerySignalFlagsFieldInfo = [GObject.Flags.SignalFlags]
        type AttrLabel SignalQuerySignalFlagsFieldInfo = "signal_flags"
        type AttrOrigin SignalQuerySignalFlagsFieldInfo = SignalQuery
        attrGet = getSignalQuerySignalFlags
        attrSet = setSignalQuerySignalFlags
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalFlags"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalFlags"
            })

    signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
    signalQuery_signalFlags = AttrLabelProxy

    #endif

    -- | Get the value of the “@return_type@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #returnType
    -- @
    getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType
    getSignalQueryReturnType :: forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
    getSignalQueryReturnType SignalQuery
    s = IO GType -> m GType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GType -> m GType) -> IO GType -> m GType
    forall a b. (a -> b) -> a -> b
    $ SignalQuery -> (Ptr SignalQuery -> IO GType) -> IO GType
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO GType) -> IO GType)
    -> (Ptr SignalQuery -> IO GType) -> IO GType
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr CGType -> IO CGType
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr CGType
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    32) :: IO CGType
        let val' = CGType -> GType
    GType CGType
    val
        return val'

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

    #if defined(ENABLE_OVERLOADING)
    data SignalQueryReturnTypeFieldInfo
    instance AttrInfo SignalQueryReturnTypeFieldInfo where
        type AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQueryReturnTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SignalQueryReturnTypeFieldInfo = (~) GType
        type AttrTransferTypeConstraint SignalQueryReturnTypeFieldInfo = (~)GType
        type AttrTransferType SignalQueryReturnTypeFieldInfo = GType
        type AttrGetType SignalQueryReturnTypeFieldInfo = GType
        type AttrLabel SignalQueryReturnTypeFieldInfo = "return_type"
        type AttrOrigin SignalQueryReturnTypeFieldInfo = SignalQuery
        attrGet = getSignalQueryReturnType
        attrSet = setSignalQueryReturnType
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.returnType"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:returnType"
            })

    signalQuery_returnType :: AttrLabelProxy "returnType"
    signalQuery_returnType = AttrLabelProxy

    #endif

    -- | Get the value of the “@n_params@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' signalQuery #nParams
    -- @
    getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32
    getSignalQueryNParams :: forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
    getSignalQueryNParams SignalQuery
    s = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ SignalQuery -> (Ptr SignalQuery -> IO Word32) -> IO Word32
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr SignalQuery
    s ((Ptr SignalQuery -> IO Word32) -> IO Word32)
    -> (Ptr SignalQuery -> IO Word32) -> IO Word32
    forall a b. (a -> b) -> a -> b
    $ \Ptr SignalQuery
    ptr -> do
        val <- Ptr Word32 -> IO Word32
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr SignalQuery
    ptr Ptr SignalQuery -> Int -> Ptr Word32
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    40) :: IO Word32
        return val

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

    #if defined(ENABLE_OVERLOADING)
    data SignalQueryNParamsFieldInfo
    instance AttrInfo SignalQueryNParamsFieldInfo where
        type AttrBaseTypeConstraint SignalQueryNParamsFieldInfo = (~) SignalQuery
        type AttrAllowedOps SignalQueryNParamsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint SignalQueryNParamsFieldInfo = (~) Word32
        type AttrTransferTypeConstraint SignalQueryNParamsFieldInfo = (~)Word32
        type AttrTransferType SignalQueryNParamsFieldInfo = Word32
        type AttrGetType SignalQueryNParamsFieldInfo = Word32
        type AttrLabel SignalQueryNParamsFieldInfo = "n_params"
        type AttrOrigin SignalQueryNParamsFieldInfo = SignalQuery
        attrGet = getSignalQueryNParams
        attrSet = setSignalQueryNParams
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.nParams"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.31/docs/GI-GObject-Structs-SignalQuery.html#g:attr:nParams"
            })

    signalQuery_nParams :: AttrLabelProxy "nParams"
    signalQuery_nParams = AttrLabelProxy

    #endif

    -- XXX Skipped attribute for "SignalQuery:param_types"
    -- Not implemented: Don't know how to unpack C array of type TCArray False (-1) 5 (TBasicType TGType)

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList SignalQuery
    type instance O.AttributeList SignalQuery = SignalQueryAttributeList
    type SignalQueryAttributeList = ('[ '("signalId", SignalQuerySignalIdFieldInfo), '("signalName", SignalQuerySignalNameFieldInfo), '("itype", SignalQueryItypeFieldInfo), '("signalFlags", SignalQuerySignalFlagsFieldInfo), '("returnType", SignalQueryReturnTypeFieldInfo), '("nParams", SignalQueryNParamsFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif