    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- Describe a rotation using Euler angles.
    --
    -- The contents of the t'GI.Graphene.Structs.Euler.Euler' structure are private
    -- and should never be accessed directly.
    --
    -- /Since: 1.2/

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

    module GI.Graphene.Structs.Euler
        (

    -- * Exported types
        Euler(..)                               ,
        newZeroEuler                            ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [equal]("GI.Graphene.Structs.Euler#g:method:equal"), [free]("GI.Graphene.Structs.Euler#g:method:free"), [init]("GI.Graphene.Structs.Euler#g:method:init"), [initFromEuler]("GI.Graphene.Structs.Euler#g:method:initFromEuler"), [initFromMatrix]("GI.Graphene.Structs.Euler#g:method:initFromMatrix"), [initFromQuaternion]("GI.Graphene.Structs.Euler#g:method:initFromQuaternion"), [initFromRadians]("GI.Graphene.Structs.Euler#g:method:initFromRadians"), [initFromVec3]("GI.Graphene.Structs.Euler#g:method:initFromVec3"), [initWithOrder]("GI.Graphene.Structs.Euler#g:method:initWithOrder"), [reorder]("GI.Graphene.Structs.Euler#g:method:reorder"), [toMatrix]("GI.Graphene.Structs.Euler#g:method:toMatrix"), [toQuaternion]("GI.Graphene.Structs.Euler#g:method:toQuaternion"), [toVec3]("GI.Graphene.Structs.Euler#g:method:toVec3").
    --
    -- ==== Getters
    -- [getAlpha]("GI.Graphene.Structs.Euler#g:method:getAlpha"), [getBeta]("GI.Graphene.Structs.Euler#g:method:getBeta"), [getGamma]("GI.Graphene.Structs.Euler#g:method:getGamma"), [getOrder]("GI.Graphene.Structs.Euler#g:method:getOrder"), [getX]("GI.Graphene.Structs.Euler#g:method:getX"), [getY]("GI.Graphene.Structs.Euler#g:method:getY"), [getZ]("GI.Graphene.Structs.Euler#g:method:getZ").
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveEulerMethod                      ,
    #endif

    -- ** alloc #method:alloc#

        eulerAlloc                              ,

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        EulerEqualMethodInfo                    ,
    #endif
        eulerEqual                              ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        EulerFreeMethodInfo                     ,
    #endif
        eulerFree                               ,

    -- ** getAlpha #method:getAlpha#

    #if defined(ENABLE_OVERLOADING)
        EulerGetAlphaMethodInfo                 ,
    #endif
        eulerGetAlpha                           ,

    -- ** getBeta #method:getBeta#

    #if defined(ENABLE_OVERLOADING)
        EulerGetBetaMethodInfo                  ,
    #endif
        eulerGetBeta                            ,

    -- ** getGamma #method:getGamma#

    #if defined(ENABLE_OVERLOADING)
        EulerGetGammaMethodInfo                 ,
    #endif
        eulerGetGamma                           ,

    -- ** getOrder #method:getOrder#

    #if defined(ENABLE_OVERLOADING)
        EulerGetOrderMethodInfo                 ,
    #endif
        eulerGetOrder                           ,

    -- ** getX #method:getX#

    #if defined(ENABLE_OVERLOADING)
        EulerGetXMethodInfo                     ,
    #endif
        eulerGetX                               ,

    -- ** getY #method:getY#

    #if defined(ENABLE_OVERLOADING)
        EulerGetYMethodInfo                     ,
    #endif
        eulerGetY                               ,

    -- ** getZ #method:getZ#

    #if defined(ENABLE_OVERLOADING)
        EulerGetZMethodInfo                     ,
    #endif
        eulerGetZ                               ,

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        EulerInitMethodInfo                     ,
    #endif
        eulerInit                               ,

    -- ** initFromEuler #method:initFromEuler#

    #if defined(ENABLE_OVERLOADING)
        EulerInitFromEulerMethodInfo            ,
    #endif
        eulerInitFromEuler                      ,

    -- ** initFromMatrix #method:initFromMatrix#

    #if defined(ENABLE_OVERLOADING)
        EulerInitFromMatrixMethodInfo           ,
    #endif
        eulerInitFromMatrix                     ,

    -- ** initFromQuaternion #method:initFromQuaternion#

    #if defined(ENABLE_OVERLOADING)
        EulerInitFromQuaternionMethodInfo       ,
    #endif
        eulerInitFromQuaternion                 ,

    -- ** initFromRadians #method:initFromRadians#

    #if defined(ENABLE_OVERLOADING)
        EulerInitFromRadiansMethodInfo          ,
    #endif
        eulerInitFromRadians                    ,

    -- ** initFromVec3 #method:initFromVec3#

    #if defined(ENABLE_OVERLOADING)
        EulerInitFromVec3MethodInfo             ,
    #endif
        eulerInitFromVec3                       ,

    -- ** initWithOrder #method:initWithOrder#

    #if defined(ENABLE_OVERLOADING)
        EulerInitWithOrderMethodInfo            ,
    #endif
        eulerInitWithOrder                      ,

    -- ** reorder #method:reorder#

    #if defined(ENABLE_OVERLOADING)
        EulerReorderMethodInfo                  ,
    #endif
        eulerReorder                            ,

    -- ** toMatrix #method:toMatrix#

    #if defined(ENABLE_OVERLOADING)
        EulerToMatrixMethodInfo                 ,
    #endif
        eulerToMatrix                           ,

    -- ** toQuaternion #method:toQuaternion#

    #if defined(ENABLE_OVERLOADING)
        EulerToQuaternionMethodInfo             ,
    #endif
        eulerToQuaternion                       ,

    -- ** toVec3 #method:toVec3#

    #if defined(ENABLE_OVERLOADING)
        EulerToVec3MethodInfo                   ,
    #endif
        eulerToVec3                             ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import {-# SOURCE #-} qualified GI.Graphene.Enums as Graphene.Enums
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Box as Graphene.Box
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Plane as Graphene.Plane
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Point as Graphene.Point
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Quad as Graphene.Quad
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Quaternion as Graphene.Quaternion
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Ray as Graphene.Ray
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Rect as Graphene.Rect
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Size as Graphene.Size
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Sphere as Graphene.Sphere
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Triangle as Graphene.Triangle
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec2 as Graphene.Vec2
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec4 as Graphene.Vec4

    #else
    import {-# SOURCE #-} qualified GI.Graphene.Enums as Graphene.Enums
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Matrix as Graphene.Matrix
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Quaternion as Graphene.Quaternion
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3

    #endif

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

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

    foreign import ccall "graphene_euler_get_type" c_graphene_euler_get_type ::
        IO GType

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

    instance B.Types.TypedObject Euler where
        glibType :: IO GType
    glibType = IO GType
    c_graphene_euler_get_type

    instance B.Types.GBoxed Euler

    -- | Convert t'Euler' 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 Euler) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_graphene_euler_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Euler -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Euler
    P.Nothing = Ptr GValue -> Ptr Euler -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr Euler
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Euler)
        gvalueSet_ Ptr GValue
    gv (P.Just Euler
    obj) = Euler -> (Ptr Euler -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Euler
    obj (Ptr GValue -> Ptr Euler -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Euler)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr Euler)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr Euler)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newBoxed Euler ptr
            else return P.Nothing

    -- | Construct a t'Euler' struct initialized to zero.
    newZeroEuler :: MonadIO m => m Euler
    newZeroEuler :: forall (m :: * -> *). MonadIO m => m Euler
    newZeroEuler = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr Euler)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes Int
    20 IO (Ptr Euler) -> (Ptr Euler -> IO Euler) -> IO Euler
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr Euler -> Euler) -> Ptr Euler -> IO Euler
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Euler -> Euler
    Euler

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

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

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

    foreign import ccall "graphene_euler_alloc" graphene_euler_alloc ::
        IO (Ptr Euler)

    -- | Allocates a new t'GI.Graphene.Structs.Euler.Euler'.
    --
    -- The contents of the returned structure are undefined.
    --
    -- /Since: 1.2/
    eulerAlloc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Euler
        -- ^ __Returns:__ the newly allocated t'GI.Graphene.Structs.Euler.Euler'
    eulerAlloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Euler
    eulerAlloc  = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Euler)
    graphene_euler_alloc
        checkUnexpectedReturnNULL "eulerAlloc" result
        result' <- (wrapBoxed Euler) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Euler::equal
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , 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 "graphene_euler_equal" graphene_euler_equal ::
        Ptr Euler ->                            -- a : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Euler ->                            -- b : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CInt

    -- | Checks if two t'GI.Graphene.Structs.Euler.Euler' are equal.
    --
    -- /Since: 1.2/
    eulerEqual ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@a@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> Euler
        -- ^ /@b@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Bool
        -- ^ __Returns:__ @true@ if the two t'GI.Graphene.Structs.Euler.Euler' are equal
    eulerEqual :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Euler -> m Bool
    eulerEqual Euler
    a Euler
    b = 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
        a' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    a
        b' <- unsafeManagedPtrGetPtr b
        result <- graphene_euler_equal a' b'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr a
        touchManagedPtr b
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerEqualMethodInfo
    instance (signature ~ (Euler -> m Bool), MonadIO m) => O.OverloadedMethod EulerEqualMethodInfo Euler signature where
        overloadedMethod = eulerEqual

    instance O.OverloadedMethodInfo EulerEqualMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerEqual",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerEqual"
            })

    #endif

    -- method Euler::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , 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 "graphene_euler_free" graphene_euler_free ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO ()

    -- | Frees the resources allocated by 'GI.Graphene.Structs.Euler.eulerAlloc'.
    --
    -- /Since: 1.2/
    eulerFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m ()
    eulerFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m ()
    eulerFree Euler
    e = 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
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        graphene_euler_free e'
        touchManagedPtr e
        return ()

    #if defined(ENABLE_OVERLOADING)
    data EulerFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EulerFreeMethodInfo Euler signature where
        overloadedMethod = eulerFree

    instance O.OverloadedMethodInfo EulerFreeMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerFree",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerFree"
            })

    #endif

    -- method Euler::get_alpha
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_alpha" graphene_euler_get_alpha ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the first component of the Euler angle vector,
    -- depending on the order of rotation.
    --
    -- See also: 'GI.Graphene.Structs.Euler.eulerGetX'
    --
    -- /Since: 1.10/
    eulerGetAlpha ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the first component of the Euler angle vector, in radians
    eulerGetAlpha :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetAlpha Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_alpha e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetAlphaMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetAlphaMethodInfo Euler signature where
        overloadedMethod = eulerGetAlpha

    instance O.OverloadedMethodInfo EulerGetAlphaMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetAlpha",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetAlpha"
            })

    #endif

    -- method Euler::get_beta
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_beta" graphene_euler_get_beta ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the second component of the Euler angle vector,
    -- depending on the order of rotation.
    --
    -- See also: 'GI.Graphene.Structs.Euler.eulerGetY'
    --
    -- /Since: 1.10/
    eulerGetBeta ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the second component of the Euler angle vector, in radians
    eulerGetBeta :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetBeta Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_beta e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetBetaMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetBetaMethodInfo Euler signature where
        overloadedMethod = eulerGetBeta

    instance O.OverloadedMethodInfo EulerGetBetaMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetBeta",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetBeta"
            })

    #endif

    -- method Euler::get_gamma
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_gamma" graphene_euler_get_gamma ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the third component of the Euler angle vector,
    -- depending on the order of rotation.
    --
    -- See also: 'GI.Graphene.Structs.Euler.eulerGetZ'
    --
    -- /Since: 1.10/
    eulerGetGamma ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the third component of the Euler angle vector, in radians
    eulerGetGamma :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetGamma Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_gamma e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetGammaMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetGammaMethodInfo Euler signature where
        overloadedMethod = eulerGetGamma

    instance O.OverloadedMethodInfo EulerGetGammaMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetGamma",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetGamma"
            })

    #endif

    -- method Euler::get_order
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Graphene" , name = "EulerOrder" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_order" graphene_euler_get_order ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CInt

    -- | Retrieves the order used to apply the rotations described in the
    -- t'GI.Graphene.Structs.Euler.Euler' structure, when converting to and from other
    -- structures, like t'GI.Graphene.Structs.Quaternion.Quaternion' and t'GI.Graphene.Structs.Matrix.Matrix'.
    --
    -- This function does not return the 'GI.Graphene.Enums.EulerOrderDefault'
    -- enumeration value; it will return the effective order of rotation
    -- instead.
    --
    -- /Since: 1.2/
    eulerGetOrder ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Graphene.Enums.EulerOrder
        -- ^ __Returns:__ the order used to apply the rotations
    eulerGetOrder :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> m EulerOrder
    eulerGetOrder Euler
    e = IO EulerOrder -> m EulerOrder
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO EulerOrder -> m EulerOrder) -> IO EulerOrder -> m EulerOrder
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_order e'
        let result' = (Int -> EulerOrder
    forall a. Enum a => Int -> a
    toEnum (Int -> EulerOrder) -> (CInt -> Int) -> CInt -> EulerOrder
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CInt
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetOrderMethodInfo
    instance (signature ~ (m Graphene.Enums.EulerOrder), MonadIO m) => O.OverloadedMethod EulerGetOrderMethodInfo Euler signature where
        overloadedMethod = eulerGetOrder

    instance O.OverloadedMethodInfo EulerGetOrderMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetOrder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetOrder"
            })

    #endif

    -- method Euler::get_x
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_x" graphene_euler_get_x ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the rotation angle on the X axis, in degrees.
    --
    -- /Since: 1.2/
    eulerGetX ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the rotation angle
    eulerGetX :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetX Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_x e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetXMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetXMethodInfo Euler signature where
        overloadedMethod = eulerGetX

    instance O.OverloadedMethodInfo EulerGetXMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetX",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetX"
            })

    #endif

    -- method Euler::get_y
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_y" graphene_euler_get_y ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the rotation angle on the Y axis, in degrees.
    --
    -- /Since: 1.2/
    eulerGetY ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the rotation angle
    eulerGetY :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetY Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_y e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetYMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetYMethodInfo Euler signature where
        overloadedMethod = eulerGetY

    instance O.OverloadedMethodInfo EulerGetYMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetY",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetY"
            })

    #endif

    -- method Euler::get_z
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TFloat)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_get_z" graphene_euler_get_z ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO CFloat

    -- | Retrieves the rotation angle on the Z axis, in degrees.
    --
    -- /Since: 1.2/
    eulerGetZ ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Float
        -- ^ __Returns:__ the rotation angle
    eulerGetZ :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Float
    eulerGetZ Euler
    e = IO Float -> m Float
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Float -> m Float) -> IO Float -> m Float
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        result <- graphene_euler_get_z e'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerGetZMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod EulerGetZMethodInfo Euler signature where
        overloadedMethod = eulerGetZ

    instance O.OverloadedMethodInfo EulerGetZMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerGetZ",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerGetZ"
            })

    #endif

    -- method Euler::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the X axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Y axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "z"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Z axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init" graphene_euler_init ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        CFloat ->                               -- x : TBasicType TFloat
        CFloat ->                               -- y : TBasicType TFloat
        CFloat ->                               -- z : TBasicType TFloat
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the given angles.
    --
    -- The order of the rotations is 'GI.Graphene.Enums.EulerOrderDefault'.
    --
    -- /Since: 1.2/
    eulerInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Float
        -- ^ /@x@/: rotation angle on the X axis, in degrees
        -> Float
        -- ^ /@y@/: rotation angle on the Y axis, in degrees
        -> Float
        -- ^ /@z@/: rotation angle on the Z axis, in degrees
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInit :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Float -> Float -> Float -> m Euler
    eulerInit Euler
    e Float
    x Float
    y Float
    z = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        let x' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    x
        let y' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    y
        let z' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    z
        result <- graphene_euler_init e' x' y' z'
        checkUnexpectedReturnNULL "eulerInit" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitMethodInfo
    instance (signature ~ (Float -> Float -> Float -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitMethodInfo Euler signature where
        overloadedMethod = eulerInit

    instance O.OverloadedMethodInfo EulerInitMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInit",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInit"
            })

    #endif

    -- method Euler::init_from_euler
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "src"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_from_euler" graphene_euler_init_from_euler ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Euler ->                            -- src : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the angles and order of
    -- another t'GI.Graphene.Structs.Euler.Euler'.
    --
    -- If the t'GI.Graphene.Structs.Euler.Euler' /@src@/ is 'P.Nothing', this function is equivalent
    -- to calling 'GI.Graphene.Structs.Euler.eulerInit' with all angles set to 0.
    --
    -- /Since: 1.2/
    eulerInitFromEuler ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Maybe (Euler)
        -- ^ /@src@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitFromEuler :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Maybe Euler -> m Euler
    eulerInitFromEuler Euler
    e Maybe Euler
    src = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        maybeSrc <- case src of
            Maybe Euler
    Nothing -> Ptr Euler -> IO (Ptr Euler)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Euler
    forall a. Ptr a
    FP.nullPtr
            Just Euler
    jSrc -> do
                jSrc' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    jSrc
                return jSrc'
        result <- graphene_euler_init_from_euler e' maybeSrc
        checkUnexpectedReturnNULL "eulerInitFromEuler" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        whenJust src touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitFromEulerMethodInfo
    instance (signature ~ (Maybe (Euler) -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromEulerMethodInfo Euler signature where
        overloadedMethod = eulerInitFromEuler

    instance O.OverloadedMethodInfo EulerInitFromEulerMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromEuler",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromEuler"
            })

    #endif

    -- method Euler::init_from_matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "m"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Matrix" }
    --           , argCType = Just "const graphene_matrix_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a rotation matrix" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the order used to apply the rotations"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_from_matrix" graphene_euler_init_from_matrix ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Matrix.Matrix ->           -- m : TInterface (Name {namespace = "Graphene", name = "Matrix"})
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the given rotation matrix.
    --
    -- If the t'GI.Graphene.Structs.Matrix.Matrix' /@m@/ is 'P.Nothing', the t'GI.Graphene.Structs.Euler.Euler' will
    -- be initialized with all angles set to 0.
    --
    -- /Since: 1.2/
    eulerInitFromMatrix ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Maybe (Graphene.Matrix.Matrix)
        -- ^ /@m@/: a rotation matrix
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: the order used to apply the rotations
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitFromMatrix :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Maybe Matrix -> EulerOrder -> m Euler
    eulerInitFromMatrix Euler
    e Maybe Matrix
    m EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        maybeM <- case m of
            Maybe Matrix
    Nothing -> Ptr Matrix -> IO (Ptr Matrix)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Matrix
    forall a. Ptr a
    FP.nullPtr
            Just Matrix
    jM -> do
                jM' <- Matrix -> IO (Ptr Matrix)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Matrix
    jM
                return jM'
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        result <- graphene_euler_init_from_matrix e' maybeM order'
        checkUnexpectedReturnNULL "eulerInitFromMatrix" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        whenJust m touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitFromMatrixMethodInfo
    instance (signature ~ (Maybe (Graphene.Matrix.Matrix) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromMatrixMethodInfo Euler signature where
        overloadedMethod = eulerInitFromMatrix

    instance O.OverloadedMethodInfo EulerInitFromMatrixMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromMatrix"
            })

    #endif

    -- method Euler::init_from_quaternion
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "q"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quaternion" }
    --           , argCType = Just "const graphene_quaternion_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a normalized #graphene_quaternion_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the order used to apply the rotations"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_from_quaternion" graphene_euler_init_from_quaternion ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Quaternion.Quaternion ->   -- q : TInterface (Name {namespace = "Graphene", name = "Quaternion"})
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the given normalized quaternion.
    --
    -- If the t'GI.Graphene.Structs.Quaternion.Quaternion' /@q@/ is 'P.Nothing', the t'GI.Graphene.Structs.Euler.Euler' will
    -- be initialized with all angles set to 0.
    --
    -- /Since: 1.2/
    eulerInitFromQuaternion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> Maybe (Graphene.Quaternion.Quaternion)
        -- ^ /@q@/: a normalized t'GI.Graphene.Structs.Quaternion.Quaternion'
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: the order used to apply the rotations
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitFromQuaternion :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Maybe Quaternion -> EulerOrder -> m Euler
    eulerInitFromQuaternion Euler
    e Maybe Quaternion
    q EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        maybeQ <- case q of
            Maybe Quaternion
    Nothing -> Ptr Quaternion -> IO (Ptr Quaternion)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Quaternion
    forall a. Ptr a
    FP.nullPtr
            Just Quaternion
    jQ -> do
                jQ' <- Quaternion -> IO (Ptr Quaternion)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Quaternion
    jQ
                return jQ'
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        result <- graphene_euler_init_from_quaternion e' maybeQ order'
        checkUnexpectedReturnNULL "eulerInitFromQuaternion" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        whenJust q touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitFromQuaternionMethodInfo
    instance (signature ~ (Maybe (Graphene.Quaternion.Quaternion) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromQuaternionMethodInfo Euler signature where
        overloadedMethod = eulerInitFromQuaternion

    instance O.OverloadedMethodInfo EulerInitFromQuaternionMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromQuaternion",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromQuaternion"
            })

    #endif

    -- method Euler::init_from_radians
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the X axis, in radians"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Y axis, in radians"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "z"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Z axis, in radians"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "order of rotations" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_from_radians" graphene_euler_init_from_radians ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        CFloat ->                               -- x : TBasicType TFloat
        CFloat ->                               -- y : TBasicType TFloat
        CFloat ->                               -- z : TBasicType TFloat
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the given angles
    -- and order of rotation.
    --
    -- /Since: 1.10/
    eulerInitFromRadians ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Float
        -- ^ /@x@/: rotation angle on the X axis, in radians
        -> Float
        -- ^ /@y@/: rotation angle on the Y axis, in radians
        -> Float
        -- ^ /@z@/: rotation angle on the Z axis, in radians
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: order of rotations
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitFromRadians :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Float -> Float -> Float -> EulerOrder -> m Euler
    eulerInitFromRadians Euler
    e Float
    x Float
    y Float
    z EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        let x' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    x
        let y' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    y
        let z' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    z
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        result <- graphene_euler_init_from_radians e' x' y' z' order'
        checkUnexpectedReturnNULL "eulerInitFromRadians" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitFromRadiansMethodInfo
    instance (signature ~ (Float -> Float -> Float -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromRadiansMethodInfo Euler signature where
        overloadedMethod = eulerInitFromRadians

    instance O.OverloadedMethodInfo EulerInitFromRadiansMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromRadians",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromRadians"
            })

    #endif

    -- method Euler::init_from_vec3
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #graphene_vec3_t containing the rotation\n  angles in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the order used to apply the rotations"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_from_vec3" graphene_euler_init_from_vec3 ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Vec3.Vec3 ->               -- v : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' using the angles contained in a
    -- t'GI.Graphene.Structs.Vec3.Vec3'.
    --
    -- If the t'GI.Graphene.Structs.Vec3.Vec3' /@v@/ is 'P.Nothing', the t'GI.Graphene.Structs.Euler.Euler' will be
    -- initialized with all angles set to 0.
    --
    -- /Since: 1.2/
    eulerInitFromVec3 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Maybe (Graphene.Vec3.Vec3)
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec3.Vec3' containing the rotation
        --   angles in degrees
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: the order used to apply the rotations
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitFromVec3 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Maybe Vec3 -> EulerOrder -> m Euler
    eulerInitFromVec3 Euler
    e Maybe Vec3
    v EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        maybeV <- case v of
            Maybe Vec3
    Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Vec3
    forall a. Ptr a
    FP.nullPtr
            Just Vec3
    jV -> do
                jV' <- Vec3 -> IO (Ptr Vec3)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec3
    jV
                return jV'
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        result <- graphene_euler_init_from_vec3 e' maybeV order'
        checkUnexpectedReturnNULL "eulerInitFromVec3" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        whenJust v touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitFromVec3MethodInfo
    instance (signature ~ (Maybe (Graphene.Vec3.Vec3) -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitFromVec3MethodInfo Euler signature where
        overloadedMethod = eulerInitFromVec3

    instance O.OverloadedMethodInfo EulerInitFromVec3MethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitFromVec3",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitFromVec3"
            })

    #endif

    -- method Euler::init_with_order
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_euler_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "x"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the X axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Y axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "z"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rotation angle on the Z axis, in degrees"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the order used to apply the rotations"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Euler" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_euler_init_with_order" graphene_euler_init_with_order ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        CFloat ->                               -- x : TBasicType TFloat
        CFloat ->                               -- y : TBasicType TFloat
        CFloat ->                               -- z : TBasicType TFloat
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        IO (Ptr Euler)

    -- | Initializes a t'GI.Graphene.Structs.Euler.Euler' with the given angles and /@order@/.
    --
    -- /Since: 1.2/
    eulerInitWithOrder ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: the t'GI.Graphene.Structs.Euler.Euler' to initialize
        -> Float
        -- ^ /@x@/: rotation angle on the X axis, in degrees
        -> Float
        -- ^ /@y@/: rotation angle on the Y axis, in degrees
        -> Float
        -- ^ /@z@/: rotation angle on the Z axis, in degrees
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: the order used to apply the rotations
        -> m Euler
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Euler.Euler'
    eulerInitWithOrder :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> Float -> Float -> Float -> EulerOrder -> m Euler
    eulerInitWithOrder Euler
    e Float
    x Float
    y Float
    z EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        let x' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    x
        let y' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    y
        let z' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    z
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        result <- graphene_euler_init_with_order e' x' y' z' order'
        checkUnexpectedReturnNULL "eulerInitWithOrder" result
        result' <- (newBoxed Euler) result
        touchManagedPtr e
        return result'

    #if defined(ENABLE_OVERLOADING)
    data EulerInitWithOrderMethodInfo
    instance (signature ~ (Float -> Float -> Float -> Graphene.Enums.EulerOrder -> m Euler), MonadIO m) => O.OverloadedMethod EulerInitWithOrderMethodInfo Euler signature where
        overloadedMethod = eulerInitWithOrder

    instance O.OverloadedMethodInfo EulerInitWithOrderMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerInitWithOrder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerInitWithOrder"
            })

    #endif

    -- method Euler::reorder
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "order"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "EulerOrder" }
    --           , argCType = Just "graphene_euler_order_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new order" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "graphene_euler_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the reordered\n  #graphene_euler_t"
    --                 , 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 "graphene_euler_reorder" graphene_euler_reorder ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        CInt ->                                 -- order : TInterface (Name {namespace = "Graphene", name = "EulerOrder"})
        Ptr Euler ->                            -- res : TInterface (Name {namespace = "Graphene", name = "Euler"})
        IO ()

    -- | Reorders a t'GI.Graphene.Structs.Euler.Euler' using /@order@/.
    --
    -- This function is equivalent to creating a t'GI.Graphene.Structs.Quaternion.Quaternion' from the
    -- given t'GI.Graphene.Structs.Euler.Euler', and then converting the quaternion into another
    -- t'GI.Graphene.Structs.Euler.Euler'.
    --
    -- /Since: 1.2/
    eulerReorder ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> Graphene.Enums.EulerOrder
        -- ^ /@order@/: the new order
        -> m (Euler)
    eulerReorder :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> EulerOrder -> m Euler
    eulerReorder Euler
    e EulerOrder
    order = IO Euler -> m Euler
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Euler -> m Euler) -> IO Euler -> m Euler
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        let order' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CInt) -> (EulerOrder -> Int) -> EulerOrder -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . EulerOrder -> Int
    forall a. Enum a => a -> Int
    fromEnum) EulerOrder
    order
        res <- SP.callocBoxedBytes 20 :: IO (Ptr Euler)
        graphene_euler_reorder e' order' res
        res' <- (wrapBoxed Euler) res
        touchManagedPtr e
        return res'

    #if defined(ENABLE_OVERLOADING)
    data EulerReorderMethodInfo
    instance (signature ~ (Graphene.Enums.EulerOrder -> m (Euler)), MonadIO m) => O.OverloadedMethod EulerReorderMethodInfo Euler signature where
        overloadedMethod = eulerReorder

    instance O.OverloadedMethodInfo EulerReorderMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerReorder",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerReorder"
            })

    #endif

    -- method Euler::to_matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Matrix" }
    --           , argCType = Just "graphene_matrix_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for a #graphene_matrix_t"
    --                 , 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 "graphene_euler_to_matrix" graphene_euler_to_matrix ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Matrix.Matrix ->           -- res : TInterface (Name {namespace = "Graphene", name = "Matrix"})
        IO ()

    -- | Converts a t'GI.Graphene.Structs.Euler.Euler' into a transformation matrix expressing
    -- the extrinsic composition of rotations described by the Euler angles.
    --
    -- The rotations are applied over the reference frame axes in the order
    -- associated with the t'GI.Graphene.Structs.Euler.Euler'; for instance, if the order
    -- used to initialize /@e@/ is 'GI.Graphene.Enums.EulerOrderXyz':
    --
    --  * the first rotation moves the body around the X axis with
    --    an angle φ
    --  * the second rotation moves the body around the Y axis with
    --    an angle of ϑ
    --  * the third rotation moves the body around the Z axis with
    --    an angle of ψ
    --
    -- The rotation sign convention is right-handed, to preserve compatibility
    -- between Euler-based, quaternion-based, and angle-axis-based rotations.
    --
    -- /Since: 1.2/
    eulerToMatrix ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m (Graphene.Matrix.Matrix)
    eulerToMatrix :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> m Matrix
    eulerToMatrix Euler
    e = 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
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        res <- SP.callocBoxedBytes 64 :: IO (Ptr Graphene.Matrix.Matrix)
        graphene_euler_to_matrix e' res
        res' <- (wrapBoxed Graphene.Matrix.Matrix) res
        touchManagedPtr e
        return res'

    #if defined(ENABLE_OVERLOADING)
    data EulerToMatrixMethodInfo
    instance (signature ~ (m (Graphene.Matrix.Matrix)), MonadIO m) => O.OverloadedMethod EulerToMatrixMethodInfo Euler signature where
        overloadedMethod = eulerToMatrix

    instance O.OverloadedMethodInfo EulerToMatrixMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerToMatrix"
            })

    #endif

    -- method Euler::to_quaternion
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Quaternion" }
    --           , argCType = Just "graphene_quaternion_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for a #graphene_quaternion_t"
    --                 , 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 "graphene_euler_to_quaternion" graphene_euler_to_quaternion ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Quaternion.Quaternion ->   -- res : TInterface (Name {namespace = "Graphene", name = "Quaternion"})
        IO ()

    -- | Converts a t'GI.Graphene.Structs.Euler.Euler' into a t'GI.Graphene.Structs.Quaternion.Quaternion'.
    --
    -- /Since: 1.10/
    eulerToQuaternion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m (Graphene.Quaternion.Quaternion)
    eulerToQuaternion :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Euler -> m Quaternion
    eulerToQuaternion Euler
    e = IO Quaternion -> m Quaternion
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Quaternion -> m Quaternion) -> IO Quaternion -> m Quaternion
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Quaternion.Quaternion)
        graphene_euler_to_quaternion e' res
        res' <- (wrapBoxed Graphene.Quaternion.Quaternion) res
        touchManagedPtr e
        return res'

    #if defined(ENABLE_OVERLOADING)
    data EulerToQuaternionMethodInfo
    instance (signature ~ (m (Graphene.Quaternion.Quaternion)), MonadIO m) => O.OverloadedMethod EulerToQuaternionMethodInfo Euler signature where
        overloadedMethod = eulerToQuaternion

    instance O.OverloadedMethodInfo EulerToQuaternionMethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToQuaternion",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerToQuaternion"
            })

    #endif

    -- method Euler::to_vec3
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "e"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Euler" }
    --           , argCType = Just "const graphene_euler_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_euler_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "graphene_vec3_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for a #graphene_vec3_t"
    --                 , 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 "graphene_euler_to_vec3" graphene_euler_to_vec3 ::
        Ptr Euler ->                            -- e : TInterface (Name {namespace = "Graphene", name = "Euler"})
        Ptr Graphene.Vec3.Vec3 ->               -- res : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        IO ()

    -- | Retrieves the angles of a t'GI.Graphene.Structs.Euler.Euler' and initializes a
    -- t'GI.Graphene.Structs.Vec3.Vec3' with them.
    --
    -- /Since: 1.2/
    eulerToVec3 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Euler
        -- ^ /@e@/: a t'GI.Graphene.Structs.Euler.Euler'
        -> m (Graphene.Vec3.Vec3)
    eulerToVec3 :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Euler -> m Vec3
    eulerToVec3 Euler
    e = IO Vec3 -> m Vec3
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec3 -> m Vec3) -> IO Vec3 -> m Vec3
    forall a b. (a -> b) -> a -> b
    $ do
        e' <- Euler -> IO (Ptr Euler)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Euler
    e
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
        graphene_euler_to_vec3 e' res
        res' <- (wrapBoxed Graphene.Vec3.Vec3) res
        touchManagedPtr e
        return res'

    #if defined(ENABLE_OVERLOADING)
    data EulerToVec3MethodInfo
    instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod EulerToVec3MethodInfo Euler signature where
        overloadedMethod = eulerToVec3

    instance O.OverloadedMethodInfo EulerToVec3MethodInfo Euler where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Graphene.Structs.Euler.eulerToVec3",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-graphene-1.0.8/docs/GI-Graphene-Structs-Euler.html#v:eulerToVec3"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveEulerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveEulerMethod "equal" o = EulerEqualMethodInfo
        ResolveEulerMethod "free" o = EulerFreeMethodInfo
        ResolveEulerMethod "init" o = EulerInitMethodInfo
        ResolveEulerMethod "initFromEuler" o = EulerInitFromEulerMethodInfo
        ResolveEulerMethod "initFromMatrix" o = EulerInitFromMatrixMethodInfo
        ResolveEulerMethod "initFromQuaternion" o = EulerInitFromQuaternionMethodInfo
        ResolveEulerMethod "initFromRadians" o = EulerInitFromRadiansMethodInfo
        ResolveEulerMethod "initFromVec3" o = EulerInitFromVec3MethodInfo
        ResolveEulerMethod "initWithOrder" o = EulerInitWithOrderMethodInfo
        ResolveEulerMethod "reorder" o = EulerReorderMethodInfo
        ResolveEulerMethod "toMatrix" o = EulerToMatrixMethodInfo
        ResolveEulerMethod "toQuaternion" o = EulerToQuaternionMethodInfo
        ResolveEulerMethod "toVec3" o = EulerToVec3MethodInfo
        ResolveEulerMethod "getAlpha" o = EulerGetAlphaMethodInfo
        ResolveEulerMethod "getBeta" o = EulerGetBetaMethodInfo
        ResolveEulerMethod "getGamma" o = EulerGetGammaMethodInfo
        ResolveEulerMethod "getOrder" o = EulerGetOrderMethodInfo
        ResolveEulerMethod "getX" o = EulerGetXMethodInfo
        ResolveEulerMethod "getY" o = EulerGetYMethodInfo
        ResolveEulerMethod "getZ" o = EulerGetZMethodInfo
        ResolveEulerMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif