    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The shadow parameters in a shadow node.

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

    module GI.Gsk.Structs.Shadow
        (

    -- * Exported types
        Shadow(..)                              ,
        newZeroShadow                           ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveShadowMethod                     ,
    #endif

     -- * Properties

    -- ** color #attr:color#
    -- | the color of the shadow

        getShadowColor                          ,
    #if defined(ENABLE_OVERLOADING)
        shadow_color                            ,
    #endif

    -- ** dx #attr:dx#
    -- | the horizontal offset of the shadow

        getShadowDx                             ,
        setShadowDx                             ,
    #if defined(ENABLE_OVERLOADING)
        shadow_dx                               ,
    #endif

    -- ** dy #attr:dy#
    -- | the vertical offset of the shadow

        getShadowDy                             ,
        setShadowDy                             ,
    #if defined(ENABLE_OVERLOADING)
        shadow_dy                               ,
    #endif

    -- ** radius #attr:radius#
    -- | the radius of the shadow

        getShadowRadius                         ,
        setShadowRadius                         ,
    #if defined(ENABLE_OVERLOADING)
        shadow_radius                           ,
    #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 qualified GI.Gdk.Structs.RGBA as Gdk.RGBA

    #else
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA

    #endif

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

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

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

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

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

    -- | Get the value of the “@color@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' shadow #color
    -- @
    getShadowColor :: MonadIO m => Shadow -> m Gdk.RGBA.RGBA
    getShadowColor :: forall (m :: * -> *). MonadIO m => Shadow -> m RGBA
    getShadowColor Shadow
    s = IO RGBA -> m RGBA
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO RGBA -> m RGBA) -> IO RGBA -> m RGBA
    forall a b. (a -> b) -> a -> b
    $ Shadow -> (Ptr Shadow -> IO RGBA) -> IO RGBA
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Shadow
    s ((Ptr Shadow -> IO RGBA) -> IO RGBA)
    -> (Ptr Shadow -> IO RGBA) -> IO RGBA
    forall a b. (a -> b) -> a -> b
    $ \Ptr Shadow
    ptr -> do
        let val :: Ptr RGBA
    val = Ptr Shadow
    ptr Ptr Shadow -> Int -> Ptr RGBA
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    0 :: (Ptr Gdk.RGBA.RGBA)
        val' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr RGBA -> RGBA
    Gdk.RGBA.RGBA) Ptr RGBA
    val
        return val'

    #if defined(ENABLE_OVERLOADING)
    data ShadowColorFieldInfo
    instance AttrInfo ShadowColorFieldInfo where
        type AttrBaseTypeConstraint ShadowColorFieldInfo = (~) Shadow
        type AttrAllowedOps ShadowColorFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ShadowColorFieldInfo = (~) (Ptr Gdk.RGBA.RGBA)
        type AttrTransferTypeConstraint ShadowColorFieldInfo = (~)(Ptr Gdk.RGBA.RGBA)
        type AttrTransferType ShadowColorFieldInfo = (Ptr Gdk.RGBA.RGBA)
        type AttrGetType ShadowColorFieldInfo = Gdk.RGBA.RGBA
        type AttrLabel ShadowColorFieldInfo = "color"
        type AttrOrigin ShadowColorFieldInfo = Shadow
        attrGet = getShadowColor
        attrSet = undefined
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.color"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Shadow.html#g:attr:color"
            })

    shadow_color :: AttrLabelProxy "color"
    shadow_color = AttrLabelProxy

    #endif

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

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

    #if defined(ENABLE_OVERLOADING)
    data ShadowDxFieldInfo
    instance AttrInfo ShadowDxFieldInfo where
        type AttrBaseTypeConstraint ShadowDxFieldInfo = (~) Shadow
        type AttrAllowedOps ShadowDxFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ShadowDxFieldInfo = (~) Float
        type AttrTransferTypeConstraint ShadowDxFieldInfo = (~)Float
        type AttrTransferType ShadowDxFieldInfo = Float
        type AttrGetType ShadowDxFieldInfo = Float
        type AttrLabel ShadowDxFieldInfo = "dx"
        type AttrOrigin ShadowDxFieldInfo = Shadow
        attrGet = getShadowDx
        attrSet = setShadowDx
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.dx"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Shadow.html#g:attr:dx"
            })

    shadow_dx :: AttrLabelProxy "dx"
    shadow_dx = AttrLabelProxy

    #endif

    -- | Get the value of the “@dy@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' shadow #dy
    -- @
    getShadowDy :: MonadIO m => Shadow -> m Float
    getShadowDy :: forall (m :: * -> *). MonadIO m => Shadow -> m Float
    getShadowDy Shadow
    s = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ Shadow -> (Ptr Shadow -> IO Float) -> IO Float
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Shadow
    s ((Ptr Shadow -> IO Float) -> IO Float)
    -> (Ptr Shadow -> IO Float) -> IO Float
    forall a b. (a -> b) -> a -> b
    $ \Ptr Shadow
    ptr -> do
        val <- Ptr CFloat -> IO CFloat
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Shadow
    ptr Ptr Shadow -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    20) :: IO CFloat
        let val' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    val
        return val'

    -- | Set the value of the “@dy@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' shadow [ #dy 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setShadowDy :: MonadIO m => Shadow -> Float -> m ()
    setShadowDy :: forall (m :: * -> *). MonadIO m => Shadow -> Float -> m ()
    setShadowDy Shadow
    s Float
    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
    $ Shadow -> (Ptr Shadow -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Shadow
    s ((Ptr Shadow -> IO ()) -> IO ()) -> (Ptr Shadow -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Shadow
    ptr -> do
        let val' :: CFloat
    val' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    val
        Ptr CFloat -> CFloat -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Shadow
    ptr Ptr Shadow -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    20) (CFloat
    val' :: CFloat)

    #if defined(ENABLE_OVERLOADING)
    data ShadowDyFieldInfo
    instance AttrInfo ShadowDyFieldInfo where
        type AttrBaseTypeConstraint ShadowDyFieldInfo = (~) Shadow
        type AttrAllowedOps ShadowDyFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ShadowDyFieldInfo = (~) Float
        type AttrTransferTypeConstraint ShadowDyFieldInfo = (~)Float
        type AttrTransferType ShadowDyFieldInfo = Float
        type AttrGetType ShadowDyFieldInfo = Float
        type AttrLabel ShadowDyFieldInfo = "dy"
        type AttrOrigin ShadowDyFieldInfo = Shadow
        attrGet = getShadowDy
        attrSet = setShadowDy
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.dy"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Shadow.html#g:attr:dy"
            })

    shadow_dy :: AttrLabelProxy "dy"
    shadow_dy = AttrLabelProxy

    #endif

    -- | Get the value of the “@radius@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' shadow #radius
    -- @
    getShadowRadius :: MonadIO m => Shadow -> m Float
    getShadowRadius :: forall (m :: * -> *). MonadIO m => Shadow -> m Float
    getShadowRadius Shadow
    s = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ Shadow -> (Ptr Shadow -> IO Float) -> IO Float
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Shadow
    s ((Ptr Shadow -> IO Float) -> IO Float)
    -> (Ptr Shadow -> IO Float) -> IO Float
    forall a b. (a -> b) -> a -> b
    $ \Ptr Shadow
    ptr -> do
        val <- Ptr CFloat -> IO CFloat
    forall a. Storable a => Ptr a -> IO a
    peek (Ptr Shadow
    ptr Ptr Shadow -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) :: IO CFloat
        let val' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    val
        return val'

    -- | Set the value of the “@radius@” field.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' shadow [ #radius 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setShadowRadius :: MonadIO m => Shadow -> Float -> m ()
    setShadowRadius :: forall (m :: * -> *). MonadIO m => Shadow -> Float -> m ()
    setShadowRadius Shadow
    s Float
    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
    $ Shadow -> (Ptr Shadow -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    withManagedPtr Shadow
    s ((Ptr Shadow -> IO ()) -> IO ()) -> (Ptr Shadow -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Shadow
    ptr -> do
        let val' :: CFloat
    val' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    val
        Ptr CFloat -> CFloat -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke (Ptr Shadow
    ptr Ptr Shadow -> Int -> Ptr CFloat
    forall a b. Ptr a -> Int -> Ptr b
    `plusPtr` Int
    24) (CFloat
    val' :: CFloat)

    #if defined(ENABLE_OVERLOADING)
    data ShadowRadiusFieldInfo
    instance AttrInfo ShadowRadiusFieldInfo where
        type AttrBaseTypeConstraint ShadowRadiusFieldInfo = (~) Shadow
        type AttrAllowedOps ShadowRadiusFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ShadowRadiusFieldInfo = (~) Float
        type AttrTransferTypeConstraint ShadowRadiusFieldInfo = (~)Float
        type AttrTransferType ShadowRadiusFieldInfo = Float
        type AttrGetType ShadowRadiusFieldInfo = Float
        type AttrLabel ShadowRadiusFieldInfo = "radius"
        type AttrOrigin ShadowRadiusFieldInfo = Shadow
        attrGet = getShadowRadius
        attrSet = setShadowRadius
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Shadow.radius"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Shadow.html#g:attr:radius"
            })

    shadow_radius :: AttrLabelProxy "radius"
    shadow_radius = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Shadow
    type instance O.AttributeList Shadow = ShadowAttributeList
    type ShadowAttributeList = ('[ '("color", ShadowColorFieldInfo), '("dx", ShadowDxFieldInfo), '("dy", ShadowDyFieldInfo), '("radius", ShadowRadiusFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif