    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A structure capable of holding a vector with two dimensions, x and y.
    --
    -- The contents of the t'GI.Graphene.Structs.Vec2.Vec2' structure are private and should
    -- never be accessed directly.

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

    module GI.Graphene.Structs.Vec2
        (

    -- * Exported types
        Vec2(..)                                ,
        newZeroVec2                             ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [add]("GI.Graphene.Structs.Vec2#g:method:add"), [divide]("GI.Graphene.Structs.Vec2#g:method:divide"), [dot]("GI.Graphene.Structs.Vec2#g:method:dot"), [equal]("GI.Graphene.Structs.Vec2#g:method:equal"), [free]("GI.Graphene.Structs.Vec2#g:method:free"), [init]("GI.Graphene.Structs.Vec2#g:method:init"), [initFromFloat]("GI.Graphene.Structs.Vec2#g:method:initFromFloat"), [initFromVec2]("GI.Graphene.Structs.Vec2#g:method:initFromVec2"), [interpolate]("GI.Graphene.Structs.Vec2#g:method:interpolate"), [length]("GI.Graphene.Structs.Vec2#g:method:length"), [max]("GI.Graphene.Structs.Vec2#g:method:max"), [min]("GI.Graphene.Structs.Vec2#g:method:min"), [multiply]("GI.Graphene.Structs.Vec2#g:method:multiply"), [near]("GI.Graphene.Structs.Vec2#g:method:near"), [negate]("GI.Graphene.Structs.Vec2#g:method:negate"), [normalize]("GI.Graphene.Structs.Vec2#g:method:normalize"), [scale]("GI.Graphene.Structs.Vec2#g:method:scale"), [subtract]("GI.Graphene.Structs.Vec2#g:method:subtract").
    --
    -- ==== Getters
    -- [getX]("GI.Graphene.Structs.Vec2#g:method:getX"), [getY]("GI.Graphene.Structs.Vec2#g:method:getY").
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveVec2Method                       ,
    #endif

    -- ** add #method:add#

    #if defined(ENABLE_OVERLOADING)
        Vec2AddMethodInfo                       ,
    #endif
        vec2Add                                 ,

    -- ** alloc #method:alloc#

        vec2Alloc                               ,

    -- ** divide #method:divide#

    #if defined(ENABLE_OVERLOADING)
        Vec2DivideMethodInfo                    ,
    #endif
        vec2Divide                              ,

    -- ** dot #method:dot#

    #if defined(ENABLE_OVERLOADING)
        Vec2DotMethodInfo                       ,
    #endif
        vec2Dot                                 ,

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        Vec2EqualMethodInfo                     ,
    #endif
        vec2Equal                               ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        Vec2FreeMethodInfo                      ,
    #endif
        vec2Free                                ,

    -- ** getX #method:getX#

    #if defined(ENABLE_OVERLOADING)
        Vec2GetXMethodInfo                      ,
    #endif
        vec2GetX                                ,

    -- ** getY #method:getY#

    #if defined(ENABLE_OVERLOADING)
        Vec2GetYMethodInfo                      ,
    #endif
        vec2GetY                                ,

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        Vec2InitMethodInfo                      ,
    #endif
        vec2Init                                ,

    -- ** initFromFloat #method:initFromFloat#

    #if defined(ENABLE_OVERLOADING)
        Vec2InitFromFloatMethodInfo             ,
    #endif
        vec2InitFromFloat                       ,

    -- ** initFromVec2 #method:initFromVec2#

    #if defined(ENABLE_OVERLOADING)
        Vec2InitFromVec2MethodInfo              ,
    #endif
        vec2InitFromVec2                        ,

    -- ** interpolate #method:interpolate#

    #if defined(ENABLE_OVERLOADING)
        Vec2InterpolateMethodInfo               ,
    #endif
        vec2Interpolate                         ,

    -- ** length #method:length#

    #if defined(ENABLE_OVERLOADING)
        Vec2LengthMethodInfo                    ,
    #endif
        vec2Length                              ,

    -- ** max #method:max#

    #if defined(ENABLE_OVERLOADING)
        Vec2MaxMethodInfo                       ,
    #endif
        vec2Max                                 ,

    -- ** min #method:min#

    #if defined(ENABLE_OVERLOADING)
        Vec2MinMethodInfo                       ,
    #endif
        vec2Min                                 ,

    -- ** multiply #method:multiply#

    #if defined(ENABLE_OVERLOADING)
        Vec2MultiplyMethodInfo                  ,
    #endif
        vec2Multiply                            ,

    -- ** near #method:near#

    #if defined(ENABLE_OVERLOADING)
        Vec2NearMethodInfo                      ,
    #endif
        vec2Near                                ,

    -- ** negate #method:negate#

    #if defined(ENABLE_OVERLOADING)
        Vec2NegateMethodInfo                    ,
    #endif
        vec2Negate                              ,

    -- ** normalize #method:normalize#

    #if defined(ENABLE_OVERLOADING)
        Vec2NormalizeMethodInfo                 ,
    #endif
        vec2Normalize                           ,

    -- ** one #method:one#

        vec2One                                 ,

    -- ** scale #method:scale#

    #if defined(ENABLE_OVERLOADING)
        Vec2ScaleMethodInfo                     ,
    #endif
        vec2Scale                               ,

    -- ** subtract #method:subtract#

    #if defined(ENABLE_OVERLOADING)
        Vec2SubtractMethodInfo                  ,
    #endif
        vec2Subtract                            ,

    -- ** xAxis #method:xAxis#

        vec2XAxis                               ,

    -- ** yAxis #method:yAxis#

        vec2YAxis                               ,

    -- ** zero #method:zero#

        vec2Zero                                ,

        ) 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)

    #else

    #endif

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

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

    foreign import ccall "graphene_vec2_get_type" c_graphene_vec2_get_type ::
        IO GType

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

    instance B.Types.TypedObject Vec2 where
        glibType :: IO GType
    glibType = IO GType
    c_graphene_vec2_get_type

    instance B.Types.GBoxed Vec2

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

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

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

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

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

    foreign import ccall "graphene_vec2_alloc" graphene_vec2_alloc ::
        IO (Ptr Vec2)

    -- | Allocates a new t'GI.Graphene.Structs.Vec2.Vec2' structure.
    --
    -- The contents of the returned structure are undefined.
    --
    -- Use 'GI.Graphene.Structs.Vec2.vec2Init' to initialize the vector.
    --
    -- /Since: 1.0/
    vec2Alloc ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Vec2
        -- ^ __Returns:__ the newly allocated t'GI.Graphene.Structs.Vec2.Vec2'
        --   structure. Use 'GI.Graphene.Structs.Vec2.vec2Free' to free the resources allocated
        --   by this function.
    vec2Alloc :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Vec2
    vec2Alloc  = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Vec2)
    graphene_vec2_alloc
        checkUnexpectedReturnNULL "vec2Alloc" result
        result' <- (wrapBoxed Vec2) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Vec2::add
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result"
    --                 , 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_vec2_add" graphene_vec2_add ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Adds each component of the two passed vectors and places
    -- each result into the components of /@res@/.
    --
    -- /Since: 1.0/
    vec2Add ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Add :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Add Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_add a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2AddMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2AddMethodInfo Vec2 signature where
        overloadedMethod = vec2Add

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

    #endif

    -- method Vec2::divide
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result"
    --                 , 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_vec2_divide" graphene_vec2_divide ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Divides each component of the first operand /@a@/ by the corresponding
    -- component of the second operand /@b@/, and places the results into the
    -- vector /@res@/.
    --
    -- /Since: 1.0/
    vec2Divide ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Divide :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Divide Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_divide a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2DivideMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2DivideMethodInfo Vec2 signature where
        overloadedMethod = vec2Divide

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

    #endif

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

    -- | Computes the dot product of the two given vectors.
    --
    -- /Since: 1.0/
    vec2Dot ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Float
        -- ^ __Returns:__ the dot product of the vectors
    vec2Dot :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Float
    vec2Dot Vec2
    a Vec2
    b = 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
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        result <- graphene_vec2_dot a' b'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr a
        touchManagedPtr b
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2DotMethodInfo
    instance (signature ~ (Vec2 -> m Float), MonadIO m) => O.OverloadedMethod Vec2DotMethodInfo Vec2 signature where
        overloadedMethod = vec2Dot

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

    #endif

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

    -- | Checks whether the two given t'GI.Graphene.Structs.Vec2.Vec2' are equal.
    --
    -- /Since: 1.2/
    vec2Equal ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v1@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@v2@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Bool
        -- ^ __Returns:__ @true@ if the two vectors are equal, and false otherwise
    vec2Equal :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Bool
    vec2Equal Vec2
    v1 Vec2
    v2 = 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
        v1' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v1
        v2' <- unsafeManagedPtrGetPtr v2
        result <- graphene_vec2_equal v1' v2'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr v1
        touchManagedPtr v2
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2EqualMethodInfo
    instance (signature ~ (Vec2 -> m Bool), MonadIO m) => O.OverloadedMethod Vec2EqualMethodInfo Vec2 signature where
        overloadedMethod = vec2Equal

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

    #endif

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

    -- | Frees the resources allocated by /@v@/
    --
    -- /Since: 1.0/
    vec2Free ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m ()
    vec2Free :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m ()
    vec2Free Vec2
    v = 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
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        graphene_vec2_free v'
        touchManagedPtr v
        return ()

    #if defined(ENABLE_OVERLOADING)
    data Vec2FreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod Vec2FreeMethodInfo Vec2 signature where
        overloadedMethod = vec2Free

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

    #endif

    -- method Vec2::get_x
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_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_vec2_get_x" graphene_vec2_get_x ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO CFloat

    -- | Retrieves the X component of the t'GI.Graphene.Structs.Vec2.Vec2'.
    --
    -- /Since: 1.0/
    vec2GetX ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Float
        -- ^ __Returns:__ the value of the X component
    vec2GetX :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m Float
    vec2GetX Vec2
    v = 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
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        result <- graphene_vec2_get_x v'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr v
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2GetXMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod Vec2GetXMethodInfo Vec2 signature where
        overloadedMethod = vec2GetX

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

    #endif

    -- method Vec2::get_y
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_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_vec2_get_y" graphene_vec2_get_y ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO CFloat

    -- | Retrieves the Y component of the t'GI.Graphene.Structs.Vec2.Vec2'.
    --
    -- /Since: 1.0/
    vec2GetY ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Float
        -- ^ __Returns:__ the value of the Y component
    vec2GetY :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m Float
    vec2GetY Vec2
    v = 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
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        result <- graphene_vec2_get_y v'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr v
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2GetYMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod Vec2GetYMethodInfo Vec2 signature where
        overloadedMethod = vec2GetY

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

    #endif

    -- method Vec2::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , 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 "the X field of the vector"
    --                 , 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 "the Y field of the vector"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Vec2" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_vec2_init" graphene_vec2_init ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        CFloat ->                               -- x : TBasicType TFloat
        CFloat ->                               -- y : TBasicType TFloat
        IO (Ptr Vec2)

    -- | Initializes a t'GI.Graphene.Structs.Vec2.Vec2' using the given values.
    --
    -- This function can be called multiple times.
    --
    -- /Since: 1.0/
    vec2Init ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Float
        -- ^ /@x@/: the X field of the vector
        -> Float
        -- ^ /@y@/: the Y field of the vector
        -> m Vec2
        -- ^ __Returns:__ the initialized vector
    vec2Init :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Float -> Float -> m Vec2
    vec2Init Vec2
    v Float
    x Float
    y = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        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
        result <- graphene_vec2_init v' x' y'
        checkUnexpectedReturnNULL "vec2Init" result
        result' <- (newBoxed Vec2) result
        touchManagedPtr v
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2InitMethodInfo
    instance (signature ~ (Float -> Float -> m Vec2), MonadIO m) => O.OverloadedMethod Vec2InitMethodInfo Vec2 signature where
        overloadedMethod = vec2Init

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

    #endif

    -- method Vec2::init_from_float
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "src"
    --           , argType = TCArray False 2 (-1) (TBasicType TFloat)
    --           , argCType = Just "const float*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "an array of floating point values\n  with at least two elements"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Vec2" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_vec2_init_from_float" graphene_vec2_init_from_float ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr CFloat ->                           -- src : TCArray False 2 (-1) (TBasicType TFloat)
        IO (Ptr Vec2)

    -- | Initializes /@v@/ with the contents of the given array.
    --
    -- /Since: 1.0/
    vec2InitFromFloat ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> [Float]
        -- ^ /@src@/: an array of floating point values
        --   with at least two elements
        -> m Vec2
        -- ^ __Returns:__ the initialized vector
    vec2InitFromFloat :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> [Float] -> m Vec2
    vec2InitFromFloat Vec2
    v [Float]
    src = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        src' <- (packMapStorableArray realToFrac) src
        result <- graphene_vec2_init_from_float v' src'
        checkUnexpectedReturnNULL "vec2InitFromFloat" result
        result' <- (newBoxed Vec2) result
        touchManagedPtr v
        freeMem src'
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2InitFromFloatMethodInfo
    instance (signature ~ ([Float] -> m Vec2), MonadIO m) => O.OverloadedMethod Vec2InitFromFloatMethodInfo Vec2 signature where
        overloadedMethod = vec2InitFromFloat

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

    #endif

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

    foreign import ccall "graphene_vec2_init_from_vec2" graphene_vec2_init_from_vec2 ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- src : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO (Ptr Vec2)

    -- | Copies the contents of /@src@/ into /@v@/.
    --
    -- /Since: 1.0/
    vec2InitFromVec2 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@src@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Vec2
        -- ^ __Returns:__ the initialized vector
    vec2InitFromVec2 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2InitFromVec2 Vec2
    v Vec2
    src = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        src' <- unsafeManagedPtrGetPtr src
        result <- graphene_vec2_init_from_vec2 v' src'
        checkUnexpectedReturnNULL "vec2InitFromVec2" result
        result' <- (newBoxed Vec2) result
        touchManagedPtr v
        touchManagedPtr src
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2InitFromVec2MethodInfo
    instance (signature ~ (Vec2 -> m Vec2), MonadIO m) => O.OverloadedMethod Vec2InitFromVec2MethodInfo Vec2 signature where
        overloadedMethod = vec2InitFromVec2

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

    #endif

    -- method Vec2::interpolate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v1"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "v2"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factor"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "double"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the interpolation factor"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the interpolated vector"
    --                 , 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_vec2_interpolate" graphene_vec2_interpolate ::
        Ptr Vec2 ->                             -- v1 : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- v2 : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        CDouble ->                              -- factor : TBasicType TDouble
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Linearly interpolates /@v1@/ and /@v2@/ using the given /@factor@/.
    --
    -- /Since: 1.10/
    vec2Interpolate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v1@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@v2@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Double
        -- ^ /@factor@/: the interpolation factor
        -> m (Vec2)
    vec2Interpolate :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> Double -> m Vec2
    vec2Interpolate Vec2
    v1 Vec2
    v2 Double
    factor = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v1' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v1
        v2' <- unsafeManagedPtrGetPtr v2
        let factor' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    factor
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_interpolate v1' v2' factor' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr v1
        touchManagedPtr v2
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2InterpolateMethodInfo
    instance (signature ~ (Vec2 -> Double -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2InterpolateMethodInfo Vec2 signature where
        overloadedMethod = vec2Interpolate

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

    #endif

    -- method Vec2::length
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_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_vec2_length" graphene_vec2_length ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO CFloat

    -- | Computes the length of the given vector.
    --
    -- /Since: 1.0/
    vec2Length ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m Float
        -- ^ __Returns:__ the length of the vector
    vec2Length :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m Float
    vec2Length Vec2
    v = 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
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        result <- graphene_vec2_length v'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr v
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2LengthMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod Vec2LengthMethodInfo Vec2 signature where
        overloadedMethod = vec2Length

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

    #endif

    -- method Vec2::max
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the resulting vector"
    --                 , 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_vec2_max" graphene_vec2_max ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Compares the two given vectors and places the maximum
    -- values of each component into /@res@/.
    --
    -- /Since: 1.0/
    vec2Max ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Max :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Max Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_max a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2MaxMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2MaxMethodInfo Vec2 signature where
        overloadedMethod = vec2Max

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

    #endif

    -- method Vec2::min
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the resulting vector"
    --                 , 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_vec2_min" graphene_vec2_min ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Compares the two given vectors and places the minimum
    -- values of each component into /@res@/.
    --
    -- /Since: 1.0/
    vec2Min ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Min :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Min Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_min a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2MinMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2MinMethodInfo Vec2 signature where
        overloadedMethod = vec2Min

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

    #endif

    -- method Vec2::multiply
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result"
    --                 , 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_vec2_multiply" graphene_vec2_multiply ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Multiplies each component of the two passed vectors and places
    -- each result into the components of /@res@/.
    --
    -- /Since: 1.0/
    vec2Multiply ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Multiply :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Multiply Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_multiply a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2MultiplyMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2MultiplyMethodInfo Vec2 signature where
        overloadedMethod = vec2Multiply

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

    #endif

    -- method Vec2::near
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v1"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "v2"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "epsilon"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the threshold between the two vectors"
    --                 , 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_vec2_near" graphene_vec2_near ::
        Ptr Vec2 ->                             -- v1 : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- v2 : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        CFloat ->                               -- epsilon : TBasicType TFloat
        IO CInt

    -- | Compares the two given t'GI.Graphene.Structs.Vec2.Vec2' vectors and checks
    -- whether their values are within the given /@epsilon@/.
    --
    -- /Since: 1.2/
    vec2Near ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v1@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@v2@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Float
        -- ^ /@epsilon@/: the threshold between the two vectors
        -> m Bool
        -- ^ __Returns:__ @true@ if the two vectors are near each other
    vec2Near :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> Float -> m Bool
    vec2Near Vec2
    v1 Vec2
    v2 Float
    epsilon = 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
        v1' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v1
        v2' <- unsafeManagedPtrGetPtr v2
        let epsilon' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    epsilon
        result <- graphene_vec2_near v1' v2' epsilon'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr v1
        touchManagedPtr v2
        return result'

    #if defined(ENABLE_OVERLOADING)
    data Vec2NearMethodInfo
    instance (signature ~ (Vec2 -> Float -> m Bool), MonadIO m) => O.OverloadedMethod Vec2NearMethodInfo Vec2 signature where
        overloadedMethod = vec2Near

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

    #endif

    -- method Vec2::negate
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result vector"
    --                 , 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_vec2_negate" graphene_vec2_negate ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Negates the given t'GI.Graphene.Structs.Vec2.Vec2'.
    --
    -- /Since: 1.2/
    vec2Negate ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Negate :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m Vec2
    vec2Negate Vec2
    v = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_negate v' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr v
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2NegateMethodInfo
    instance (signature ~ (m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2NegateMethodInfo Vec2 signature where
        overloadedMethod = vec2Negate

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

    #endif

    -- method Vec2::normalize
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the\n  normalized vector"
    --                 , 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_vec2_normalize" graphene_vec2_normalize ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Computes the normalized vector for the given vector /@v@/.
    --
    -- /Since: 1.0/
    vec2Normalize ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Normalize :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Vec2 -> m Vec2
    vec2Normalize Vec2
    v = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_normalize v' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr v
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2NormalizeMethodInfo
    instance (signature ~ (m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2NormalizeMethodInfo Vec2 signature where
        overloadedMethod = vec2Normalize

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

    #endif

    -- method Vec2::scale
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "v"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factor"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the scalar factor" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result vector"
    --                 , 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_vec2_scale" graphene_vec2_scale ::
        Ptr Vec2 ->                             -- v : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        CFloat ->                               -- factor : TBasicType TFloat
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Multiplies all components of the given vector with the given scalar /@factor@/.
    --
    -- /Since: 1.2/
    vec2Scale ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@v@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Float
        -- ^ /@factor@/: the scalar factor
        -> m (Vec2)
    vec2Scale :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Float -> m Vec2
    vec2Scale Vec2
    v Float
    factor = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        v' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    v
        let factor' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    factor
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_scale v' factor' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr v
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2ScaleMethodInfo
    instance (signature ~ (Float -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2ScaleMethodInfo Vec2 signature where
        overloadedMethod = vec2Scale

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

    #endif

    -- method Vec2::subtract
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "const graphene_vec2_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_vec2_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec2" }
    --           , argCType = Just "graphene_vec2_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the result"
    --                 , 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_vec2_subtract" graphene_vec2_subtract ::
        Ptr Vec2 ->                             -- a : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- b : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        Ptr Vec2 ->                             -- res : TInterface (Name {namespace = "Graphene", name = "Vec2"})
        IO ()

    -- | Subtracts from each component of the first operand /@a@/ the
    -- corresponding component of the second operand /@b@/ and places
    -- each result into the components of /@res@/.
    --
    -- /Since: 1.0/
    vec2Subtract ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Vec2
        -- ^ /@a@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> Vec2
        -- ^ /@b@/: a t'GI.Graphene.Structs.Vec2.Vec2'
        -> m (Vec2)
    vec2Subtract :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Vec2 -> Vec2 -> m Vec2
    vec2Subtract Vec2
    a Vec2
    b = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Vec2 -> IO (Ptr Vec2)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec2
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 16 :: IO (Ptr Vec2)
        graphene_vec2_subtract a' b' res
        res' <- (wrapBoxed Vec2) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data Vec2SubtractMethodInfo
    instance (signature ~ (Vec2 -> m (Vec2)), MonadIO m) => O.OverloadedMethod Vec2SubtractMethodInfo Vec2 signature where
        overloadedMethod = vec2Subtract

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

    #endif

    -- XXX Could not generate method Vec2::to_float
    -- Not implemented: Don't know how to allocate "dest" of type TCArray False 2 (-1) (TBasicType TFloat)
    -- method Vec2::one
    -- method type : MemberFunction
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Vec2" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_vec2_one" graphene_vec2_one ::
        IO (Ptr Vec2)

    -- | Retrieves a constant vector with (1, 1) components.
    --
    -- /Since: 1.0/
    vec2One ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Vec2
        -- ^ __Returns:__ the one vector
    vec2One :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Vec2
    vec2One  = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Vec2)
    graphene_vec2_one
        checkUnexpectedReturnNULL "vec2One" result
        result' <- (newBoxed Vec2) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_vec2_x_axis" graphene_vec2_x_axis ::
        IO (Ptr Vec2)

    -- | Retrieves a constant vector with (1, 0) components.
    --
    -- /Since: 1.0/
    vec2XAxis ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Vec2
        -- ^ __Returns:__ the X axis vector
    vec2XAxis :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Vec2
    vec2XAxis  = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Vec2)
    graphene_vec2_x_axis
        checkUnexpectedReturnNULL "vec2XAxis" result
        result' <- (newBoxed Vec2) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_vec2_y_axis" graphene_vec2_y_axis ::
        IO (Ptr Vec2)

    -- | Retrieves a constant vector with (0, 1) components.
    --
    -- /Since: 1.0/
    vec2YAxis ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Vec2
        -- ^ __Returns:__ the Y axis vector
    vec2YAxis :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Vec2
    vec2YAxis  = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Vec2)
    graphene_vec2_y_axis
        checkUnexpectedReturnNULL "vec2YAxis" result
        result' <- (newBoxed Vec2) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_vec2_zero" graphene_vec2_zero ::
        IO (Ptr Vec2)

    -- | Retrieves a constant vector with (0, 0) components.
    --
    -- /Since: 1.0/
    vec2Zero ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Vec2
        -- ^ __Returns:__ the zero vector
    vec2Zero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Vec2
    vec2Zero  = IO Vec2 -> m Vec2
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec2 -> m Vec2) -> IO Vec2 -> m Vec2
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Vec2)
    graphene_vec2_zero
        checkUnexpectedReturnNULL "vec2Zero" result
        result' <- (newBoxed Vec2) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveVec2Method (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveVec2Method "add" o = Vec2AddMethodInfo
        ResolveVec2Method "divide" o = Vec2DivideMethodInfo
        ResolveVec2Method "dot" o = Vec2DotMethodInfo
        ResolveVec2Method "equal" o = Vec2EqualMethodInfo
        ResolveVec2Method "free" o = Vec2FreeMethodInfo
        ResolveVec2Method "init" o = Vec2InitMethodInfo
        ResolveVec2Method "initFromFloat" o = Vec2InitFromFloatMethodInfo
        ResolveVec2Method "initFromVec2" o = Vec2InitFromVec2MethodInfo
        ResolveVec2Method "interpolate" o = Vec2InterpolateMethodInfo
        ResolveVec2Method "length" o = Vec2LengthMethodInfo
        ResolveVec2Method "max" o = Vec2MaxMethodInfo
        ResolveVec2Method "min" o = Vec2MinMethodInfo
        ResolveVec2Method "multiply" o = Vec2MultiplyMethodInfo
        ResolveVec2Method "near" o = Vec2NearMethodInfo
        ResolveVec2Method "negate" o = Vec2NegateMethodInfo
        ResolveVec2Method "normalize" o = Vec2NormalizeMethodInfo
        ResolveVec2Method "scale" o = Vec2ScaleMethodInfo
        ResolveVec2Method "subtract" o = Vec2SubtractMethodInfo
        ResolveVec2Method "getX" o = Vec2GetXMethodInfo
        ResolveVec2Method "getY" o = Vec2GetYMethodInfo
        ResolveVec2Method l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif