    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Describes a 3D transform.
    --
    -- Unlike @graphene_matrix_t@, @GskTransform@ retains the steps in how
    -- a transform was constructed, and allows inspecting them. It is modeled
    -- after the way CSS describes transforms.
    --
    -- @GskTransform@ objects are immutable and cannot be changed after creation.
    -- This means code can safely expose them as properties of objects without
    -- having to worry about others changing them.

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

    module GI.Gsk.Structs.Transform
        (

    -- * Exported types
        Transform(..)                           ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [equal]("GI.Gsk.Structs.Transform#g:method:equal"), [invert]("GI.Gsk.Structs.Transform#g:method:invert"), [matrix]("GI.Gsk.Structs.Transform#g:method:matrix"), [matrix2d]("GI.Gsk.Structs.Transform#g:method:matrix2d"), [perspective]("GI.Gsk.Structs.Transform#g:method:perspective"), [print]("GI.Gsk.Structs.Transform#g:method:print"), [ref]("GI.Gsk.Structs.Transform#g:method:ref"), [rotate]("GI.Gsk.Structs.Transform#g:method:rotate"), [rotate3d]("GI.Gsk.Structs.Transform#g:method:rotate3d"), [scale]("GI.Gsk.Structs.Transform#g:method:scale"), [scale3d]("GI.Gsk.Structs.Transform#g:method:scale3d"), [skew]("GI.Gsk.Structs.Transform#g:method:skew"), [to2d]("GI.Gsk.Structs.Transform#g:method:to2d"), [to2dComponents]("GI.Gsk.Structs.Transform#g:method:to2dComponents"), [toAffine]("GI.Gsk.Structs.Transform#g:method:toAffine"), [toMatrix]("GI.Gsk.Structs.Transform#g:method:toMatrix"), [toString]("GI.Gsk.Structs.Transform#g:method:toString"), [toTranslate]("GI.Gsk.Structs.Transform#g:method:toTranslate"), [transform]("GI.Gsk.Structs.Transform#g:method:transform"), [transformBounds]("GI.Gsk.Structs.Transform#g:method:transformBounds"), [transformPoint]("GI.Gsk.Structs.Transform#g:method:transformPoint"), [translate]("GI.Gsk.Structs.Transform#g:method:translate"), [translate3d]("GI.Gsk.Structs.Transform#g:method:translate3d"), [unref]("GI.Gsk.Structs.Transform#g:method:unref").
    --
    -- ==== Getters
    -- [getCategory]("GI.Gsk.Structs.Transform#g:method:getCategory").
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveTransformMethod                  ,
    #endif

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        TransformEqualMethodInfo                ,
    #endif
        transformEqual                          ,

    -- ** getCategory #method:getCategory#

    #if defined(ENABLE_OVERLOADING)
        TransformGetCategoryMethodInfo          ,
    #endif
        transformGetCategory                    ,

    -- ** invert #method:invert#

    #if defined(ENABLE_OVERLOADING)
        TransformInvertMethodInfo               ,
    #endif
        transformInvert                         ,

    -- ** matrix #method:matrix#

    #if defined(ENABLE_OVERLOADING)
        TransformMatrixMethodInfo               ,
    #endif
        transformMatrix                         ,

    -- ** matrix2d #method:matrix2d#

    #if defined(ENABLE_OVERLOADING)
        TransformMatrix2dMethodInfo             ,
    #endif
        transformMatrix2d                       ,

    -- ** new #method:new#

        transformNew                            ,

    -- ** parse #method:parse#

        transformParse                          ,

    -- ** perspective #method:perspective#

    #if defined(ENABLE_OVERLOADING)
        TransformPerspectiveMethodInfo          ,
    #endif
        transformPerspective                    ,

    -- ** print #method:print#

    #if defined(ENABLE_OVERLOADING)
        TransformPrintMethodInfo                ,
    #endif
        transformPrint                          ,

    -- ** ref #method:ref#

    #if defined(ENABLE_OVERLOADING)
        TransformRefMethodInfo                  ,
    #endif
        transformRef                            ,

    -- ** rotate #method:rotate#

    #if defined(ENABLE_OVERLOADING)
        TransformRotateMethodInfo               ,
    #endif
        transformRotate                         ,

    -- ** rotate3d #method:rotate3d#

    #if defined(ENABLE_OVERLOADING)
        TransformRotate3dMethodInfo             ,
    #endif
        transformRotate3d                       ,

    -- ** scale #method:scale#

    #if defined(ENABLE_OVERLOADING)
        TransformScaleMethodInfo                ,
    #endif
        transformScale                          ,

    -- ** scale3d #method:scale3d#

    #if defined(ENABLE_OVERLOADING)
        TransformScale3dMethodInfo              ,
    #endif
        transformScale3d                        ,

    -- ** skew #method:skew#

    #if defined(ENABLE_OVERLOADING)
        TransformSkewMethodInfo                 ,
    #endif
        transformSkew                           ,

    -- ** to2d #method:to2d#

    #if defined(ENABLE_OVERLOADING)
        TransformTo2dMethodInfo                 ,
    #endif
        transformTo2d                           ,

    -- ** to2dComponents #method:to2dComponents#

    #if defined(ENABLE_OVERLOADING)
        TransformTo2dComponentsMethodInfo       ,
    #endif
        transformTo2dComponents                 ,

    -- ** toAffine #method:toAffine#

    #if defined(ENABLE_OVERLOADING)
        TransformToAffineMethodInfo             ,
    #endif
        transformToAffine                       ,

    -- ** toMatrix #method:toMatrix#

    #if defined(ENABLE_OVERLOADING)
        TransformToMatrixMethodInfo             ,
    #endif
        transformToMatrix                       ,

    -- ** toString #method:toString#

    #if defined(ENABLE_OVERLOADING)
        TransformToStringMethodInfo             ,
    #endif
        transformToString                       ,

    -- ** toTranslate #method:toTranslate#

    #if defined(ENABLE_OVERLOADING)
        TransformToTranslateMethodInfo          ,
    #endif
        transformToTranslate                    ,

    -- ** transform #method:transform#

    #if defined(ENABLE_OVERLOADING)
        TransformTransformMethodInfo            ,
    #endif
        transformTransform                      ,

    -- ** transformBounds #method:transformBounds#

    #if defined(ENABLE_OVERLOADING)
        TransformTransformBoundsMethodInfo      ,
    #endif
        transformTransformBounds                ,

    -- ** transformPoint #method:transformPoint#

    #if defined(ENABLE_OVERLOADING)
        TransformTransformPointMethodInfo       ,
    #endif
        transformTransformPoint                 ,

    -- ** translate #method:translate#

    #if defined(ENABLE_OVERLOADING)
        TransformTranslateMethodInfo            ,
    #endif
        transformTranslate                      ,

    -- ** translate3d #method:translate3d#

    #if defined(ENABLE_OVERLOADING)
        TransformTranslate3dMethodInfo          ,
    #endif
        transformTranslate3d                    ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        TransformUnrefMethodInfo                ,
    #endif
        transformUnref                          ,

        ) 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.String as GLib.String
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums

    #else
    import qualified GI.GLib.Structs.String as GLib.String
    import qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import qualified GI.Graphene.Structs.Point as Graphene.Point
    import qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import {-# SOURCE #-} qualified GI.Gsk.Enums as Gsk.Enums

    #endif

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

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

    foreign import ccall "gsk_transform_get_type" c_gsk_transform_get_type ::
        IO GType

    type instance O.ParentTypes Transform = '[]
    instance O.HasParentTypes Transform

    instance B.Types.TypedObject Transform where
        glibType :: IO GType
    glibType = IO GType
    c_gsk_transform_get_type

    instance B.Types.GBoxed Transform

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

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Transform
    type instance O.AttributeList Transform = TransformAttributeList
    type TransformAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

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

    foreign import ccall "gsk_transform_new" gsk_transform_new ::
        IO (Ptr Transform)

    -- | Creates a new identity transform.
    --
    -- This function is meant to be used by language
    -- bindings. For C code, this is equivalent to using @NULL@.
    transformNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Transform
        -- ^ __Returns:__ A new identity transform
    transformNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Transform
    transformNew  = IO Transform -> m Transform
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Transform)
    gsk_transform_new
        checkUnexpectedReturnNULL "transformNew" result
        result' <- (wrapBoxed Transform) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Transform::equal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "first"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the first transform"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "second"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the second transform"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_equal" gsk_transform_equal ::
        Ptr Transform ->                        -- first : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Transform ->                        -- second : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO CInt

    -- | Checks two transforms for equality.
    transformEqual ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@first@/: the first transform
        -> Maybe (Transform)
        -- ^ /@second@/: the second transform
        -> m Bool
        -- ^ __Returns:__ true if the two transforms perform the same operation
    transformEqual :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Maybe Transform -> m Bool
    transformEqual Maybe Transform
    first Maybe Transform
    second = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        maybeFirst <- case Maybe Transform
    first of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jFirst -> do
                jFirst' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jFirst
                return jFirst'
        maybeSecond <- case second of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSecond -> do
                jSecond' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSecond
                return jSecond'
        result <- gsk_transform_equal maybeFirst maybeSecond
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        whenJust first touchManagedPtr
        whenJust second touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TransformEqualMethodInfo
    instance (signature ~ (Maybe (Transform) -> m Bool), MonadIO m) => O.OverloadedMethod TransformEqualMethodInfo Transform signature where
        overloadedMethod i = transformEqual (Just i)

    instance O.OverloadedMethodInfo TransformEqualMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformEqual",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformEqual"
            })

    #endif

    -- method Transform::get_category
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Gsk" , name = "TransformCategory" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_get_category" gsk_transform_get_category ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO CUInt

    -- | Returns the category this transform belongs to.
    transformGetCategory ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> m Gsk.Enums.TransformCategory
        -- ^ __Returns:__ The category of the transform
    transformGetCategory :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m TransformCategory
    transformGetCategory Maybe Transform
    self = IO TransformCategory -> m TransformCategory
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO TransformCategory -> m TransformCategory)
    -> IO TransformCategory -> m TransformCategory
    forall a b. (a -> b) -> a -> b
    $ do
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        result <- gsk_transform_get_category maybeSelf
        let result' = (Int -> TransformCategory
    forall a. Enum a => Int -> a
    toEnum (Int -> TransformCategory)
    -> (CUInt -> Int) -> CUInt -> TransformCategory
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        whenJust self touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TransformGetCategoryMethodInfo
    instance (signature ~ (m Gsk.Enums.TransformCategory), MonadIO m) => O.OverloadedMethod TransformGetCategoryMethodInfo Transform signature where
        overloadedMethod i = transformGetCategory (Just i)

    instance O.OverloadedMethodInfo TransformGetCategoryMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformGetCategory",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformGetCategory"
            })

    #endif

    -- method Transform::invert
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "transform to invert"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_invert" gsk_transform_invert ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO (Ptr Transform)

    -- | Inverts the given transform.
    --
    -- If /@self@/ is not invertible, @NULL@ is returned.
    -- Note that inverting @NULL@ also returns @NULL@, which is
    -- the correct inverse of @NULL@. If you need to differentiate
    -- between those cases, you should check /@self@/ is not @NULL@
    -- before calling this function.
    --
    -- This function consumes /@self@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformInvert ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: transform to invert
        -> m (Maybe Transform)
        -- ^ __Returns:__ The inverted transform
    transformInvert :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m (Maybe Transform)
    transformInvert Maybe Transform
    self = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jSelf
                return jSelf'
        result <- gsk_transform_invert maybeSelf
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust self touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformInvertMethodInfo
    instance (signature ~ (m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformInvertMethodInfo Transform signature where
        overloadedMethod i = transformInvert (Just i)

    instance O.OverloadedMethodInfo TransformInvertMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformInvert",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformInvert"
            })

    #endif

    -- method Transform::matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "matrix"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Matrix" }
    --           , argCType = Just "const graphene_matrix_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the matrix to multiply @next with"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_matrix" gsk_transform_matrix ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Matrix.Matrix ->           -- matrix : TInterface (Name {namespace = "Graphene", name = "Matrix"})
        IO (Ptr Transform)

    -- | Multiplies /@next@/ with the given /@matrix@/.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformMatrix ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Graphene.Matrix.Matrix
        -- ^ /@matrix@/: the matrix to multiply /@next@/ with
        -> m Transform
        -- ^ __Returns:__ The new transform
    transformMatrix :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Matrix -> m Transform
    transformMatrix Maybe Transform
    next Matrix
    matrix = IO Transform -> m Transform
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        matrix' <- unsafeManagedPtrGetPtr matrix
        result <- gsk_transform_matrix maybeNext matrix'
        checkUnexpectedReturnNULL "transformMatrix" result
        result' <- (wrapBoxed Transform) result
        whenJust next touchManagedPtr
        touchManagedPtr matrix
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TransformMatrixMethodInfo
    instance (signature ~ (Graphene.Matrix.Matrix -> m Transform), MonadIO m) => O.OverloadedMethod TransformMatrixMethodInfo Transform signature where
        overloadedMethod i = transformMatrix (Just i)

    instance O.OverloadedMethodInfo TransformMatrixMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformMatrix"
            })

    #endif

    -- method Transform::matrix_2d
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "xx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the xx member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "yx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the yx member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "xy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the xy member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "yy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the yy member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "dx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the x0 member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "dy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the y0 member" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_matrix_2d" gsk_transform_matrix_2d ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- xx : TBasicType TFloat
        CFloat ->                               -- yx : TBasicType TFloat
        CFloat ->                               -- xy : TBasicType TFloat
        CFloat ->                               -- yy : TBasicType TFloat
        CFloat ->                               -- dx : TBasicType TFloat
        CFloat ->                               -- dy : TBasicType TFloat
        IO (Ptr Transform)

    -- | Multiplies /@next@/ with the matrix [ xx yx x0; xy yy y0; 0 0 1 ].
    --
    -- The result of calling 'GI.Gsk.Structs.Transform.transformTo2d' on the returned
    -- t'GI.Gsk.Structs.Transform.Transform' should match the input passed to this
    -- function.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    --
    -- /Since: 4.20/
    transformMatrix2d ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@xx@/: the xx member
        -> Float
        -- ^ /@yx@/: the yx member
        -> Float
        -- ^ /@xy@/: the xy member
        -> Float
        -- ^ /@yy@/: the yy member
        -> Float
        -- ^ /@dx@/: the x0 member
        -> Float
        -- ^ /@dy@/: the y0 member
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformMatrix2d :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> Float
    -> m (Maybe Transform)
    transformMatrix2d Maybe Transform
    next Float
    xx Float
    yx Float
    xy Float
    yy Float
    dx Float
    dy = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let xx' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xx
        let yx' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yx
        let xy' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    xy
        let yy' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    yy
        let dx' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    dx
        let dy' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    dy
        result <- gsk_transform_matrix_2d maybeNext xx' yx' xy' yy' dx' dy'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformMatrix2dMethodInfo
    instance (signature ~ (Float -> Float -> Float -> Float -> Float -> Float -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformMatrix2dMethodInfo Transform signature where
        overloadedMethod i = transformMatrix2d (Just i)

    instance O.OverloadedMethodInfo TransformMatrix2dMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformMatrix2d",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformMatrix2d"
            })

    #endif

    -- method Transform::perspective
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "depth"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "distance of the z=0 plane. Lower values give a more\n  flattened pyramid and therefore a more pronounced\n  perspective effect."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_perspective" gsk_transform_perspective ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- depth : TBasicType TFloat
        IO (Ptr Transform)

    -- | Applies a perspective projection transform.
    --
    -- This transform scales points in X and Y based on their Z value,
    -- scaling points with positive Z values away from the origin, and
    -- those with negative Z values towards the origin. Points
    -- on the z=0 plane are unchanged.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformPerspective ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@depth@/: distance of the z=0 plane. Lower values give a more
        --   flattened pyramid and therefore a more pronounced
        --   perspective effect.
        -> m Transform
        -- ^ __Returns:__ The new transform
    transformPerspective :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> m Transform
    transformPerspective Maybe Transform
    next Float
    depth = IO Transform -> m Transform
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Transform -> m Transform) -> IO Transform -> m Transform
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let depth' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    depth
        result <- gsk_transform_perspective maybeNext depth'
        checkUnexpectedReturnNULL "transformPerspective" result
        result' <- (wrapBoxed Transform) result
        whenJust next touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TransformPerspectiveMethodInfo
    instance (signature ~ (Float -> m Transform), MonadIO m) => O.OverloadedMethod TransformPerspectiveMethodInfo Transform signature where
        overloadedMethod i = transformPerspective (Just i)

    instance O.OverloadedMethodInfo TransformPerspectiveMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformPerspective",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformPerspective"
            })

    #endif

    -- method Transform::print
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "string"
    --           , argType =
    --               TInterface Name { namespace = "GLib" , name = "String" }
    --           , argCType = Just "GString*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The string to print into"
    --                 , 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 "gsk_transform_print" gsk_transform_print ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})
        IO ()

    -- | Converts the transform into a human-readable representation.
    --
    -- The result of this function can later be parsed with
    -- 'GI.Gsk.Structs.Transform.transformParse'.
    transformPrint ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> GLib.String.String
        -- ^ /@string@/: The string to print into
        -> m ()
    transformPrint :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> String -> m ()
    transformPrint Maybe Transform
    self String
    string = 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
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        string' <- unsafeManagedPtrGetPtr string
        gsk_transform_print maybeSelf string'
        whenJust self touchManagedPtr
        touchManagedPtr string
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TransformPrintMethodInfo
    instance (signature ~ (GLib.String.String -> m ()), MonadIO m) => O.OverloadedMethod TransformPrintMethodInfo Transform signature where
        overloadedMethod i = transformPrint (Just i)

    instance O.OverloadedMethodInfo TransformPrintMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformPrint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformPrint"
            })

    #endif

    -- method Transform::ref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_ref" gsk_transform_ref ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO (Ptr Transform)

    -- | Acquires a reference on the given transform.
    transformRef ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> m (Maybe Transform)
        -- ^ __Returns:__ the transform with an additional reference
    transformRef :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m (Maybe Transform)
    transformRef Maybe Transform
    self = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        result <- gsk_transform_ref maybeSelf
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust self touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformRefMethodInfo
    instance (signature ~ (m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformRefMethodInfo Transform signature where
        overloadedMethod i = transformRef (Just i)

    instance O.OverloadedMethodInfo TransformRefMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformRef",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformRef"
            })

    #endif

    -- method Transform::rotate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "angle"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the rotation angle, in degrees (clockwise)"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_rotate" gsk_transform_rotate ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- angle : TBasicType TFloat
        IO (Ptr Transform)

    -- | Rotates /@next@/ by an angle around the Z axis.
    --
    -- The rotation happens around the origin point of (0, 0).
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformRotate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@angle@/: the rotation angle, in degrees (clockwise)
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformRotate :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> m (Maybe Transform)
    transformRotate Maybe Transform
    next Float
    angle = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let angle' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    angle
        result <- gsk_transform_rotate maybeNext angle'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformRotateMethodInfo
    instance (signature ~ (Float -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformRotateMethodInfo Transform signature where
        overloadedMethod i = transformRotate (Just i)

    instance O.OverloadedMethodInfo TransformRotateMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformRotate",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformRotate"
            })

    #endif

    -- method Transform::rotate_3d
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "angle"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the rotation angle, in degrees (clockwise)"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "axis"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "The rotation axis" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_rotate_3d" gsk_transform_rotate_3d ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- angle : TBasicType TFloat
        Ptr Graphene.Vec3.Vec3 ->               -- axis : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        IO (Ptr Transform)

    -- | Rotates /@next@/ /@angle@/ degrees around /@axis@/.
    --
    -- For a rotation in 2D space, use 'GI.Gsk.Structs.Transform.transformRotate'
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformRotate3d ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@angle@/: the rotation angle, in degrees (clockwise)
        -> Graphene.Vec3.Vec3
        -- ^ /@axis@/: The rotation axis
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformRotate3d :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> Vec3 -> m (Maybe Transform)
    transformRotate3d Maybe Transform
    next Float
    angle Vec3
    axis = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let angle' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    angle
        axis' <- unsafeManagedPtrGetPtr axis
        result <- gsk_transform_rotate_3d maybeNext angle' axis'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        touchManagedPtr axis
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformRotate3dMethodInfo
    instance (signature ~ (Float -> Graphene.Vec3.Vec3 -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformRotate3dMethodInfo Transform signature where
        overloadedMethod i = transformRotate3d (Just i)

    instance O.OverloadedMethodInfo TransformRotate3dMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformRotate3d",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformRotate3d"
            })

    #endif

    -- method Transform::scale
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "factor_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "scaling factor on the X axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factor_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "scaling factor on the Y axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_scale" gsk_transform_scale ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- factor_x : TBasicType TFloat
        CFloat ->                               -- factor_y : TBasicType TFloat
        IO (Ptr Transform)

    -- | Scales /@next@/ in 2-dimensional space by the given factors.
    --
    -- Use 'GI.Gsk.Structs.Transform.transformScale3d' to scale in all 3 dimensions.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformScale ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@factorX@/: scaling factor on the X axis
        -> Float
        -- ^ /@factorY@/: scaling factor on the Y axis
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformScale :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> Float -> m (Maybe Transform)
    transformScale Maybe Transform
    next Float
    factorX Float
    factorY = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let factorX' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factorX
        let factorY' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factorY
        result <- gsk_transform_scale maybeNext factorX' factorY'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformScaleMethodInfo
    instance (signature ~ (Float -> Float -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformScaleMethodInfo Transform signature where
        overloadedMethod i = transformScale (Just i)

    instance O.OverloadedMethodInfo TransformScaleMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformScale",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformScale"
            })

    #endif

    -- method Transform::scale_3d
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "factor_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "scaling factor on the X axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factor_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "scaling factor on the Y axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factor_z"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "scaling factor on the Z axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_scale_3d" gsk_transform_scale_3d ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- factor_x : TBasicType TFloat
        CFloat ->                               -- factor_y : TBasicType TFloat
        CFloat ->                               -- factor_z : TBasicType TFloat
        IO (Ptr Transform)

    -- | Scales /@next@/ by the given factors.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformScale3d ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@factorX@/: scaling factor on the X axis
        -> Float
        -- ^ /@factorY@/: scaling factor on the Y axis
        -> Float
        -- ^ /@factorZ@/: scaling factor on the Z axis
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformScale3d :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> Float -> Float -> m (Maybe Transform)
    transformScale3d Maybe Transform
    next Float
    factorX Float
    factorY Float
    factorZ = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let factorX' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factorX
        let factorY' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factorY
        let factorZ' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factorZ
        result <- gsk_transform_scale_3d maybeNext factorX' factorY' factorZ'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformScale3dMethodInfo
    instance (signature ~ (Float -> Float -> Float -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformScale3dMethodInfo Transform signature where
        overloadedMethod i = transformScale3d (Just i)

    instance O.OverloadedMethodInfo TransformScale3dMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformScale3d",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformScale3d"
            })

    #endif

    -- method Transform::skew
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "skew_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "skew factor, in degrees, on the X axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "skew_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "skew factor, in degrees, on the Y axis"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_skew" gsk_transform_skew ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        CFloat ->                               -- skew_x : TBasicType TFloat
        CFloat ->                               -- skew_y : TBasicType TFloat
        IO (Ptr Transform)

    -- | Applies a skew transform.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    --
    -- /Since: 4.6/
    transformSkew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Float
        -- ^ /@skewX@/: skew factor, in degrees, on the X axis
        -> Float
        -- ^ /@skewY@/: skew factor, in degrees, on the Y axis
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformSkew :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Float -> Float -> m (Maybe Transform)
    transformSkew Maybe Transform
    next Float
    skewX Float
    skewY = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        let skewX' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    skewX
        let skewY' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    skewY
        result <- gsk_transform_skew maybeNext skewX' skewY'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformSkewMethodInfo
    instance (signature ~ (Float -> Float -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformSkewMethodInfo Transform signature where
        overloadedMethod i = transformSkew (Just i)

    instance O.OverloadedMethodInfo TransformSkewMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformSkew",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformSkew"
            })

    #endif

    -- method Transform::to_2d
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a 2D transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_xx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the xx member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_yx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the yx member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_xy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the xy member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_yy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the yy member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the x0 member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the y0 member"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_2d" gsk_transform_to_2d ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr CFloat ->                           -- out_xx : TBasicType TFloat
        Ptr CFloat ->                           -- out_yx : TBasicType TFloat
        Ptr CFloat ->                           -- out_xy : TBasicType TFloat
        Ptr CFloat ->                           -- out_yy : TBasicType TFloat
        Ptr CFloat ->                           -- out_dx : TBasicType TFloat
        Ptr CFloat ->                           -- out_dy : TBasicType TFloat
        IO ()

    -- | Converts a transform to a 2D transformation matrix.
    --
    -- /@self@/ must be a 2D transformation. If you are not
    -- sure, use
    --
    --     'GI.Gsk.Structs.Transform.transformGetCategory' >= GSK_TRANSFORM_CATEGORY_2D
    --
    -- to check.
    --
    -- The returned values are a subset of the full 4x4 matrix that
    -- is computed by 'GI.Gsk.Structs.Transform.transformToMatrix' and have the
    -- following layout:
    --
    --
    --
    -- >  | xx yx |   |  a  b  0 |
    -- >  | xy yy | = |  c  d  0 |
    -- >  | dx dy |   | tx ty  1 |
    --
    --
    -- This function can be used to convert between a @GskTransform@
    -- and a matrix type from other 2D drawing libraries, in particular
    -- Cairo.
    transformTo2d ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a 2D transform
        -> m ((Float, Float, Float, Float, Float, Float))
    transformTo2d :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> m (Float, Float, Float, Float, Float, Float)
    transformTo2d Transform
    self = IO (Float, Float, Float, Float, Float, Float)
    -> m (Float, Float, Float, Float, Float, Float)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Float, Float, Float, Float, Float, Float)
     -> m (Float, Float, Float, Float, Float, Float))
    -> IO (Float, Float, Float, Float, Float, Float)
    -> m (Float, Float, Float, Float, Float, Float)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        outXx <- allocMem :: IO (Ptr CFloat)
        outYx <- allocMem :: IO (Ptr CFloat)
        outXy <- allocMem :: IO (Ptr CFloat)
        outYy <- allocMem :: IO (Ptr CFloat)
        outDx <- allocMem :: IO (Ptr CFloat)
        outDy <- allocMem :: IO (Ptr CFloat)
        gsk_transform_to_2d self' outXx outYx outXy outYy outDx outDy
        outXx' <- peek outXx
        let outXx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outXx'
        outYx' <- peek outYx
        let outYx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outYx'
        outXy' <- peek outXy
        let outXy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outXy'
        outYy' <- peek outYy
        let outYy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outYy'
        outDx' <- peek outDx
        let outDx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDx'
        outDy' <- peek outDy
        let outDy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDy'
        touchManagedPtr self
        freeMem outXx
        freeMem outYx
        freeMem outXy
        freeMem outYy
        freeMem outDx
        freeMem outDy
        return (outXx'', outYx'', outXy'', outYy'', outDx'', outDy'')

    #if defined(ENABLE_OVERLOADING)
    data TransformTo2dMethodInfo
    instance (signature ~ (m ((Float, Float, Float, Float, Float, Float))), MonadIO m) => O.OverloadedMethod TransformTo2dMethodInfo Transform signature where
        overloadedMethod = transformTo2d

    instance O.OverloadedMethodInfo TransformTo2dMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTo2d",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTo2d"
            })

    #endif

    -- method Transform::to_2d_components
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_skew_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the skew factor\n  in the  x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_skew_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the skew factor\n  in the  y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_scale_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the scale\n  factor in the x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_scale_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the scale\n  factor in the y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_angle"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the rotation angle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_2d_components" gsk_transform_to_2d_components ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr CFloat ->                           -- out_skew_x : TBasicType TFloat
        Ptr CFloat ->                           -- out_skew_y : TBasicType TFloat
        Ptr CFloat ->                           -- out_scale_x : TBasicType TFloat
        Ptr CFloat ->                           -- out_scale_y : TBasicType TFloat
        Ptr CFloat ->                           -- out_angle : TBasicType TFloat
        Ptr CFloat ->                           -- out_dx : TBasicType TFloat
        Ptr CFloat ->                           -- out_dy : TBasicType TFloat
        IO ()

    -- | Converts a transform to 2D transformation factors.
    --
    -- To recreate an equivalent transform from the factors returned
    -- by this function, use
    --
    --     gsk_transform_skew (
    --         gsk_transform_scale (
    --             gsk_transform_rotate (
    --                 gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (dx, dy)),
    --                 angle),
    --             scale_x, scale_y),
    --         skew_x, skew_y)
    --
    -- /@self@/ must be a 2D transformation. If you are not sure, use
    --
    --     'GI.Gsk.Structs.Transform.transformGetCategory' >= GSK_TRANSFORM_CATEGORY_2D
    --
    -- to check.
    --
    -- /Since: 4.6/
    transformTo2dComponents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a transform
        -> m ((Float, Float, Float, Float, Float, Float, Float))
    transformTo2dComponents :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> m (Float, Float, Float, Float, Float, Float, Float)
    transformTo2dComponents Transform
    self = IO (Float, Float, Float, Float, Float, Float, Float)
    -> m (Float, Float, Float, Float, Float, Float, Float)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Float, Float, Float, Float, Float, Float, Float)
     -> m (Float, Float, Float, Float, Float, Float, Float))
    -> IO (Float, Float, Float, Float, Float, Float, Float)
    -> m (Float, Float, Float, Float, Float, Float, Float)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        outSkewX <- allocMem :: IO (Ptr CFloat)
        outSkewY <- allocMem :: IO (Ptr CFloat)
        outScaleX <- allocMem :: IO (Ptr CFloat)
        outScaleY <- allocMem :: IO (Ptr CFloat)
        outAngle <- allocMem :: IO (Ptr CFloat)
        outDx <- allocMem :: IO (Ptr CFloat)
        outDy <- allocMem :: IO (Ptr CFloat)
        gsk_transform_to_2d_components self' outSkewX outSkewY outScaleX outScaleY outAngle outDx outDy
        outSkewX' <- peek outSkewX
        let outSkewX'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outSkewX'
        outSkewY' <- peek outSkewY
        let outSkewY'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outSkewY'
        outScaleX' <- peek outScaleX
        let outScaleX'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outScaleX'
        outScaleY' <- peek outScaleY
        let outScaleY'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outScaleY'
        outAngle' <- peek outAngle
        let outAngle'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outAngle'
        outDx' <- peek outDx
        let outDx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDx'
        outDy' <- peek outDy
        let outDy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDy'
        touchManagedPtr self
        freeMem outSkewX
        freeMem outSkewY
        freeMem outScaleX
        freeMem outScaleY
        freeMem outAngle
        freeMem outDx
        freeMem outDy
        return (outSkewX'', outSkewY'', outScaleX'', outScaleY'', outAngle'', outDx'', outDy'')

    #if defined(ENABLE_OVERLOADING)
    data TransformTo2dComponentsMethodInfo
    instance (signature ~ (m ((Float, Float, Float, Float, Float, Float, Float))), MonadIO m) => O.OverloadedMethod TransformTo2dComponentsMethodInfo Transform signature where
        overloadedMethod = transformTo2dComponents

    instance O.OverloadedMethodInfo TransformTo2dComponentsMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTo2dComponents",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTo2dComponents"
            })

    #endif

    -- method Transform::to_affine
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_scale_x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the scale\n  factor in the x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_scale_y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the scale\n  factor in the y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_affine" gsk_transform_to_affine ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr CFloat ->                           -- out_scale_x : TBasicType TFloat
        Ptr CFloat ->                           -- out_scale_y : TBasicType TFloat
        Ptr CFloat ->                           -- out_dx : TBasicType TFloat
        Ptr CFloat ->                           -- out_dy : TBasicType TFloat
        IO ()

    -- | Converts a transform to 2D affine transformation factors.
    --
    -- To recreate an equivalent transform from the factors returned
    -- by this function, use
    --
    --     gsk_transform_scale (
    --         gsk_transform_translate (
    --             NULL,
    --             &GRAPHENE_POINT_T (dx, dy)),
    --         sx, sy)
    --
    -- /@self@/ must be a 2D affine transformation. If you are not
    -- sure, use
    --
    --     'GI.Gsk.Structs.Transform.transformGetCategory' >= GSK_TRANSFORM_CATEGORY_2D_AFFINE
    --
    -- to check.
    transformToAffine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a transform
        -> m ((Float, Float, Float, Float))
    transformToAffine :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> m (Float, Float, Float, Float)
    transformToAffine Transform
    self = IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Float, Float, Float, Float) -> m (Float, Float, Float, Float))
    -> IO (Float, Float, Float, Float)
    -> m (Float, Float, Float, Float)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        outScaleX <- allocMem :: IO (Ptr CFloat)
        outScaleY <- allocMem :: IO (Ptr CFloat)
        outDx <- allocMem :: IO (Ptr CFloat)
        outDy <- allocMem :: IO (Ptr CFloat)
        gsk_transform_to_affine self' outScaleX outScaleY outDx outDy
        outScaleX' <- peek outScaleX
        let outScaleX'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outScaleX'
        outScaleY' <- peek outScaleY
        let outScaleY'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outScaleY'
        outDx' <- peek outDx
        let outDx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDx'
        outDy' <- peek outDy
        let outDy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDy'
        touchManagedPtr self
        freeMem outScaleX
        freeMem outScaleY
        freeMem outDx
        freeMem outDy
        return (outScaleX'', outScaleY'', outDx'', outDy'')

    #if defined(ENABLE_OVERLOADING)
    data TransformToAffineMethodInfo
    instance (signature ~ (m ((Float, Float, Float, Float))), MonadIO m) => O.OverloadedMethod TransformToAffineMethodInfo Transform signature where
        overloadedMethod = transformToAffine

    instance O.OverloadedMethodInfo TransformToAffineMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformToAffine",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformToAffine"
            })

    #endif

    -- method Transform::to_matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_matrix"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Matrix" }
    --           , argCType = Just "graphene_matrix_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the matrix"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_matrix" gsk_transform_to_matrix ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Matrix.Matrix ->           -- out_matrix : TInterface (Name {namespace = "Graphene", name = "Matrix"})
        IO ()

    -- | Computes the 4x4 matrix for the transform.
    --
    -- The previous value of /@outMatrix@/ will be ignored.
    transformToMatrix ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> m (Graphene.Matrix.Matrix)
    transformToMatrix :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m Matrix
    transformToMatrix Maybe Transform
    self = IO Matrix -> m Matrix
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Matrix -> m Matrix) -> IO Matrix -> m Matrix
    forall a b. (a -> b) -> a -> b
    $ do
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        outMatrix <- SP.callocBoxedBytes 64 :: IO (Ptr Graphene.Matrix.Matrix)
        gsk_transform_to_matrix maybeSelf outMatrix
        outMatrix' <- (wrapBoxed Graphene.Matrix.Matrix) outMatrix
        whenJust self touchManagedPtr
        return outMatrix'

    #if defined(ENABLE_OVERLOADING)
    data TransformToMatrixMethodInfo
    instance (signature ~ (m (Graphene.Matrix.Matrix)), MonadIO m) => O.OverloadedMethod TransformToMatrixMethodInfo Transform signature where
        overloadedMethod i = transformToMatrix (Just i)

    instance O.OverloadedMethodInfo TransformToMatrixMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformToMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformToMatrix"
            })

    #endif

    -- method Transform::to_string
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_string" gsk_transform_to_string ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO CString

    -- | Converts the transform into a human-readable string.
    --
    -- The resulting string can be parsed with 'GI.Gsk.Structs.Transform.transformParse'.
    --
    -- This is a wrapper around 'GI.Gsk.Structs.Transform.transformPrint'.
    transformToString ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> m T.Text
        -- ^ __Returns:__ A new string for /@self@/
    transformToString :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m Text
    transformToString Maybe Transform
    self = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        result <- gsk_transform_to_string maybeSelf
        checkUnexpectedReturnNULL "transformToString" result
        result' <- cstringToText result
        freeMem result
        whenJust self touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data TransformToStringMethodInfo
    instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod TransformToStringMethodInfo Transform signature where
        overloadedMethod i = transformToString (Just i)

    instance O.OverloadedMethodInfo TransformToStringMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformToString",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformToString"
            })

    #endif

    -- method Transform::to_translate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_dx"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the x direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "out_dy"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the translation\n  in the y direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_to_translate" gsk_transform_to_translate ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr CFloat ->                           -- out_dx : TBasicType TFloat
        Ptr CFloat ->                           -- out_dy : TBasicType TFloat
        IO ()

    -- | Converts a transform to a translation operation.
    --
    -- /@self@/ must be a 2D transformation. If you are not
    -- sure, use
    --
    --     'GI.Gsk.Structs.Transform.transformGetCategory' >= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE
    --
    -- to check.
    transformToTranslate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a transform
        -> m ((Float, Float))
    transformToTranslate :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> m (Float, Float)
    transformToTranslate Transform
    self = IO (Float, Float) -> m (Float, Float)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Float, Float) -> m (Float, Float))
    -> IO (Float, Float) -> m (Float, Float)
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        outDx <- allocMem :: IO (Ptr CFloat)
        outDy <- allocMem :: IO (Ptr CFloat)
        gsk_transform_to_translate self' outDx outDy
        outDx' <- peek outDx
        let outDx'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDx'
        outDy' <- peek outDy
        let outDy'' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    outDy'
        touchManagedPtr self
        freeMem outDx
        freeMem outDy
        return (outDx'', outDy'')

    #if defined(ENABLE_OVERLOADING)
    data TransformToTranslateMethodInfo
    instance (signature ~ (m ((Float, Float))), MonadIO m) => O.OverloadedMethod TransformToTranslateMethodInfo Transform signature where
        overloadedMethod = transformToTranslate

    instance O.OverloadedMethodInfo TransformToTranslateMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformToTranslate",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformToTranslate"
            })

    #endif

    -- method Transform::transform
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "transform to apply @other to"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "other"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "transform to apply" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_transform" gsk_transform_transform ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Transform ->                        -- other : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO (Ptr Transform)

    -- | Applies all the operations from /@other@/ to /@next@/.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformTransform ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: transform to apply /@other@/ to
        -> Maybe (Transform)
        -- ^ /@other@/: transform to apply
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformTransform :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Maybe Transform -> m (Maybe Transform)
    transformTransform Maybe Transform
    next Maybe Transform
    other = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        maybeOther <- case other of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jOther -> do
                jOther' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jOther
                return jOther'
        result <- gsk_transform_transform maybeNext maybeOther
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        whenJust other touchManagedPtr
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformTransformMethodInfo
    instance (signature ~ (Maybe (Transform) -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformTransformMethodInfo Transform signature where
        overloadedMethod i = transformTransform (Just i)

    instance O.OverloadedMethodInfo TransformTransformMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTransform",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTransform"
            })

    #endif

    -- method Transform::transform_bounds
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "rect"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Rect" }
    --           , argCType = Just "const graphene_rect_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the rectangle to transform"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_rect"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Rect" }
    --           , argCType = Just "graphene_rect_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "return location for the bounds\n  of the transformed rectangle"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_transform_bounds" gsk_transform_transform_bounds ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Rect.Rect ->               -- rect : TInterface (Name {namespace = "Graphene", name = "Rect"})
        Ptr Graphene.Rect.Rect ->               -- out_rect : TInterface (Name {namespace = "Graphene", name = "Rect"})
        IO ()

    -- | Transforms a rectangle using the given transform.
    --
    -- The result is the bounding box containing the coplanar quad.
    --
    -- The input and output rect may point to the same rectangle.
    transformTransformBounds ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a transform
        -> Graphene.Rect.Rect
        -- ^ /@rect@/: the rectangle to transform
        -> m (Graphene.Rect.Rect)
    transformTransformBounds :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> Rect -> m Rect
    transformTransformBounds Transform
    self Rect
    rect = IO Rect -> m Rect
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Rect -> m Rect) -> IO Rect -> m Rect
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        rect' <- unsafeManagedPtrGetPtr rect
        outRect <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Rect.Rect)
        gsk_transform_transform_bounds self' rect' outRect
        outRect' <- (wrapBoxed Graphene.Rect.Rect) outRect
        touchManagedPtr self
        touchManagedPtr rect
        return outRect'

    #if defined(ENABLE_OVERLOADING)
    data TransformTransformBoundsMethodInfo
    instance (signature ~ (Graphene.Rect.Rect -> m (Graphene.Rect.Rect)), MonadIO m) => O.OverloadedMethod TransformTransformBoundsMethodInfo Transform signature where
        overloadedMethod = transformTransformBounds

    instance O.OverloadedMethodInfo TransformTransformBoundsMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTransformBounds",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTransformBounds"
            })

    #endif

    -- method Transform::transform_point
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the point to transform"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "graphene_point_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for\n  the transformed point"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_transform_point" gsk_transform_transform_point ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Point.Point ->             -- point : TInterface (Name {namespace = "Graphene", name = "Point"})
        Ptr Graphene.Point.Point ->             -- out_point : TInterface (Name {namespace = "Graphene", name = "Point"})
        IO ()

    -- | Transforms a point using the given transform.
    transformTransformPoint ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Transform
        -- ^ /@self@/: a transform
        -> Graphene.Point.Point
        -- ^ /@point@/: the point to transform
        -> m (Graphene.Point.Point)
    transformTransformPoint :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Transform -> Point -> m Point
    transformTransformPoint Transform
    self Point
    point = IO Point -> m Point
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Point -> m Point) -> IO Point -> m Point
    forall a b. (a -> b) -> a -> b
    $ do
        self' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    self
        point' <- unsafeManagedPtrGetPtr point
        outPoint <- SP.callocBoxedBytes 8 :: IO (Ptr Graphene.Point.Point)
        gsk_transform_transform_point self' point' outPoint
        outPoint' <- (wrapBoxed Graphene.Point.Point) outPoint
        touchManagedPtr self
        touchManagedPtr point
        return outPoint'

    #if defined(ENABLE_OVERLOADING)
    data TransformTransformPointMethodInfo
    instance (signature ~ (Graphene.Point.Point -> m (Graphene.Point.Point)), MonadIO m) => O.OverloadedMethod TransformTransformPointMethodInfo Transform signature where
        overloadedMethod = transformTransformPoint

    instance O.OverloadedMethodInfo TransformTransformPointMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTransformPoint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTransformPoint"
            })

    #endif

    -- method Transform::translate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point" }
    --           , argCType = Just "const graphene_point_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the point to translate the transform by"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_translate" gsk_transform_translate ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Point.Point ->             -- point : TInterface (Name {namespace = "Graphene", name = "Point"})
        IO (Ptr Transform)

    -- | Translates /@next@/ in 2-dimensional space by /@point@/.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformTranslate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Graphene.Point.Point
        -- ^ /@point@/: the point to translate the transform by
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformTranslate :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Point -> m (Maybe Transform)
    transformTranslate Maybe Transform
    next Point
    point = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        point' <- unsafeManagedPtrGetPtr point
        result <- gsk_transform_translate maybeNext point'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        touchManagedPtr point
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformTranslateMethodInfo
    instance (signature ~ (Graphene.Point.Point -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformTranslateMethodInfo Transform signature where
        overloadedMethod i = transformTranslate (Just i)

    instance O.OverloadedMethodInfo TransformTranslateMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTranslate",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTranslate"
            })

    #endif

    -- method Transform::translate_3d
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "next"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the next transform" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the point to translate the transform by"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gsk" , name = "Transform" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_translate_3d" gsk_transform_translate_3d ::
        Ptr Transform ->                        -- next : TInterface (Name {namespace = "Gsk", name = "Transform"})
        Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO (Ptr Transform)

    -- | Translates /@next@/ by /@point@/.
    --
    -- This function consumes /@next@/. Use 'GI.Gsk.Structs.Transform.transformRef' first
    -- if you want to keep it around.
    transformTranslate3d ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@next@/: the next transform
        -> Graphene.Point3D.Point3D
        -- ^ /@point@/: the point to translate the transform by
        -> m (Maybe Transform)
        -- ^ __Returns:__ The new transform
    transformTranslate3d :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> Point3D -> m (Maybe Transform)
    transformTranslate3d Maybe Transform
    next Point3D
    point = IO (Maybe Transform) -> m (Maybe Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Transform) -> m (Maybe Transform))
    -> IO (Maybe Transform) -> m (Maybe Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        maybeNext <- case Maybe Transform
    next of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jNext -> do
                jNext' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Transform
    jNext
                return jNext'
        point' <- unsafeManagedPtrGetPtr point
        result <- gsk_transform_translate_3d maybeNext point'
        maybeResult <- convertIfNonNull result $ \Ptr Transform
    result' -> do
            result'' <- ((ManagedPtr Transform -> Transform)
    -> Ptr Transform -> IO Transform
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Transform -> Transform
    Transform) Ptr Transform
    result'
            return result''
        whenJust next touchManagedPtr
        touchManagedPtr point
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data TransformTranslate3dMethodInfo
    instance (signature ~ (Graphene.Point3D.Point3D -> m (Maybe Transform)), MonadIO m) => O.OverloadedMethod TransformTranslate3dMethodInfo Transform signature where
        overloadedMethod i = transformTranslate3d (Just i)

    instance O.OverloadedMethodInfo TransformTranslate3dMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformTranslate3d",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformTranslate3d"
            })

    #endif

    -- method Transform::unref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "self"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a transform" , 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 "gsk_transform_unref" gsk_transform_unref ::
        Ptr Transform ->                        -- self : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO ()

    -- | Releases a reference on the given transform.
    --
    -- If the reference was the last, the resources associated to the /@self@/ are
    -- freed.
    transformUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Maybe (Transform)
        -- ^ /@self@/: a transform
        -> m ()
    transformUnref :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Maybe Transform -> m ()
    transformUnref Maybe Transform
    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
        maybeSelf <- case Maybe Transform
    self of
            Maybe Transform
    Nothing -> Ptr Transform -> IO (Ptr Transform)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Transform
    forall a. Ptr a
    FP.nullPtr
            Just Transform
    jSelf -> do
                jSelf' <- Transform -> IO (Ptr Transform)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Transform
    jSelf
                return jSelf'
        gsk_transform_unref maybeSelf
        whenJust self touchManagedPtr
        return ()

    #if defined(ENABLE_OVERLOADING)
    data TransformUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod TransformUnrefMethodInfo Transform signature where
        overloadedMethod i = transformUnref (Just i)

    instance O.OverloadedMethodInfo TransformUnrefMethodInfo Transform where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Gsk.Structs.Transform.transformUnref",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gsk-4.0.9/docs/GI-Gsk-Structs-Transform.html#v:transformUnref"
            })

    #endif

    -- method Transform::parse
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "string"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the string to parse"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "out_transform"
    --           , argType =
    --               TInterface Name { namespace = "Gsk" , name = "Transform" }
    --           , argCType = Just "GskTransform**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the transform"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "gsk_transform_parse" gsk_transform_parse ::
        CString ->                              -- string : TBasicType TUTF8
        Ptr (Ptr Transform) ->                  -- out_transform : TInterface (Name {namespace = "Gsk", name = "Transform"})
        IO CInt

    -- | Parses a given into a transform.
    --
    -- Strings printed via 'GI.Gsk.Structs.Transform.transformToString'
    -- can be read in again successfully using this function.
    --
    -- If /@string@/ does not describe a valid transform, false
    -- is returned and @NULL@ is put in /@outTransform@/.
    transformParse ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@string@/: the string to parse
        -> m ((Bool, Transform))
        -- ^ __Returns:__ true if /@string@/ described a valid transform
    transformParse :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> m (Bool, Transform)
    transformParse Text
    string = IO (Bool, Transform) -> m (Bool, Transform)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Transform) -> m (Bool, Transform))
    -> IO (Bool, Transform) -> m (Bool, Transform)
    forall a b. (a -> b) -> a -> b
    $ do
        string' <- Text -> IO CString
    textToCString Text
    string
        outTransform <- callocMem :: IO (Ptr (Ptr Transform))
        result <- gsk_transform_parse string' outTransform
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        outTransform' <- peek outTransform
        outTransform'' <- (wrapBoxed Transform) outTransform'
        freeMem string'
        freeMem outTransform
        return (result', outTransform'')

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveTransformMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveTransformMethod "equal" o = TransformEqualMethodInfo
        ResolveTransformMethod "invert" o = TransformInvertMethodInfo
        ResolveTransformMethod "matrix" o = TransformMatrixMethodInfo
        ResolveTransformMethod "matrix2d" o = TransformMatrix2dMethodInfo
        ResolveTransformMethod "perspective" o = TransformPerspectiveMethodInfo
        ResolveTransformMethod "print" o = TransformPrintMethodInfo
        ResolveTransformMethod "ref" o = TransformRefMethodInfo
        ResolveTransformMethod "rotate" o = TransformRotateMethodInfo
        ResolveTransformMethod "rotate3d" o = TransformRotate3dMethodInfo
        ResolveTransformMethod "scale" o = TransformScaleMethodInfo
        ResolveTransformMethod "scale3d" o = TransformScale3dMethodInfo
        ResolveTransformMethod "skew" o = TransformSkewMethodInfo
        ResolveTransformMethod "to2d" o = TransformTo2dMethodInfo
        ResolveTransformMethod "to2dComponents" o = TransformTo2dComponentsMethodInfo
        ResolveTransformMethod "toAffine" o = TransformToAffineMethodInfo
        ResolveTransformMethod "toMatrix" o = TransformToMatrixMethodInfo
        ResolveTransformMethod "toString" o = TransformToStringMethodInfo
        ResolveTransformMethod "toTranslate" o = TransformToTranslateMethodInfo
        ResolveTransformMethod "transform" o = TransformTransformMethodInfo
        ResolveTransformMethod "transformBounds" o = TransformTransformBoundsMethodInfo
        ResolveTransformMethod "transformPoint" o = TransformTransformPointMethodInfo
        ResolveTransformMethod "translate" o = TransformTranslateMethodInfo
        ResolveTransformMethod "translate3d" o = TransformTranslate3dMethodInfo
        ResolveTransformMethod "unref" o = TransformUnrefMethodInfo
        ResolveTransformMethod "getCategory" o = TransformGetCategoryMethodInfo
        ResolveTransformMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif