    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A paintable implementation that renders SVG, with animations.
    --
    -- @GtkSvg@ objects are created by parsing a subset of SVG,
    -- including SVG animations.
    --
    -- @GtkSvg@ fills or strokes paths with symbolic or fixed colors.
    -- It can have multiple states, and paths can be included in a subset
    -- of the states. States can have animations, and the transition
    -- between different states can also be animated.
    --
    -- To show a static SVG image, it is enough to load the
    -- the SVG and use it like any other paintable.
    --
    -- To play an SVG animation, use 'GI.Gtk.Objects.Svg.svgSetFrameClock'
    -- to connect the paintable to a frame clock, and call
    -- 'GI.Gtk.Objects.Svg.svgPlay' after loading the SVG. The animation can
    -- be paused using 'GI.Gtk.Objects.Svg.svgPause'.
    --
    -- To set the current state, use 'GI.Gtk.Objects.Svg.svgSetState'.
    --
    --
    -- == Error handling
    --
    -- Loading an SVG into @GtkSvg@ will always produce a (possibly empty)
    -- paintable. GTK will drop things that it can\'t handle and try to make
    -- sense of the rest.
    --
    -- To track errors during parsing or rendering, connect to the
    -- [Svg::error]("GI.Gtk.Objects.Svg#g:signal:error") signal.
    --
    -- For parsing errors in the @GTK_SVG_ERROR@ domain, the functions
    -- t'GI.Gtk.Enums.SvgError'.@/get_start/@(), t'GI.Gtk.Enums.SvgError'.@/get_end/@(),
    -- t'GI.Gtk.Enums.SvgError'.@/get_element/@() and t'GI.Gtk.Enums.SvgError'.@/get_attribute/@()
    -- can be used to obtain information about where the error occurred.
    --
    --
    -- == The supported subset of SVG
    --
    -- The paintable supports much of <https://svgwg.org/svg2-draft/ SVG 2>,
    -- including <https://svgwg.org/specs/animations/ animations>, with some
    -- exceptions.
    --
    -- Among the graphical elements, @\<textPath>@ and @\<foreignObject>@ are
    -- not supported.
    --
    -- In the @\<filter>@ element, the following primitives are not supported:
    -- feConvolveMatrix, feDiffuseLighting, feMorphology, feSpecularLighting.
    --
    -- Support for the @mask@ attribute is limited to just a url referring to
    -- the @\<mask>@ element by ID.
    --
    -- In animation elements, the parsing of @begin@ and @end@ attributes is
    -- limited, and the @min@ and @max@ attributes are not supported.
    --
    -- The interactive aspects of SVG are supported by t'GI.Gtk.Objects.SvgWidget.SvgWidget'.
    --
    --
    -- == SVG Extensions
    --
    -- The paintable supports a number of <https://docs.gtk.org/gtk4/icon-format.html custom attributes>
    -- that offer a convenient way to define states, transitions and animations.
    -- For example,
    --
    --     \<circle cx=\'5\' cy=\'5\' r=\'5\'
    --             gpa:states=\'0 1\'
    --             gpa:animation-type=\'automatic\'
    --             gpa:animation-direction=\'segment\'
    --             gpa:animation-duration=\'600ms\'\/>
    --
    -- defines the circle to be shown in states 0 and 1, and animates a segment
    -- of the circle.
    --
    --
    -- \<image src=\"svg-renderer1.svg\">
    --
    -- Note that the generated animations are implemented using standard
    -- SVG attributes (@visibility@, @stroke-dasharray, @stroke-dashoffset@,
    -- @pathLength@ and @filter@). Setting these attributes in your SVG
    -- is therefore going to interfere with generated animations.
    --
    -- To connect general SVG animations to the states of the paintable,
    -- use the custom @StateChange(...)@ condition in the @begin@ and @end@
    -- attributes of SVG animation elements. For example,
    --
    --     \<animate href=\'path1\'
    --              attributeName=\'fill\'
    --              begin=\'StateChange(1 2 3, 0)\'
    --              dur=\'300ms\'
    --              fill=\'freeze\'
    --              from=\'black\'
    --              to=\'magenta\'\/>
    --
    -- will make the fill color of path1 transition from black to
    -- magenta when the renderer enters state 0 from states 1, 2, or 3.
    --
    -- \<image src=\"svg-renderer2.svg\">
    --
    -- The @StateChange(...)@ condition triggers for upcoming state changes
    -- as well, to support fade-out transitions. For example,
    --
    --     \<animate href=\'path1\'
    --              attributeName=\'opacity\'
    --              begin=\'StateChange(0, 1 2 3) -300ms\'
    --              dur=\'300ms\'
    --              fill=\'freeze\'
    --              from=\'1\'
    --              to=\'0\'\/>
    --
    -- will start a fade-out of path1 300ms before a transition from state
    -- 0 to 1, 2 or 3.
    --
    -- States can be specified numerically, or by name. It is also possible
    -- to say @not STATE@ instead of explictly listing all states that are
    -- different from @STATE@.
    --
    -- In addition to the @gpa:fill@ and @gpa:stroke@ attributes, symbolic
    -- colors can also be specified as a custom paint server reference,
    -- like this: @url(@/gpa:warning/@)@. This works in @fill@ and @stroke@
    -- attributes, but also when specifying colors in SVG animation
    -- attributes like @to@ or @values@.
    --
    -- Note that the SVG syntax allows for a fallback RGB color to be
    -- specified after the url, for compatibility with other SVG consumers:
    --
    --     fill=\'url(#gpa:warning) orange\'
    --
    -- GtkSvg also allows to refer to symbolic colors like system colors
    -- in CSS, with names like SymbolicForeground, SymbolicSuccess, etc.
    -- These can be used whenever a color is required.
    --
    -- In contrast to SVG 1.1 and 2.0, we allow the @transform@ attribute
    -- to be animated with @\<animate>\`.
    --
    -- /Since: 4.22/

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

    module GI.Gtk.Objects.Svg
        (

    -- * Exported types
        Svg(..)                                 ,
        IsSvg                                   ,
        toSvg                                   ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [computeConcreteSize]("GI.Gdk.Interfaces.Paintable#g:method:computeConcreteSize"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [invalidateContents]("GI.Gdk.Interfaces.Paintable#g:method:invalidateContents"), [invalidateSize]("GI.Gdk.Interfaces.Paintable#g:method:invalidateSize"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [loadFromBytes]("GI.Gtk.Objects.Svg#g:method:loadFromBytes"), [loadFromResource]("GI.Gtk.Objects.Svg#g:method:loadFromResource"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [pause]("GI.Gtk.Objects.Svg#g:method:pause"), [play]("GI.Gtk.Objects.Svg#g:method:play"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [serialize]("GI.Gtk.Objects.Svg#g:method:serialize"), [snapshot]("GI.Gdk.Interfaces.Paintable#g:method:snapshot"), [snapshotSymbolic]("GI.Gtk.Interfaces.SymbolicPaintable#g:method:snapshotSymbolic"), [snapshotWithWeight]("GI.Gtk.Interfaces.SymbolicPaintable#g:method:snapshotWithWeight"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [writeToFile]("GI.Gtk.Objects.Svg#g:method:writeToFile").
    --
    -- ==== Getters
    -- [getCurrentImage]("GI.Gdk.Interfaces.Paintable#g:method:getCurrentImage"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFeatures]("GI.Gtk.Objects.Svg#g:method:getFeatures"), [getFlags]("GI.Gdk.Interfaces.Paintable#g:method:getFlags"), [getIntrinsicAspectRatio]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicAspectRatio"), [getIntrinsicHeight]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicHeight"), [getIntrinsicWidth]("GI.Gdk.Interfaces.Paintable#g:method:getIntrinsicWidth"), [getOverflow]("GI.Gtk.Objects.Svg#g:method:getOverflow"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getState]("GI.Gtk.Objects.Svg#g:method:getState"), [getStateNames]("GI.Gtk.Objects.Svg#g:method:getStateNames"), [getStylesheet]("GI.Gtk.Objects.Svg#g:method:getStylesheet"), [getWeight]("GI.Gtk.Objects.Svg#g:method:getWeight").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFeatures]("GI.Gtk.Objects.Svg#g:method:setFeatures"), [setFrameClock]("GI.Gtk.Objects.Svg#g:method:setFrameClock"), [setOverflow]("GI.Gtk.Objects.Svg#g:method:setOverflow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSettings]("GI.Gtk.Objects.Svg#g:method:setSettings"), [setState]("GI.Gtk.Objects.Svg#g:method:setState"), [setStylesheet]("GI.Gtk.Objects.Svg#g:method:setStylesheet"), [setWeight]("GI.Gtk.Objects.Svg#g:method:setWeight").

    #if defined(ENABLE_OVERLOADING)
        ResolveSvgMethod                        ,
    #endif

    -- ** getFeatures #method:getFeatures#

    #if defined(ENABLE_OVERLOADING)
        SvgGetFeaturesMethodInfo                ,
    #endif
        svgGetFeatures                          ,

    -- ** getOverflow #method:getOverflow#

    #if defined(ENABLE_OVERLOADING)
        SvgGetOverflowMethodInfo                ,
    #endif
        svgGetOverflow                          ,

    -- ** getState #method:getState#

    #if defined(ENABLE_OVERLOADING)
        SvgGetStateMethodInfo                   ,
    #endif
        svgGetState                             ,

    -- ** getStateNames #method:getStateNames#

    #if defined(ENABLE_OVERLOADING)
        SvgGetStateNamesMethodInfo              ,
    #endif
        svgGetStateNames                        ,

    -- ** getStylesheet #method:getStylesheet#

    #if defined(ENABLE_OVERLOADING)
        SvgGetStylesheetMethodInfo              ,
    #endif
        svgGetStylesheet                        ,

    -- ** getWeight #method:getWeight#

    #if defined(ENABLE_OVERLOADING)
        SvgGetWeightMethodInfo                  ,
    #endif
        svgGetWeight                            ,

    -- ** loadFromBytes #method:loadFromBytes#

    #if defined(ENABLE_OVERLOADING)
        SvgLoadFromBytesMethodInfo              ,
    #endif
        svgLoadFromBytes                        ,

    -- ** loadFromResource #method:loadFromResource#

    #if defined(ENABLE_OVERLOADING)
        SvgLoadFromResourceMethodInfo           ,
    #endif
        svgLoadFromResource                     ,

    -- ** new #method:new#

        svgNew                                  ,

    -- ** newFromBytes #method:newFromBytes#

        svgNewFromBytes                         ,

    -- ** newFromResource #method:newFromResource#

        svgNewFromResource                      ,

    -- ** pause #method:pause#

    #if defined(ENABLE_OVERLOADING)
        SvgPauseMethodInfo                      ,
    #endif
        svgPause                                ,

    -- ** play #method:play#

    #if defined(ENABLE_OVERLOADING)
        SvgPlayMethodInfo                       ,
    #endif
        svgPlay                                 ,

    -- ** serialize #method:serialize#

    #if defined(ENABLE_OVERLOADING)
        SvgSerializeMethodInfo                  ,
    #endif
        svgSerialize                            ,

    -- ** setFeatures #method:setFeatures#

    #if defined(ENABLE_OVERLOADING)
        SvgSetFeaturesMethodInfo                ,
    #endif
        svgSetFeatures                          ,

    -- ** setFrameClock #method:setFrameClock#

    #if defined(ENABLE_OVERLOADING)
        SvgSetFrameClockMethodInfo              ,
    #endif
        svgSetFrameClock                        ,

    -- ** setOverflow #method:setOverflow#

    #if defined(ENABLE_OVERLOADING)
        SvgSetOverflowMethodInfo                ,
    #endif
        svgSetOverflow                          ,

    -- ** setSettings #method:setSettings#

    #if defined(ENABLE_OVERLOADING)
        SvgSetSettingsMethodInfo                ,
    #endif
        svgSetSettings                          ,

    -- ** setState #method:setState#

    #if defined(ENABLE_OVERLOADING)
        SvgSetStateMethodInfo                   ,
    #endif
        svgSetState                             ,

    -- ** setStylesheet #method:setStylesheet#

    #if defined(ENABLE_OVERLOADING)
        SvgSetStylesheetMethodInfo              ,
    #endif
        svgSetStylesheet                        ,

    -- ** setWeight #method:setWeight#

    #if defined(ENABLE_OVERLOADING)
        SvgSetWeightMethodInfo                  ,
    #endif
        svgSetWeight                            ,

    -- ** writeToFile #method:writeToFile#

    #if defined(ENABLE_OVERLOADING)
        SvgWriteToFileMethodInfo                ,
    #endif
        svgWriteToFile                          ,

     -- * Properties

    -- ** features #attr:features#
    -- | Enabled features for this paintable.
    --
    -- Note that features have to be set before
    -- loading SVG data to take effect.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        SvgFeaturesPropertyInfo                 ,
    #endif
        constructSvgFeatures                    ,
        getSvgFeatures                          ,
        setSvgFeatures                          ,
    #if defined(ENABLE_OVERLOADING)
        svgFeatures                             ,
    #endif

    -- ** overflow #attr:overflow#
    -- | Whether the rendering will be clipped to the bounds.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        SvgOverflowPropertyInfo                 ,
    #endif
        constructSvgOverflow                    ,
        getSvgOverflow                          ,
        setSvgOverflow                          ,
    #if defined(ENABLE_OVERLOADING)
        svgOverflow                             ,
    #endif

    -- ** playing #attr:playing#
    -- | Whether the paintable is currently animating its content.
    --
    -- To set this property, use the 'GI.Gtk.Objects.Svg.svgPlay' and
    -- 'GI.Gtk.Objects.Svg.svgPause' functions.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        SvgPlayingPropertyInfo                  ,
    #endif
        constructSvgPlaying                     ,
        getSvgPlaying                           ,
        setSvgPlaying                           ,
    #if defined(ENABLE_OVERLOADING)
        svgPlaying                              ,
    #endif

    -- ** resource #attr:resource#
    -- | Resource to load SVG data from.
    --
    -- This property is meant to create a paintable
    -- from a resource in ui files.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        SvgResourcePropertyInfo                 ,
    #endif
        clearSvgResource                        ,
        constructSvgResource                    ,
        getSvgResource                          ,
        setSvgResource                          ,
    #if defined(ENABLE_OVERLOADING)
        svgResource                             ,
    #endif

    -- ** state #attr:state#
    -- | The current state of the renderer.
    --
    -- This can be a number between 0 and 63.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        SvgStatePropertyInfo                    ,
    #endif
        constructSvgState                       ,
        getSvgState                             ,
        setSvgState                             ,
    #if defined(ENABLE_OVERLOADING)
        svgState                                ,
    #endif

    -- ** stylesheet #attr:stylesheet#
    -- | A CSS stylesheet to apply to the SVG.
    --
    -- /Since: 4.24/

    #if defined(ENABLE_OVERLOADING)
        SvgStylesheetPropertyInfo               ,
    #endif
        clearSvgStylesheet                      ,
        constructSvgStylesheet                  ,
        getSvgStylesheet                        ,
        setSvgStylesheet                        ,
    #if defined(ENABLE_OVERLOADING)
        svgStylesheet                           ,
    #endif

    -- ** weight #attr:weight#
    -- | If not set to -1, this value overrides the weight used
    -- when rendering the paintable.
    --
    -- /Since: 4.22/

    #if defined(ENABLE_OVERLOADING)
        SvgWeightPropertyInfo                   ,
    #endif
        constructSvgWeight                      ,
        getSvgWeight                            ,
        setSvgWeight                            ,
    #if defined(ENABLE_OVERLOADING)
        svgWeight                               ,
    #endif

     -- * Signals

    -- ** error #signal:error#

        SvgErrorCallback                        ,
    #if defined(ENABLE_OVERLOADING)
        SvgErrorSignalInfo                      ,
    #endif
        afterSvgError                           ,
        onSvgError                              ,

        ) 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.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.Display as Gdk.Display
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import qualified GI.Gdk.Objects.Snapshot as Gdk.Snapshot
    import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SymbolicPaintable as Gtk.SymbolicPaintable
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings

    #else
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gdk.Interfaces.Paintable as Gdk.Paintable
    import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
    import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
    import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
    import {-# SOURCE #-} qualified GI.Gtk.Interfaces.SymbolicPaintable as Gtk.SymbolicPaintable
    import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings

    #endif

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

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

    foreign import ccall "gtk_svg_get_type"
        c_gtk_svg_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Svg where
        glibType :: IO GType
    glibType = IO GType
    c_gtk_svg_get_type

    instance B.Types.GObject Svg

    -- | Type class for types which can be safely cast to t'Svg', for instance with `toSvg`.
    class (SP.GObject o, O.IsDescendantOf Svg o) => IsSvg o
    instance (SP.GObject o, O.IsDescendantOf Svg o) => IsSvg o

    instance O.HasParentTypes Svg
    type instance O.ParentTypes Svg = '[GObject.Object.Object, Gdk.Paintable.Paintable, Gtk.SymbolicPaintable.SymbolicPaintable]

    -- | Cast to t'Svg', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'.
    toSvg :: (MIO.MonadIO m, IsSvg o) => o -> m Svg
    toSvg :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m Svg
    toSvg = IO Svg -> m Svg
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Svg -> m Svg) -> (o -> IO Svg) -> o -> m Svg
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr Svg -> Svg) -> o -> IO Svg
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    B.ManagedPtr.unsafeCastTo ManagedPtr Svg -> Svg
    Svg

    -- | Convert t'Svg' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe Svg) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_gtk_svg_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Svg -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Svg
    P.Nothing = Ptr GValue -> Ptr Svg -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr Svg
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Svg)
        gvalueSet_ Ptr GValue
    gv (P.Just Svg
    obj) = Svg -> (Ptr Svg -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Svg
    obj (Ptr GValue -> Ptr Svg -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Svg)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr Svg)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr Svg)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newObject Svg ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveSvgMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveSvgMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveSvgMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveSvgMethod "computeConcreteSize" o = Gdk.Paintable.PaintableComputeConcreteSizeMethodInfo
        ResolveSvgMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveSvgMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveSvgMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveSvgMethod "invalidateContents" o = Gdk.Paintable.PaintableInvalidateContentsMethodInfo
        ResolveSvgMethod "invalidateSize" o = Gdk.Paintable.PaintableInvalidateSizeMethodInfo
        ResolveSvgMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveSvgMethod "loadFromBytes" o = SvgLoadFromBytesMethodInfo
        ResolveSvgMethod "loadFromResource" o = SvgLoadFromResourceMethodInfo
        ResolveSvgMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveSvgMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveSvgMethod "pause" o = SvgPauseMethodInfo
        ResolveSvgMethod "play" o = SvgPlayMethodInfo
        ResolveSvgMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveSvgMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveSvgMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveSvgMethod "serialize" o = SvgSerializeMethodInfo
        ResolveSvgMethod "snapshot" o = Gdk.Paintable.PaintableSnapshotMethodInfo
        ResolveSvgMethod "snapshotSymbolic" o = Gtk.SymbolicPaintable.SymbolicPaintableSnapshotSymbolicMethodInfo
        ResolveSvgMethod "snapshotWithWeight" o = Gtk.SymbolicPaintable.SymbolicPaintableSnapshotWithWeightMethodInfo
        ResolveSvgMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveSvgMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveSvgMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveSvgMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveSvgMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveSvgMethod "writeToFile" o = SvgWriteToFileMethodInfo
        ResolveSvgMethod "getCurrentImage" o = Gdk.Paintable.PaintableGetCurrentImageMethodInfo
        ResolveSvgMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveSvgMethod "getFeatures" o = SvgGetFeaturesMethodInfo
        ResolveSvgMethod "getFlags" o = Gdk.Paintable.PaintableGetFlagsMethodInfo
        ResolveSvgMethod "getIntrinsicAspectRatio" o = Gdk.Paintable.PaintableGetIntrinsicAspectRatioMethodInfo
        ResolveSvgMethod "getIntrinsicHeight" o = Gdk.Paintable.PaintableGetIntrinsicHeightMethodInfo
        ResolveSvgMethod "getIntrinsicWidth" o = Gdk.Paintable.PaintableGetIntrinsicWidthMethodInfo
        ResolveSvgMethod "getOverflow" o = SvgGetOverflowMethodInfo
        ResolveSvgMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveSvgMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveSvgMethod "getState" o = SvgGetStateMethodInfo
        ResolveSvgMethod "getStateNames" o = SvgGetStateNamesMethodInfo
        ResolveSvgMethod "getStylesheet" o = SvgGetStylesheetMethodInfo
        ResolveSvgMethod "getWeight" o = SvgGetWeightMethodInfo
        ResolveSvgMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveSvgMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveSvgMethod "setFeatures" o = SvgSetFeaturesMethodInfo
        ResolveSvgMethod "setFrameClock" o = SvgSetFrameClockMethodInfo
        ResolveSvgMethod "setOverflow" o = SvgSetOverflowMethodInfo
        ResolveSvgMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveSvgMethod "setSettings" o = SvgSetSettingsMethodInfo
        ResolveSvgMethod "setState" o = SvgSetStateMethodInfo
        ResolveSvgMethod "setStylesheet" o = SvgSetStylesheetMethodInfo
        ResolveSvgMethod "setWeight" o = SvgSetWeightMethodInfo
        ResolveSvgMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

    -- signal Svg::error
    -- | Signals that an error occurred.
    --
    -- Errors can occur both during parsing and during rendering.
    --
    -- The expected error values are in the [error/@gtk@/.SvgError] enumeration,
    -- context information about the location of parsing errors can
    -- be obtained with the various @gtk_svg_error@ functions.
    --
    -- Parsing errors are never fatal, so the parsing will resume after
    -- the error. Errors may however cause parts of the given data or
    -- even all of it to not be parsed at all. So it is a useful idea
    -- to check that the parsing succeeds by connecting to this signal.
    --
    -- ::: note
    --     This signal is emitted in the middle of parsing or rendering,
    --     and if you handle it, you must be careful. Logging the errors
    --     you receive is fine, but modifying the widget hierarchy or
    --     changing the paintable state definitively isn\'t.
    --
    --     If in doubt, defer to an idle.
    --
    -- /Since: 4.22/
    type SvgErrorCallback =
        GError
        -- ^ /@error@/: the error
        -> IO ()

    type C_SvgErrorCallback =
        Ptr Svg ->                              -- object
        Ptr GError ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_SvgErrorCallback`.
    foreign import ccall "wrapper"
        mk_SvgErrorCallback :: C_SvgErrorCallback -> IO (FunPtr C_SvgErrorCallback)

    wrap_SvgErrorCallback ::
        GObject a => (a -> SvgErrorCallback) ->
        C_SvgErrorCallback
    wrap_SvgErrorCallback :: forall a.
    GObject a =>
    (a -> SvgErrorCallback) -> C_SvgErrorCallback
    wrap_SvgErrorCallback a -> SvgErrorCallback
    gi'cb Ptr Svg
    gi'selfPtr Ptr GError
    error_ Ptr ()
    _ = do
        error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr GError -> GError
    GError) Ptr GError
    error_
        B.ManagedPtr.withNewObject gi'selfPtr $ \Svg
    gi'self -> a -> SvgErrorCallback
    gi'cb (Svg -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Svg
    gi'self)  GError
    error_'

    -- | Connect a signal handler for the [error](#signal:error) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' svg #error callback
    -- @
    --
    --
    onSvgError :: (IsSvg a, MonadIO m) => a -> ((?self :: a) => SvgErrorCallback) -> m SignalHandlerId
    onSvgError :: forall a (m :: * -> *).
    (IsSvg a, MonadIO m) =>
    a -> ((?self::a) => SvgErrorCallback) -> m SignalHandlerId
    onSvgError a
    obj (?self::a) => SvgErrorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgErrorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgErrorCallback
    SvgErrorCallback
    cb
        let wrapped' :: C_SvgErrorCallback
    wrapped' = (a -> SvgErrorCallback) -> C_SvgErrorCallback
    forall a.
    GObject a =>
    (a -> SvgErrorCallback) -> C_SvgErrorCallback
    wrap_SvgErrorCallback a -> SvgErrorCallback
    wrapped
        wrapped'' <- C_SvgErrorCallback -> IO (FunPtr C_SvgErrorCallback)
    mk_SvgErrorCallback C_SvgErrorCallback
    wrapped'
        connectSignalFunPtr obj "error" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [error](#signal:error) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' svg #error callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterSvgError :: (IsSvg a, MonadIO m) => a -> ((?self :: a) => SvgErrorCallback) -> m SignalHandlerId
    afterSvgError :: forall a (m :: * -> *).
    (IsSvg a, MonadIO m) =>
    a -> ((?self::a) => SvgErrorCallback) -> m SignalHandlerId
    afterSvgError a
    obj (?self::a) => SvgErrorCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> SvgErrorCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => SvgErrorCallback
    SvgErrorCallback
    cb
        let wrapped' :: C_SvgErrorCallback
    wrapped' = (a -> SvgErrorCallback) -> C_SvgErrorCallback
    forall a.
    GObject a =>
    (a -> SvgErrorCallback) -> C_SvgErrorCallback
    wrap_SvgErrorCallback a -> SvgErrorCallback
    wrapped
        wrapped'' <- C_SvgErrorCallback -> IO (FunPtr C_SvgErrorCallback)
    mk_SvgErrorCallback C_SvgErrorCallback
    wrapped'
        connectSignalFunPtr obj "error" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data SvgErrorSignalInfo
    instance SignalInfo SvgErrorSignalInfo where
        type HaskellCallbackType SvgErrorSignalInfo = SvgErrorCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_SvgErrorCallback cb
            cb'' <- mk_SvgErrorCallback cb'
            connectSignalFunPtr obj "error" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg::error"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:signal:error"})

    #endif

    -- VVV Prop "features"
       -- Type: TInterface (Name {namespace = "Gtk", name = "SvgFeatures"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@features@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #features
    -- @
    getSvgFeatures :: (MonadIO m, IsSvg o) => o -> m [Gtk.Flags.SvgFeatures]
    getSvgFeatures :: forall (m :: * -> *) o.
    (MonadIO m, IsSvg o) =>
    o -> m [SvgFeatures]
    getSvgFeatures o
    obj = IO [SvgFeatures] -> m [SvgFeatures]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO [SvgFeatures] -> m [SvgFeatures])
    -> IO [SvgFeatures] -> m [SvgFeatures]
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO [SvgFeatures]
    forall a b.
    (GObject a, IsGFlag b, BoxedFlags b) =>
    a -> String -> IO [b]
    B.Properties.getObjectPropertyFlags o
    obj String
    "features"

    -- | Set the value of the “@features@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #features 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgFeatures :: (MonadIO m, IsSvg o) => o -> [Gtk.Flags.SvgFeatures] -> m ()
    setSvgFeatures :: forall (m :: * -> *) o.
    (MonadIO m, IsSvg o) =>
    o -> [SvgFeatures] -> m ()
    setSvgFeatures o
    obj [SvgFeatures]
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> [SvgFeatures] -> IO ()
    forall a b.
    (IsGFlag b, BoxedFlags b, GObject a) =>
    a -> String -> [b] -> IO ()
    B.Properties.setObjectPropertyFlags o
    obj String
    "features" [SvgFeatures]
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@features@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgFeatures :: (IsSvg o, MIO.MonadIO m) => [Gtk.Flags.SvgFeatures] -> m (GValueConstruct o)
    constructSvgFeatures :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    [SvgFeatures] -> m (GValueConstruct o)
    constructSvgFeatures [SvgFeatures]
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> [SvgFeatures] -> IO (GValueConstruct o)
    forall a o.
    (IsGFlag a, BoxedFlags a) =>
    String -> [a] -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyFlags String
    "features" [SvgFeatures]
    val

    #if defined(ENABLE_OVERLOADING)
    data SvgFeaturesPropertyInfo
    instance AttrInfo SvgFeaturesPropertyInfo where
        type AttrAllowedOps SvgFeaturesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgFeaturesPropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgFeaturesPropertyInfo = (~) [Gtk.Flags.SvgFeatures]
        type AttrTransferTypeConstraint SvgFeaturesPropertyInfo = (~) [Gtk.Flags.SvgFeatures]
        type AttrTransferType SvgFeaturesPropertyInfo = [Gtk.Flags.SvgFeatures]
        type AttrGetType SvgFeaturesPropertyInfo = [Gtk.Flags.SvgFeatures]
        type AttrLabel SvgFeaturesPropertyInfo = "features"
        type AttrOrigin SvgFeaturesPropertyInfo = Svg
        attrGet = getSvgFeatures
        attrSet = setSvgFeatures
        attrPut = setSvgFeatures
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgFeatures
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.features"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:features"
            })
    #endif

    -- VVV Prop "overflow"
       -- Type: TInterface (Name {namespace = "Gtk", name = "Overflow"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@overflow@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #overflow
    -- @
    getSvgOverflow :: (MonadIO m, IsSvg o) => o -> m Gtk.Enums.Overflow
    getSvgOverflow :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m Overflow
    getSvgOverflow o
    obj = IO Overflow -> m Overflow
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Overflow -> m Overflow) -> IO Overflow -> m Overflow
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Overflow
    forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
    B.Properties.getObjectPropertyEnum o
    obj String
    "overflow"

    -- | Set the value of the “@overflow@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #overflow 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgOverflow :: (MonadIO m, IsSvg o) => o -> Gtk.Enums.Overflow -> m ()
    setSvgOverflow :: forall (m :: * -> *) o.
    (MonadIO m, IsSvg o) =>
    o -> Overflow -> m ()
    setSvgOverflow o
    obj Overflow
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Overflow -> IO ()
    forall a b.
    (GObject a, Enum b, BoxedEnum b) =>
    a -> String -> b -> IO ()
    B.Properties.setObjectPropertyEnum o
    obj String
    "overflow" Overflow
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@overflow@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgOverflow :: (IsSvg o, MIO.MonadIO m) => Gtk.Enums.Overflow -> m (GValueConstruct o)
    constructSvgOverflow :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Overflow -> m (GValueConstruct o)
    constructSvgOverflow Overflow
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Overflow -> IO (GValueConstruct o)
    forall a o.
    (Enum a, BoxedEnum a) =>
    String -> a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyEnum String
    "overflow" Overflow
    val

    #if defined(ENABLE_OVERLOADING)
    data SvgOverflowPropertyInfo
    instance AttrInfo SvgOverflowPropertyInfo where
        type AttrAllowedOps SvgOverflowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgOverflowPropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgOverflowPropertyInfo = (~) Gtk.Enums.Overflow
        type AttrTransferTypeConstraint SvgOverflowPropertyInfo = (~) Gtk.Enums.Overflow
        type AttrTransferType SvgOverflowPropertyInfo = Gtk.Enums.Overflow
        type AttrGetType SvgOverflowPropertyInfo = Gtk.Enums.Overflow
        type AttrLabel SvgOverflowPropertyInfo = "overflow"
        type AttrOrigin SvgOverflowPropertyInfo = Svg
        attrGet = getSvgOverflow
        attrSet = setSvgOverflow
        attrPut = setSvgOverflow
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgOverflow
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.overflow"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:overflow"
            })
    #endif

    -- VVV Prop "playing"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@playing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #playing
    -- @
    getSvgPlaying :: (MonadIO m, IsSvg o) => o -> m Bool
    getSvgPlaying :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m Bool
    getSvgPlaying o
    obj = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Bool
    forall a. GObject a => a -> String -> IO Bool
    B.Properties.getObjectPropertyBool o
    obj String
    "playing"

    -- | Set the value of the “@playing@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #playing 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgPlaying :: (MonadIO m, IsSvg o) => o -> Bool -> m ()
    setSvgPlaying :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> Bool -> m ()
    setSvgPlaying o
    obj Bool
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Bool -> IO ()
    forall a. GObject a => a -> String -> Bool -> IO ()
    B.Properties.setObjectPropertyBool o
    obj String
    "playing" Bool
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@playing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgPlaying :: (IsSvg o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
    constructSvgPlaying :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Bool -> m (GValueConstruct o)
    constructSvgPlaying Bool
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Bool -> IO (GValueConstruct o)
    forall o. String -> Bool -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBool String
    "playing" Bool
    val

    #if defined(ENABLE_OVERLOADING)
    data SvgPlayingPropertyInfo
    instance AttrInfo SvgPlayingPropertyInfo where
        type AttrAllowedOps SvgPlayingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgPlayingPropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgPlayingPropertyInfo = (~) Bool
        type AttrTransferTypeConstraint SvgPlayingPropertyInfo = (~) Bool
        type AttrTransferType SvgPlayingPropertyInfo = Bool
        type AttrGetType SvgPlayingPropertyInfo = Bool
        type AttrLabel SvgPlayingPropertyInfo = "playing"
        type AttrOrigin SvgPlayingPropertyInfo = Svg
        attrGet = getSvgPlaying
        attrSet = setSvgPlaying
        attrPut = setSvgPlaying
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgPlaying
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.playing"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:playing"
            })
    #endif

    -- VVV Prop "resource"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Nothing)

    -- | Get the value of the “@resource@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #resource
    -- @
    getSvgResource :: (MonadIO m, IsSvg o) => o -> m (Maybe T.Text)
    getSvgResource :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m (Maybe Text)
    getSvgResource o
    obj = IO (Maybe Text) -> m (Maybe Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
    -> IO (Maybe Text) -> m (Maybe Text)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO (Maybe Text)
    forall a. GObject a => a -> String -> IO (Maybe Text)
    B.Properties.getObjectPropertyString o
    obj String
    "resource"

    -- | Set the value of the “@resource@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #resource 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgResource :: (MonadIO m, IsSvg o) => o -> T.Text -> m ()
    setSvgResource :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> Text -> m ()
    setSvgResource o
    obj Text
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "resource" (Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@resource@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgResource :: (IsSvg o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
    constructSvgResource :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Text -> m (GValueConstruct o)
    constructSvgResource Text
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Text -> IO (GValueConstruct o)
    forall o. String -> Maybe Text -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyString String
    "resource" (Text -> Maybe Text
    forall a. a -> Maybe a
    P.Just Text
    val)

    -- | Set the value of the “@resource@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #resource
    -- @
    clearSvgResource :: (MonadIO m, IsSvg o) => o -> m ()
    clearSvgResource :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m ()
    clearSvgResource o
    obj = 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
    $ o -> String -> Maybe Text -> IO ()
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
    B.Properties.setObjectPropertyString o
    obj String
    "resource" (Maybe Text
    forall a. Maybe a
    Nothing :: Maybe T.Text)

    #if defined(ENABLE_OVERLOADING)
    data SvgResourcePropertyInfo
    instance AttrInfo SvgResourcePropertyInfo where
        type AttrAllowedOps SvgResourcePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SvgResourcePropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgResourcePropertyInfo = (~) T.Text
        type AttrTransferTypeConstraint SvgResourcePropertyInfo = (~) T.Text
        type AttrTransferType SvgResourcePropertyInfo = T.Text
        type AttrGetType SvgResourcePropertyInfo = (Maybe T.Text)
        type AttrLabel SvgResourcePropertyInfo = "resource"
        type AttrOrigin SvgResourcePropertyInfo = Svg
        attrGet = getSvgResource
        attrSet = setSvgResource
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgResource
        attrClear = clearSvgResource
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.resource"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:resource"
            })
    #endif

    -- VVV Prop "state"
       -- Type: TBasicType TUInt
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@state@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #state
    -- @
    getSvgState :: (MonadIO m, IsSvg o) => o -> m Word32
    getSvgState :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m Word32
    getSvgState o
    obj = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Word32
    forall a. GObject a => a -> String -> IO Word32
    B.Properties.getObjectPropertyUInt32 o
    obj String
    "state"

    -- | Set the value of the “@state@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #state 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgState :: (MonadIO m, IsSvg o) => o -> Word32 -> m ()
    setSvgState :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> Word32 -> m ()
    setSvgState o
    obj Word32
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Word32 -> IO ()
    forall a. GObject a => a -> String -> Word32 -> IO ()
    B.Properties.setObjectPropertyUInt32 o
    obj String
    "state" Word32
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@state@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgState :: (IsSvg o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
    constructSvgState :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Word32 -> m (GValueConstruct o)
    constructSvgState Word32
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Word32 -> IO (GValueConstruct o)
    forall o. String -> Word32 -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyUInt32 String
    "state" Word32
    val

    #if defined(ENABLE_OVERLOADING)
    data SvgStatePropertyInfo
    instance AttrInfo SvgStatePropertyInfo where
        type AttrAllowedOps SvgStatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgStatePropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgStatePropertyInfo = (~) Word32
        type AttrTransferTypeConstraint SvgStatePropertyInfo = (~) Word32
        type AttrTransferType SvgStatePropertyInfo = Word32
        type AttrGetType SvgStatePropertyInfo = Word32
        type AttrLabel SvgStatePropertyInfo = "state"
        type AttrOrigin SvgStatePropertyInfo = Svg
        attrGet = getSvgState
        attrSet = setSvgState
        attrPut = setSvgState
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgState
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.state"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:state"
            })
    #endif

    -- VVV Prop "stylesheet"
       -- Type: TInterface (Name {namespace = "GLib", name = "Bytes"})
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Nothing,Just True)

    -- | Get the value of the “@stylesheet@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #stylesheet
    -- @
    getSvgStylesheet :: (MonadIO m, IsSvg o) => o -> m (Maybe GLib.Bytes.Bytes)
    getSvgStylesheet :: forall (m :: * -> *) o.
    (MonadIO m, IsSvg o) =>
    o -> m (Maybe Bytes)
    getSvgStylesheet o
    obj = IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
    -> IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a b. (a -> b) -> a -> b
    $ o -> String -> (ManagedPtr Bytes -> Bytes) -> IO (Maybe Bytes)
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
    B.Properties.getObjectPropertyBoxed o
    obj String
    "stylesheet" ManagedPtr Bytes -> Bytes
    GLib.Bytes.Bytes

    -- | Set the value of the “@stylesheet@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #stylesheet 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgStylesheet :: (MonadIO m, IsSvg o) => o -> GLib.Bytes.Bytes -> m ()
    setSvgStylesheet :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> Bytes -> m ()
    setSvgStylesheet o
    obj Bytes
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Maybe Bytes -> IO ()
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyBoxed o
    obj String
    "stylesheet" (Bytes -> Maybe Bytes
    forall a. a -> Maybe a
    Just Bytes
    val)

    -- | Construct a t'GValueConstruct' with valid value for the “@stylesheet@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgStylesheet :: (IsSvg o, MIO.MonadIO m) => GLib.Bytes.Bytes -> m (GValueConstruct o)
    constructSvgStylesheet :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Bytes -> m (GValueConstruct o)
    constructSvgStylesheet Bytes
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Maybe Bytes -> IO (GValueConstruct o)
    forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyBoxed String
    "stylesheet" (Bytes -> Maybe Bytes
    forall a. a -> Maybe a
    P.Just Bytes
    val)

    -- | Set the value of the “@stylesheet@” property to `Nothing`.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.clear' #stylesheet
    -- @
    clearSvgStylesheet :: (MonadIO m, IsSvg o) => o -> m ()
    clearSvgStylesheet :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m ()
    clearSvgStylesheet o
    obj = 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
    $ o -> String -> Maybe Bytes -> IO ()
    forall a b.
    (GObject a, GBoxed b) =>
    a -> String -> Maybe b -> IO ()
    B.Properties.setObjectPropertyBoxed o
    obj String
    "stylesheet" (Maybe Bytes
    forall a. Maybe a
    Nothing :: Maybe GLib.Bytes.Bytes)

    #if defined(ENABLE_OVERLOADING)
    data SvgStylesheetPropertyInfo
    instance AttrInfo SvgStylesheetPropertyInfo where
        type AttrAllowedOps SvgStylesheetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrBaseTypeConstraint SvgStylesheetPropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgStylesheetPropertyInfo = (~) GLib.Bytes.Bytes
        type AttrTransferTypeConstraint SvgStylesheetPropertyInfo = (~) GLib.Bytes.Bytes
        type AttrTransferType SvgStylesheetPropertyInfo = GLib.Bytes.Bytes
        type AttrGetType SvgStylesheetPropertyInfo = (Maybe GLib.Bytes.Bytes)
        type AttrLabel SvgStylesheetPropertyInfo = "stylesheet"
        type AttrOrigin SvgStylesheetPropertyInfo = Svg
        attrGet = getSvgStylesheet
        attrSet = setSvgStylesheet
        attrPut = undefined
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgStylesheet
        attrClear = clearSvgStylesheet
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.stylesheet"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:stylesheet"
            })
    #endif

    -- VVV Prop "weight"
       -- Type: TBasicType TDouble
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    -- | Get the value of the “@weight@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.get' svg #weight
    -- @
    getSvgWeight :: (MonadIO m, IsSvg o) => o -> m Double
    getSvgWeight :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> m Double
    getSvgWeight o
    obj = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ o -> String -> IO Double
    forall a. GObject a => a -> String -> IO Double
    B.Properties.getObjectPropertyDouble o
    obj String
    "weight"

    -- | Set the value of the “@weight@” property.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Attributes.set' svg [ #weight 'Data.GI.Base.Attributes.:=' value ]
    -- @
    setSvgWeight :: (MonadIO m, IsSvg o) => o -> Double -> m ()
    setSvgWeight :: forall (m :: * -> *) o. (MonadIO m, IsSvg o) => o -> Double -> m ()
    setSvgWeight o
    obj Double
    val = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        o -> String -> Double -> IO ()
    forall a. GObject a => a -> String -> Double -> IO ()
    B.Properties.setObjectPropertyDouble o
    obj String
    "weight" Double
    val

    -- | Construct a t'GValueConstruct' with valid value for the “@weight@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    constructSvgWeight :: (IsSvg o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
    constructSvgWeight :: forall o (m :: * -> *).
    (IsSvg o, MonadIO m) =>
    Double -> m (GValueConstruct o)
    constructSvgWeight Double
    val = IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
    -> IO (GValueConstruct o) -> m (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ do
        IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
    -> IO (GValueConstruct o) -> IO (GValueConstruct o)
    forall a b. (a -> b) -> a -> b
    $ String -> Double -> IO (GValueConstruct o)
    forall o. String -> Double -> IO (GValueConstruct o)
    B.Properties.constructObjectPropertyDouble String
    "weight" Double
    val

    #if defined(ENABLE_OVERLOADING)
    data SvgWeightPropertyInfo
    instance AttrInfo SvgWeightPropertyInfo where
        type AttrAllowedOps SvgWeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
        type AttrBaseTypeConstraint SvgWeightPropertyInfo = IsSvg
        type AttrSetTypeConstraint SvgWeightPropertyInfo = (~) Double
        type AttrTransferTypeConstraint SvgWeightPropertyInfo = (~) Double
        type AttrTransferType SvgWeightPropertyInfo = Double
        type AttrGetType SvgWeightPropertyInfo = Double
        type AttrLabel SvgWeightPropertyInfo = "weight"
        type AttrOrigin SvgWeightPropertyInfo = Svg
        attrGet = getSvgWeight
        attrSet = setSvgWeight
        attrPut = setSvgWeight
        attrTransfer _ v = do
            return v
        attrConstruct = constructSvgWeight
        attrClear = undefined
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.weight"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#g:attr:weight"
            })
    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Svg
    type instance O.AttributeList Svg = SvgAttributeList
    type SvgAttributeList = ('[ '("features", SvgFeaturesPropertyInfo), '("overflow", SvgOverflowPropertyInfo), '("playing", SvgPlayingPropertyInfo), '("resource", SvgResourcePropertyInfo), '("state", SvgStatePropertyInfo), '("stylesheet", SvgStylesheetPropertyInfo), '("weight", SvgWeightPropertyInfo)] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    svgFeatures :: AttrLabelProxy "features"
    svgFeatures = AttrLabelProxy

    svgOverflow :: AttrLabelProxy "overflow"
    svgOverflow = AttrLabelProxy

    svgPlaying :: AttrLabelProxy "playing"
    svgPlaying = AttrLabelProxy

    svgResource :: AttrLabelProxy "resource"
    svgResource = AttrLabelProxy

    svgState :: AttrLabelProxy "state"
    svgState = AttrLabelProxy

    svgStylesheet :: AttrLabelProxy "stylesheet"
    svgStylesheet = AttrLabelProxy

    svgWeight :: AttrLabelProxy "weight"
    svgWeight = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Svg = SvgSignalList
    type SvgSignalList = ('[ '("error", SvgErrorSignalInfo), '("invalidateContents", Gdk.Paintable.PaintableInvalidateContentsSignalInfo), '("invalidateSize", Gdk.Paintable.PaintableInvalidateSizeSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method Svg::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Svg" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_new" gtk_svg_new ::
        IO (Ptr Svg)

    -- | Creates a new, empty SVG paintable.
    --
    -- /Since: 4.22/
    svgNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Svg
        -- ^ __Returns:__ the paintable
    svgNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Svg
    svgNew  = IO Svg -> m Svg
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Svg -> m Svg) -> IO Svg -> m Svg
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Svg)
    gtk_svg_new
        checkUnexpectedReturnNULL "svgNew" result
        result' <- (wrapObject Svg) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Svg::new_from_bytes
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Svg" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_new_from_bytes" gtk_svg_new_from_bytes ::
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO (Ptr Svg)

    -- | Parses the SVG data in /@bytes@/ and creates a paintable.
    --
    -- /Since: 4.22/
    svgNewFromBytes ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GLib.Bytes.Bytes
        -- ^ /@bytes@/: the data
        -> m Svg
        -- ^ __Returns:__ the paintable
    svgNewFromBytes :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Bytes -> m Svg
    svgNewFromBytes Bytes
    bytes = IO Svg -> m Svg
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Svg -> m Svg) -> IO Svg -> m Svg
    forall a b. (a -> b) -> a -> b
    $ do
        bytes' <- Bytes -> IO (Ptr Bytes)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Bytes
    bytes
        result <- gtk_svg_new_from_bytes bytes'
        checkUnexpectedReturnNULL "svgNewFromBytes" result
        result' <- (wrapObject Svg) result
        touchManagedPtr bytes
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Svg::new_from_resource
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the resource path" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Svg" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_new_from_resource" gtk_svg_new_from_resource ::
        CString ->                              -- path : TBasicType TUTF8
        IO (Ptr Svg)

    -- | Parses the SVG data in the resource and creates a paintable.
    --
    -- /Since: 4.22/
    svgNewFromResource ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@path@/: the resource path
        -> m Svg
        -- ^ __Returns:__ the paintable
    svgNewFromResource :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Svg
    svgNewFromResource Text
    path = IO Svg -> m Svg
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Svg -> m Svg) -> IO Svg -> m Svg
    forall a b. (a -> b) -> a -> b
    $ do
        path' <- Text -> IO CString
    textToCString Text
    path
        result <- gtk_svg_new_from_resource path'
        checkUnexpectedReturnNULL "svgNewFromResource" result
        result' <- (wrapObject Svg) result
        freeMem path'
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Svg::get_features
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "SvgFeatures" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_features" gtk_svg_get_features ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO CUInt

    -- | Returns the currently enabled features.
    --
    -- /Since: 4.22/
    svgGetFeatures ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m [Gtk.Flags.SvgFeatures]
        -- ^ __Returns:__ the enabled features
    svgGetFeatures :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m [SvgFeatures]
    svgGetFeatures a
    self = IO [SvgFeatures] -> m [SvgFeatures]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [SvgFeatures] -> m [SvgFeatures])
    -> IO [SvgFeatures] -> m [SvgFeatures]
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_get_features self'
        let result' = CUInt -> [SvgFeatures]
    forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
    wordToGFlags CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SvgGetFeaturesMethodInfo
    instance (signature ~ (m [Gtk.Flags.SvgFeatures]), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetFeaturesMethodInfo a signature where
        overloadedMethod = svgGetFeatures

    instance O.OverloadedMethodInfo SvgGetFeaturesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetFeatures",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetFeatures"
            })

    #endif

    -- method Svg::get_overflow
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Overflow" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_overflow" gtk_svg_get_overflow ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO CUInt

    -- | Gets the current overflow value.
    --
    -- /Since: 4.24/
    svgGetOverflow ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m Gtk.Enums.Overflow
        -- ^ __Returns:__ the current overflow value
    svgGetOverflow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m Overflow
    svgGetOverflow a
    self = IO Overflow -> m Overflow
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Overflow -> m Overflow) -> IO Overflow -> m Overflow
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_get_overflow self'
        let result' = (Int -> Overflow
    forall a. Enum a => Int -> a
    toEnum (Int -> Overflow) -> (CUInt -> Int) -> CUInt -> Overflow
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SvgGetOverflowMethodInfo
    instance (signature ~ (m Gtk.Enums.Overflow), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetOverflowMethodInfo a signature where
        overloadedMethod = svgGetOverflow

    instance O.OverloadedMethodInfo SvgGetOverflowMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetOverflow",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetOverflow"
            })

    #endif

    -- method Svg::get_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_state" gtk_svg_get_state ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO Word32

    -- | Gets the current state of the paintable.
    --
    -- /Since: 4.22/
    svgGetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m Word32
        -- ^ __Returns:__ the state
    svgGetState :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m Word32
    svgGetState a
    self = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_get_state self'
        touchManagedPtr self
        return result

    #if defined(ENABLE_OVERLOADING)
    data SvgGetStateMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetStateMethodInfo a signature where
        overloadedMethod = svgGetState

    instance O.OverloadedMethodInfo SvgGetStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetState"
            })

    #endif

    -- method Svg::get_state_names
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "length"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int*"
    --           , direction = DirectionOut
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "return location for the number\n  of strings that are returned"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_state_names" gtk_svg_get_state_names ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Ptr Word32 ->                           -- length : TBasicType TUInt
        IO (Ptr CString)

    -- | Returns a @NULL@-terminated array of
    -- state names, if available.
    --
    -- Note that the returned array and the strings
    -- contained in it will only be valid until the
    -- @GtkSvg@ is cleared or reloaded, so if you
    -- want to keep it around, you should make a copy.
    --
    -- /Since: 4.22/
    svgGetStateNames ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m ((Maybe [T.Text], Word32))
        -- ^ __Returns:__ the state names
    svgGetStateNames :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m (Maybe [Text], Word32)
    svgGetStateNames a
    self = IO (Maybe [Text], Word32) -> m (Maybe [Text], Word32)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe [Text], Word32) -> m (Maybe [Text], Word32))
    -> IO (Maybe [Text], Word32) -> m (Maybe [Text], Word32)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        length_ <- allocMem :: IO (Ptr Word32)
        result <- gtk_svg_get_state_names self' length_
        maybeResult <- convertIfNonNull result $ \Ptr CString
    result' -> do
            result'' <- HasCallStack => Ptr CString -> IO [Text]
    Ptr CString -> IO [Text]
    unpackZeroTerminatedUTF8CArray Ptr CString
    result'
            return result''
        length_' <- peek length_
        touchManagedPtr self
        freeMem length_
        return (maybeResult, length_')

    #if defined(ENABLE_OVERLOADING)
    data SvgGetStateNamesMethodInfo
    instance (signature ~ (m ((Maybe [T.Text], Word32))), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetStateNamesMethodInfo a signature where
        overloadedMethod = svgGetStateNames

    instance O.OverloadedMethodInfo SvgGetStateNamesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetStateNames",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetStateNames"
            })

    #endif

    -- method Svg::get_stylesheet
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_stylesheet" gtk_svg_get_stylesheet ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO (Ptr GLib.Bytes.Bytes)

    -- | Gets the CSS user stylesheet.
    --
    -- /Since: 4.24/
    svgGetStylesheet ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m (Maybe GLib.Bytes.Bytes)
        -- ^ __Returns:__ a @GBytes@ with the CSS data
    svgGetStylesheet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m (Maybe Bytes)
    svgGetStylesheet a
    self = IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Bytes) -> m (Maybe Bytes))
    -> IO (Maybe Bytes) -> m (Maybe Bytes)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_get_stylesheet self'
        maybeResult <- convertIfNonNull result $ \Ptr Bytes
    result' -> do
            result'' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Bytes -> Bytes
    GLib.Bytes.Bytes) Ptr Bytes
    result'
            return result''
        touchManagedPtr self
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data SvgGetStylesheetMethodInfo
    instance (signature ~ (m (Maybe GLib.Bytes.Bytes)), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetStylesheetMethodInfo a signature where
        overloadedMethod = svgGetStylesheet

    instance O.OverloadedMethodInfo SvgGetStylesheetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetStylesheet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetStylesheet"
            })

    #endif

    -- method Svg::get_weight
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TDouble)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_get_weight" gtk_svg_get_weight ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO CDouble

    -- | Gets the value of the weight property.
    --
    -- /Since: 4.22/
    svgGetWeight ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m Double
        -- ^ __Returns:__ the weight
    svgGetWeight :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m Double
    svgGetWeight a
    self = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_get_weight self'
        let result' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SvgGetWeightMethodInfo
    instance (signature ~ (m Double), MonadIO m, IsSvg a) => O.OverloadedMethod SvgGetWeightMethodInfo a signature where
        overloadedMethod = svgGetWeight

    instance O.OverloadedMethodInfo SvgGetWeightMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgGetWeight",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgGetWeight"
            })

    #endif

    -- method Svg::load_from_bytes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the data to load" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_load_from_bytes" gtk_svg_load_from_bytes ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    -- | Loads SVG content into an existing SVG paintable.
    --
    -- To track errors while loading SVG content,
    -- connect to the [Svg::error]("GI.Gtk.Objects.Svg#g:signal:error") signal.
    --
    -- This clears any previously loaded content.
    --
    -- /Since: 4.22/
    svgLoadFromBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> GLib.Bytes.Bytes
        -- ^ /@bytes@/: the data to load
        -> m ()
    svgLoadFromBytes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Bytes -> m ()
    svgLoadFromBytes a
    self Bytes
    bytes = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        bytes' <- unsafeManagedPtrGetPtr bytes
        gtk_svg_load_from_bytes self' bytes'
        touchManagedPtr self
        touchManagedPtr bytes
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgLoadFromBytesMethodInfo
    instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgLoadFromBytesMethodInfo a signature where
        overloadedMethod = svgLoadFromBytes

    instance O.OverloadedMethodInfo SvgLoadFromBytesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgLoadFromBytes",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgLoadFromBytes"
            })

    #endif

    -- method Svg::load_from_resource
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "path"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the resource path" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_load_from_resource" gtk_svg_load_from_resource ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        CString ->                              -- path : TBasicType TUTF8
        IO ()

    -- | Loads SVG content into an existing SVG paintable.
    --
    -- To track errors while loading SVG content,
    -- connect to the [Svg::error]("GI.Gtk.Objects.Svg#g:signal:error") signal.
    --
    -- This clears any previously loaded content.
    --
    -- /Since: 4.22/
    svgLoadFromResource ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> T.Text
        -- ^ /@path@/: the resource path
        -> m ()
    svgLoadFromResource :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Text -> m ()
    svgLoadFromResource a
    self Text
    path = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        path' <- textToCString path
        gtk_svg_load_from_resource self' path'
        touchManagedPtr self
        freeMem path'
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgLoadFromResourceMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgLoadFromResourceMethodInfo a signature where
        overloadedMethod = svgLoadFromResource

    instance O.OverloadedMethodInfo SvgLoadFromResourceMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgLoadFromResource",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgLoadFromResource"
            })

    #endif

    -- method Svg::pause
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_pause" gtk_svg_pause ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO ()

    -- | Stop any playing animations and state transitions.
    --
    -- SvgAnimations can be paused and started repeatedly.
    --
    -- /Since: 4.22/
    svgPause ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m ()
    svgPause :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m ()
    svgPause a
    self = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_svg_pause self'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgPauseMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgPauseMethodInfo a signature where
        overloadedMethod = svgPause

    instance O.OverloadedMethodInfo SvgPauseMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgPause",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgPause"
            })

    #endif

    -- method Svg::play
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_play" gtk_svg_play ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO ()

    -- | Start playing animations and state transitions.
    --
    -- SvgAnimations can be paused and started repeatedly.
    --
    -- /Since: 4.22/
    svgPlay ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m ()
    svgPlay :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m ()
    svgPlay a
    self = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_svg_play self'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgPlayMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgPlayMethodInfo a signature where
        overloadedMethod = svgPlay

    instance O.OverloadedMethodInfo SvgPlayMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgPlay",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgPlay"
            })

    #endif

    -- method Svg::serialize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_serialize" gtk_svg_serialize ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        IO (Ptr GLib.Bytes.Bytes)

    -- | Serializes the content of the renderer as SVG.
    --
    -- The SVG will be similar to the orignally loaded one,
    -- but is not guaranteed to be 100% identical.
    --
    -- This function serializes the DOM, i.e. the results
    -- of parsing the SVG. It does not reflect the effect
    -- of applying animations.
    --
    -- /Since: 4.22/
    svgSerialize ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> m GLib.Bytes.Bytes
        -- ^ __Returns:__ the serialized contents
    svgSerialize :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> m Bytes
    svgSerialize a
    self = IO Bytes -> m Bytes
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bytes -> m Bytes) -> IO Bytes -> m Bytes
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        result <- gtk_svg_serialize self'
        checkUnexpectedReturnNULL "svgSerialize" result
        result' <- (wrapBoxed GLib.Bytes.Bytes) result
        touchManagedPtr self
        return result'

    #if defined(ENABLE_OVERLOADING)
    data SvgSerializeMethodInfo
    instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSerializeMethodInfo a signature where
        overloadedMethod = svgSerialize

    instance O.OverloadedMethodInfo SvgSerializeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSerialize",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSerialize"
            })

    #endif

    -- method Svg::set_features
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "features"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "SvgFeatures" }
    --           , argCType = Just "GtkSvgFeatures"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "features to enable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_features" gtk_svg_set_features ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        CUInt ->                                -- features : TInterface (Name {namespace = "Gtk", name = "SvgFeatures"})
        IO ()

    -- | Enables or disables features of the SVG paintable.
    --
    -- By default, all features are enabled.
    --
    -- Note that this call only has an effect before the
    -- SVG is loaded.
    --
    -- /Since: 4.22/
    svgSetFeatures ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> [Gtk.Flags.SvgFeatures]
        -- ^ /@features@/: features to enable
        -> m ()
    svgSetFeatures :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> [SvgFeatures] -> m ()
    svgSetFeatures a
    self [SvgFeatures]
    features = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let features' = [SvgFeatures] -> CUInt
    forall b a. (Num b, IsGFlag a) => [a] -> b
    gflagsToWord [SvgFeatures]
    features
        gtk_svg_set_features self' features'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetFeaturesMethodInfo
    instance (signature ~ ([Gtk.Flags.SvgFeatures] -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSetFeaturesMethodInfo a signature where
        overloadedMethod = svgSetFeatures

    instance O.OverloadedMethodInfo SvgSetFeaturesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetFeatures",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetFeatures"
            })

    #endif

    -- method Svg::set_frame_clock
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "clock"
    --           , argType =
    --               TInterface Name { namespace = "Gdk" , name = "FrameClock" }
    --           , argCType = Just "GdkFrameClock*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the frame clock" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_frame_clock" gtk_svg_set_frame_clock ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Ptr Gdk.FrameClock.FrameClock ->        -- clock : TInterface (Name {namespace = "Gdk", name = "FrameClock"})
        IO ()

    -- | Sets a frame clock.
    --
    -- Without a frame clock, GtkSvg will not advance animations.
    --
    -- /Since: 4.22/
    svgSetFrameClock ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a, Gdk.FrameClock.IsFrameClock b) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> b
        -- ^ /@clock@/: the frame clock
        -> m ()
    svgSetFrameClock :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSvg a, IsFrameClock b) =>
    a -> b -> m ()
    svgSetFrameClock a
    self b
    clock = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        clock' <- unsafeManagedPtrCastPtr clock
        gtk_svg_set_frame_clock self' clock'
        touchManagedPtr self
        touchManagedPtr clock
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetFrameClockMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsSvg a, Gdk.FrameClock.IsFrameClock b) => O.OverloadedMethod SvgSetFrameClockMethodInfo a signature where
        overloadedMethod = svgSetFrameClock

    instance O.OverloadedMethodInfo SvgSetFrameClockMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetFrameClock",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetFrameClock"
            })

    #endif

    -- method Svg::set_overflow
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "overflow"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Overflow" }
    --           , argCType = Just "GtkOverflow"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new overflow value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_overflow" gtk_svg_set_overflow ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        CUInt ->                                -- overflow : TInterface (Name {namespace = "Gtk", name = "Overflow"})
        IO ()

    -- | Sets whether the rendering will be clipped
    -- to the bounds.
    --
    -- Clipping is expected for t'GI.Gdk.Interfaces.Paintable.Paintable'
    -- semantics, so this property should not be
    -- changed when using a @GtkSvg@ as a paintable.
    --
    -- /Since: 4.24/
    svgSetOverflow ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> Gtk.Enums.Overflow
        -- ^ /@overflow@/: the new overflow value
        -> m ()
    svgSetOverflow :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Overflow -> m ()
    svgSetOverflow a
    self Overflow
    overflow = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let overflow' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (Overflow -> Int) -> Overflow -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Overflow -> Int
    forall a. Enum a => a -> Int
    fromEnum) Overflow
    overflow
        gtk_svg_set_overflow self' overflow'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetOverflowMethodInfo
    instance (signature ~ (Gtk.Enums.Overflow -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSetOverflowMethodInfo a signature where
        overloadedMethod = svgSetOverflow

    instance O.OverloadedMethodInfo SvgSetOverflowMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetOverflow",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetOverflow"
            })

    #endif

    -- method Svg::set_settings
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "settings"
    --           , argType =
    --               TInterface Name { namespace = "Gtk" , name = "Settings" }
    --           , argCType = Just "GtkSettings*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the settings object"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_settings" gtk_svg_set_settings ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Ptr Gtk.Settings.Settings ->            -- settings : TInterface (Name {namespace = "Gtk", name = "Settings"})
        IO ()

    -- | Sets a settings object holding settinsg used when
    -- rendering the SVG.
    --
    -- /Since: 4.24/
    svgSetSettings ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a, Gtk.Settings.IsSettings b) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> Maybe (b)
        -- ^ /@settings@/: the settings object
        -> m ()
    svgSetSettings :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsSvg a, IsSettings b) =>
    a -> Maybe b -> m ()
    svgSetSettings a
    self Maybe b
    settings = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeSettings <- case settings of
            Maybe b
    Nothing -> Ptr Settings -> IO (Ptr Settings)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Settings
    forall a. Ptr a
    FP.nullPtr
            Just b
    jSettings -> do
                jSettings' <- b -> IO (Ptr Settings)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jSettings
                return jSettings'
        gtk_svg_set_settings self' maybeSettings
        touchManagedPtr self
        whenJust settings touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetSettingsMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSvg a, Gtk.Settings.IsSettings b) => O.OverloadedMethod SvgSetSettingsMethodInfo a signature where
        overloadedMethod = svgSetSettings

    instance O.OverloadedMethodInfo SvgSetSettingsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetSettings",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetSettings"
            })

    #endif

    -- method Svg::set_state
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "state"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the state to set, as a value between 0 and 63"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_state" gtk_svg_set_state ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Word32 ->                               -- state : TBasicType TUInt
        IO ()

    -- | Sets the state of the paintable.
    --
    -- If the paintable is currently playing, the state change
    -- will apply transitions that are defined in the SVG. If
    -- the paintable is not playing, the state change will take
    -- effect instantaneously.
    --
    -- /Since: 4.22/
    svgSetState ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> Word32
        -- ^ /@state@/: the state to set, as a value between 0 and 63
        -> m ()
    svgSetState :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Word32 -> m ()
    svgSetState a
    self Word32
    state = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        gtk_svg_set_state self' state
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetStateMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSetStateMethodInfo a signature where
        overloadedMethod = svgSetState

    instance O.OverloadedMethodInfo SvgSetStateMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetState",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetState"
            })

    #endif

    -- method Svg::set_stylesheet
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
    --           , argCType = Just "GBytes*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "CSS data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_stylesheet" gtk_svg_set_stylesheet ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
        IO ()

    -- | Sets a CSS user stylesheet to use.
    --
    -- Note that styles are applied at load time,
    -- so this function must be called before
    -- loading SVG.
    --
    -- /Since: 4.24/
    svgSetStylesheet ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> Maybe (GLib.Bytes.Bytes)
        -- ^ /@bytes@/: CSS data
        -> m ()
    svgSetStylesheet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Maybe Bytes -> m ()
    svgSetStylesheet a
    self Maybe Bytes
    bytes = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        maybeBytes <- case bytes of
            Maybe Bytes
    Nothing -> Ptr Bytes -> IO (Ptr Bytes)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Bytes
    forall a. Ptr a
    FP.nullPtr
            Just Bytes
    jBytes -> do
                jBytes' <- Bytes -> IO (Ptr Bytes)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Bytes
    jBytes
                return jBytes'
        gtk_svg_set_stylesheet self' maybeBytes
        touchManagedPtr self
        whenJust bytes touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetStylesheetMethodInfo
    instance (signature ~ (Maybe (GLib.Bytes.Bytes) -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSetStylesheetMethodInfo a signature where
        overloadedMethod = svgSetStylesheet

    instance O.OverloadedMethodInfo SvgSetStylesheetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetStylesheet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetStylesheet"
            })

    #endif

    -- method Svg::set_weight
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "weight"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the font weight, as a value between -1 and 1000"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gtk_svg_set_weight" gtk_svg_set_weight ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        CDouble ->                              -- weight : TBasicType TDouble
        IO ()

    -- | Sets the weight that is used when rendering.
    --
    -- The weight affects the effective linewidth when stroking
    -- paths.
    --
    -- The default value of -1 means to use the font weight
    -- from CSS.
    --
    -- /Since: 4.22/
    svgSetWeight ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> Double
        -- ^ /@weight@/: the font weight, as a value between -1 and 1000
        -> m ()
    svgSetWeight :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Double -> m ()
    svgSetWeight a
    self Double
    weight = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        let weight' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    weight
        gtk_svg_set_weight self' weight'
        touchManagedPtr self
        return ()

    #if defined(ENABLE_OVERLOADING)
    data SvgSetWeightMethodInfo
    instance (signature ~ (Double -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgSetWeightMethodInfo a signature where
        overloadedMethod = svgSetWeight

    instance O.OverloadedMethodInfo SvgSetWeightMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgSetWeight",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgSetWeight"
            })

    #endif

    -- method Svg::write_to_file
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType = TInterface Name { namespace = "Gtk" , name = "Svg" }
    --           , argCType = Just "GtkSvg*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an SVG paintable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "filename"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the file to save to"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : True
    -- Skip return : False

    foreign import ccall "gtk_svg_write_to_file" gtk_svg_write_to_file ::
        Ptr Svg ->                              -- self : TInterface (Name {namespace = "Gtk", name = "Svg"})
        CString ->                              -- filename : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | Serializes the paintable, and saves the result to a file.
    --
    -- /Since: 4.22/
    svgWriteToFile ::
        (B.CallStack.HasCallStack, MonadIO m, IsSvg a) =>
        a
        -- ^ /@self@/: an SVG paintable
        -> T.Text
        -- ^ /@filename@/: the file to save to
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    svgWriteToFile :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsSvg a) =>
    a -> Text -> m ()
    svgWriteToFile a
    self Text
    filename = 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
    $ do
        self' <- a -> IO (Ptr Svg)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    self
        filename' <- textToCString filename
        onException (do
            _ <- propagateGError $ gtk_svg_write_to_file self' filename'
            touchManagedPtr self
            freeMem filename'
            return ()
         ) (do
            freeMem filename'
         )

    #if defined(ENABLE_OVERLOADING)
    data SvgWriteToFileMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsSvg a) => O.OverloadedMethod SvgWriteToFileMethodInfo a signature where
        overloadedMethod = svgWriteToFile

    instance O.OverloadedMethodInfo SvgWriteToFileMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gtk.Objects.Svg.svgWriteToFile",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk4-4.0.12/docs/GI-Gtk-Objects-Svg.html#v:svgWriteToFile"
            })

    #endif