    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A 3D box, described as the volume between a minimum and
    -- a maximum vertices.
    --
    -- /Since: 1.2/

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

    module GI.Graphene.Structs.Box
        (

    -- * Exported types
        Box(..)                                 ,
        newZeroBox                              ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [containsBox]("GI.Graphene.Structs.Box#g:method:containsBox"), [containsPoint]("GI.Graphene.Structs.Box#g:method:containsPoint"), [equal]("GI.Graphene.Structs.Box#g:method:equal"), [expand]("GI.Graphene.Structs.Box#g:method:expand"), [expandScalar]("GI.Graphene.Structs.Box#g:method:expandScalar"), [expandVec3]("GI.Graphene.Structs.Box#g:method:expandVec3"), [free]("GI.Graphene.Structs.Box#g:method:free"), [init]("GI.Graphene.Structs.Box#g:method:init"), [initFromBox]("GI.Graphene.Structs.Box#g:method:initFromBox"), [initFromPoints]("GI.Graphene.Structs.Box#g:method:initFromPoints"), [initFromVec3]("GI.Graphene.Structs.Box#g:method:initFromVec3"), [initFromVectors]("GI.Graphene.Structs.Box#g:method:initFromVectors"), [intersection]("GI.Graphene.Structs.Box#g:method:intersection"), [union]("GI.Graphene.Structs.Box#g:method:union").
    --
    -- ==== Getters
    -- [getBoundingSphere]("GI.Graphene.Structs.Box#g:method:getBoundingSphere"), [getCenter]("GI.Graphene.Structs.Box#g:method:getCenter"), [getDepth]("GI.Graphene.Structs.Box#g:method:getDepth"), [getHeight]("GI.Graphene.Structs.Box#g:method:getHeight"), [getMax]("GI.Graphene.Structs.Box#g:method:getMax"), [getMin]("GI.Graphene.Structs.Box#g:method:getMin"), [getSize]("GI.Graphene.Structs.Box#g:method:getSize"), [getWidth]("GI.Graphene.Structs.Box#g:method:getWidth").
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveBoxMethod                        ,
    #endif

    -- ** alloc #method:alloc#

        boxAlloc                                ,

    -- ** containsBox #method:containsBox#

    #if defined(ENABLE_OVERLOADING)
        BoxContainsBoxMethodInfo                ,
    #endif
        boxContainsBox                          ,

    -- ** containsPoint #method:containsPoint#

    #if defined(ENABLE_OVERLOADING)
        BoxContainsPointMethodInfo              ,
    #endif
        boxContainsPoint                        ,

    -- ** empty #method:empty#

        boxEmpty                                ,

    -- ** equal #method:equal#

    #if defined(ENABLE_OVERLOADING)
        BoxEqualMethodInfo                      ,
    #endif
        boxEqual                                ,

    -- ** expand #method:expand#

    #if defined(ENABLE_OVERLOADING)
        BoxExpandMethodInfo                     ,
    #endif
        boxExpand                               ,

    -- ** expandScalar #method:expandScalar#

    #if defined(ENABLE_OVERLOADING)
        BoxExpandScalarMethodInfo               ,
    #endif
        boxExpandScalar                         ,

    -- ** expandVec3 #method:expandVec3#

    #if defined(ENABLE_OVERLOADING)
        BoxExpandVec3MethodInfo                 ,
    #endif
        boxExpandVec3                           ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        BoxFreeMethodInfo                       ,
    #endif
        boxFree                                 ,

    -- ** getBoundingSphere #method:getBoundingSphere#

    #if defined(ENABLE_OVERLOADING)
        BoxGetBoundingSphereMethodInfo          ,
    #endif
        boxGetBoundingSphere                    ,

    -- ** getCenter #method:getCenter#

    #if defined(ENABLE_OVERLOADING)
        BoxGetCenterMethodInfo                  ,
    #endif
        boxGetCenter                            ,

    -- ** getDepth #method:getDepth#

    #if defined(ENABLE_OVERLOADING)
        BoxGetDepthMethodInfo                   ,
    #endif
        boxGetDepth                             ,

    -- ** getHeight #method:getHeight#

    #if defined(ENABLE_OVERLOADING)
        BoxGetHeightMethodInfo                  ,
    #endif
        boxGetHeight                            ,

    -- ** getMax #method:getMax#

    #if defined(ENABLE_OVERLOADING)
        BoxGetMaxMethodInfo                     ,
    #endif
        boxGetMax                               ,

    -- ** getMin #method:getMin#

    #if defined(ENABLE_OVERLOADING)
        BoxGetMinMethodInfo                     ,
    #endif
        boxGetMin                               ,

    -- ** getSize #method:getSize#

    #if defined(ENABLE_OVERLOADING)
        BoxGetSizeMethodInfo                    ,
    #endif
        boxGetSize                              ,

    -- ** getWidth #method:getWidth#

    #if defined(ENABLE_OVERLOADING)
        BoxGetWidthMethodInfo                   ,
    #endif
        boxGetWidth                             ,

    -- ** infinite #method:infinite#

        boxInfinite                             ,

    -- ** init #method:init#

    #if defined(ENABLE_OVERLOADING)
        BoxInitMethodInfo                       ,
    #endif
        boxInit                                 ,

    -- ** initFromBox #method:initFromBox#

    #if defined(ENABLE_OVERLOADING)
        BoxInitFromBoxMethodInfo                ,
    #endif
        boxInitFromBox                          ,

    -- ** initFromPoints #method:initFromPoints#

    #if defined(ENABLE_OVERLOADING)
        BoxInitFromPointsMethodInfo             ,
    #endif
        boxInitFromPoints                       ,

    -- ** initFromVec3 #method:initFromVec3#

    #if defined(ENABLE_OVERLOADING)
        BoxInitFromVec3MethodInfo               ,
    #endif
        boxInitFromVec3                         ,

    -- ** initFromVectors #method:initFromVectors#

    #if defined(ENABLE_OVERLOADING)
        BoxInitFromVectorsMethodInfo            ,
    #endif
        boxInitFromVectors                      ,

    -- ** intersection #method:intersection#

    #if defined(ENABLE_OVERLOADING)
        BoxIntersectionMethodInfo               ,
    #endif
        boxIntersection                         ,

    -- ** minusOne #method:minusOne#

        boxMinusOne                             ,

    -- ** one #method:one#

        boxOne                                  ,

    -- ** oneMinusOne #method:oneMinusOne#

        boxOneMinusOne                          ,

    -- ** union #method:union#

    #if defined(ENABLE_OVERLOADING)
        BoxUnionMethodInfo                      ,
    #endif
        boxUnion                                ,

    -- ** zero #method:zero#

        boxZero                                 ,

        ) where

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

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

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

    #else
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Point3D as Graphene.Point3D
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Sphere as Graphene.Sphere
    import {-# SOURCE #-} qualified GI.Graphene.Structs.Vec3 as Graphene.Vec3

    #endif

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

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

    foreign import ccall "graphene_box_get_type" c_graphene_box_get_type ::
        IO GType

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

    instance B.Types.TypedObject Box where
        glibType :: IO GType
    glibType = IO GType
    c_graphene_box_get_type

    instance B.Types.GBoxed Box

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

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

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

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

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

    foreign import ccall "graphene_box_alloc" graphene_box_alloc ::
        IO (Ptr Box)

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

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    -- | Checks whether the t'GI.Graphene.Structs.Box.Box' /@a@/ contains the given
    -- t'GI.Graphene.Structs.Box.Box' /@b@/.
    --
    -- /Since: 1.2/
    boxContainsBox ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
        -> Box
        -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Bool
        -- ^ __Returns:__ @true@ if the box is contained in the given box
    boxContainsBox :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Box -> m Bool
    boxContainsBox Box
    a Box
    b = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    a
        b' <- unsafeManagedPtrGetPtr b
        result <- graphene_box_contains_box a' b'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr a
        touchManagedPtr b
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxContainsBoxMethodInfo
    instance (signature ~ (Box -> m Bool), MonadIO m) => O.OverloadedMethod BoxContainsBoxMethodInfo Box signature where
        overloadedMethod = boxContainsBox

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

    #endif

    -- method Box::contains_point
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates to check"
    --                 , 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_box_contains_point" graphene_box_contains_point ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO CInt

    -- | Checks whether /@box@/ contains the given /@point@/.
    --
    -- /Since: 1.2/
    boxContainsPoint ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> Graphene.Point3D.Point3D
        -- ^ /@point@/: the coordinates to check
        -> m Bool
        -- ^ __Returns:__ @true@ if the point is contained in the given box
    boxContainsPoint :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Point3D -> m Bool
    boxContainsPoint Box
    box Point3D
    point = 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
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        point' <- unsafeManagedPtrGetPtr point
        result <- graphene_box_contains_point box' point'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr box
        touchManagedPtr point
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxContainsPointMethodInfo
    instance (signature ~ (Graphene.Point3D.Point3D -> m Bool), MonadIO m) => O.OverloadedMethod BoxContainsPointMethodInfo Box signature where
        overloadedMethod = boxContainsPoint

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

    #endif

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

    -- | Checks whether the two given boxes are equal.
    --
    -- /Since: 1.2/
    boxEqual ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
        -> Box
        -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Bool
        -- ^ __Returns:__ @true@ if the boxes are equal
    boxEqual :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Box -> m Bool
    boxEqual Box
    a Box
    b = IO Bool -> m Bool
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    a
        b' <- unsafeManagedPtrGetPtr b
        result <- graphene_box_equal a' b'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr a
        touchManagedPtr b
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxEqualMethodInfo
    instance (signature ~ (Box -> m Bool), MonadIO m) => O.OverloadedMethod BoxEqualMethodInfo Box signature where
        overloadedMethod = boxEqual

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

    #endif

    -- method Box::expand
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "point"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates of the point to include"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the expanded box"
    --                 , 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_box_expand" graphene_box_expand ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- point : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO ()

    -- | Expands the dimensions of /@box@/ to include the coordinates at /@point@/.
    --
    -- /Since: 1.2/
    boxExpand ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> Graphene.Point3D.Point3D
        -- ^ /@point@/: the coordinates of the point to include
        -> m (Box)
    boxExpand :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Point3D -> m Box
    boxExpand Box
    box Point3D
    point = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        point' <- unsafeManagedPtrGetPtr point
        res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
        graphene_box_expand box' point' res
        res' <- (wrapBoxed Box) res
        touchManagedPtr box
        touchManagedPtr point
        return res'

    #if defined(ENABLE_OVERLOADING)
    data BoxExpandMethodInfo
    instance (signature ~ (Graphene.Point3D.Point3D -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandMethodInfo Box signature where
        overloadedMethod = boxExpand

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

    #endif

    -- method Box::expand_scalar
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "scalar"
    --           , argType = TBasicType TFloat
    --           , argCType = Just "float"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a scalar value" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the expanded box"
    --                 , 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_box_expand_scalar" graphene_box_expand_scalar ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        CFloat ->                               -- scalar : TBasicType TFloat
        Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO ()

    -- | Expands the dimensions of /@box@/ by the given /@scalar@/ value.
    --
    -- If /@scalar@/ is positive, the t'GI.Graphene.Structs.Box.Box' will grow; if /@scalar@/ is
    -- negative, the t'GI.Graphene.Structs.Box.Box' will shrink.
    --
    -- /Since: 1.2/
    boxExpandScalar ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> Float
        -- ^ /@scalar@/: a scalar value
        -> m (Box)
    boxExpandScalar :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Float -> m Box
    boxExpandScalar Box
    box Float
    scalar = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        let scalar' = Float -> CFloat
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Float
    scalar
        res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
        graphene_box_expand_scalar box' scalar' res
        res' <- (wrapBoxed Box) res
        touchManagedPtr box
        return res'

    #if defined(ENABLE_OVERLOADING)
    data BoxExpandScalarMethodInfo
    instance (signature ~ (Float -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandScalarMethodInfo Box signature where
        overloadedMethod = boxExpandScalar

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

    #endif

    -- method Box::expand_vec3
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vec"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the coordinates of the point to include, as a #graphene_vec3_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the expanded box"
    --                 , 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_box_expand_vec3" graphene_box_expand_vec3 ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Vec3.Vec3 ->               -- vec : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO ()

    -- | Expands the dimensions of /@box@/ to include the coordinates of the
    -- given vector.
    --
    -- /Since: 1.2/
    boxExpandVec3 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> Graphene.Vec3.Vec3
        -- ^ /@vec@/: the coordinates of the point to include, as a t'GI.Graphene.Structs.Vec3.Vec3'
        -> m (Box)
    boxExpandVec3 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Vec3 -> m Box
    boxExpandVec3 Box
    box Vec3
    vec = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        vec' <- unsafeManagedPtrGetPtr vec
        res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
        graphene_box_expand_vec3 box' vec' res
        res' <- (wrapBoxed Box) res
        touchManagedPtr box
        touchManagedPtr vec
        return res'

    #if defined(ENABLE_OVERLOADING)
    data BoxExpandVec3MethodInfo
    instance (signature ~ (Graphene.Vec3.Vec3 -> m (Box)), MonadIO m) => O.OverloadedMethod BoxExpandVec3MethodInfo Box signature where
        overloadedMethod = boxExpandVec3

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

    #endif

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

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

    #if defined(ENABLE_OVERLOADING)
    data BoxFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod BoxFreeMethodInfo Box signature where
        overloadedMethod = boxFree

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

    #endif

    -- method Box::get_bounding_sphere
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "sphere"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Sphere" }
    --           , argCType = Just "graphene_sphere_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the bounding sphere"
    --                 , 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_box_get_bounding_sphere" graphene_box_get_bounding_sphere ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Sphere.Sphere ->           -- sphere : TInterface (Name {namespace = "Graphene", name = "Sphere"})
        IO ()

    -- | Computes the bounding t'GI.Graphene.Structs.Sphere.Sphere' capable of containing the given
    -- t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxGetBoundingSphere ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m (Graphene.Sphere.Sphere)
    boxGetBoundingSphere :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Sphere
    boxGetBoundingSphere Box
    box = IO Sphere -> m Sphere
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Sphere -> m Sphere) -> IO Sphere -> m Sphere
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        sphere <- SP.callocBoxedBytes 20 :: IO (Ptr Graphene.Sphere.Sphere)
        graphene_box_get_bounding_sphere box' sphere
        sphere' <- (wrapBoxed Graphene.Sphere.Sphere) sphere
        touchManagedPtr box
        return sphere'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetBoundingSphereMethodInfo
    instance (signature ~ (m (Graphene.Sphere.Sphere)), MonadIO m) => O.OverloadedMethod BoxGetBoundingSphereMethodInfo Box signature where
        overloadedMethod = boxGetBoundingSphere

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

    #endif

    -- method Box::get_center
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "center"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "graphene_point3d_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "return location for the coordinates of\n  the center"
    --                 , 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_box_get_center" graphene_box_get_center ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- center : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO ()

    -- | Retrieves the coordinates of the center of a t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxGetCenter ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m (Graphene.Point3D.Point3D)
    boxGetCenter :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
    boxGetCenter Box
    box = IO Point3D -> m Point3D
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Point3D -> m Point3D) -> IO Point3D -> m Point3D
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        center <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
        graphene_box_get_center box' center
        center' <- (wrapBoxed Graphene.Point3D.Point3D) center
        touchManagedPtr box
        return center'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetCenterMethodInfo
    instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetCenterMethodInfo Box signature where
        overloadedMethod = boxGetCenter

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

    #endif

    -- method Box::get_depth
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_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_box_get_depth" graphene_box_get_depth ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO CFloat

    -- | Retrieves the size of the /@box@/ on the Z axis.
    --
    -- /Since: 1.2/
    boxGetDepth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Float
        -- ^ __Returns:__ the depth of the box
    boxGetDepth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
    boxGetDepth Box
    box = 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
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        result <- graphene_box_get_depth box'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr box
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetDepthMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetDepthMethodInfo Box signature where
        overloadedMethod = boxGetDepth

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

    #endif

    -- method Box::get_height
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_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_box_get_height" graphene_box_get_height ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO CFloat

    -- | Retrieves the size of the /@box@/ on the Y axis.
    --
    -- /Since: 1.2/
    boxGetHeight ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Float
        -- ^ __Returns:__ the height of the box
    boxGetHeight :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
    boxGetHeight Box
    box = 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
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        result <- graphene_box_get_height box'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr box
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetHeightMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetHeightMethodInfo Box signature where
        overloadedMethod = boxGetHeight

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

    #endif

    -- method Box::get_max
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "graphene_point3d_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the maximum point"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_get_max" graphene_box_get_max ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- max : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO ()

    -- | Retrieves the coordinates of the maximum point of the given
    -- t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxGetMax ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m (Graphene.Point3D.Point3D)
    boxGetMax :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
    boxGetMax Box
    box = IO Point3D -> m Point3D
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Point3D -> m Point3D) -> IO Point3D -> m Point3D
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        max <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
        graphene_box_get_max box' max
        max' <- (wrapBoxed Graphene.Point3D.Point3D) max
        touchManagedPtr box
        return max'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetMaxMethodInfo
    instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetMaxMethodInfo Box signature where
        overloadedMethod = boxGetMax

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

    #endif

    -- method Box::get_min
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "graphene_point3d_t*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location for the minimum point"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_get_min" graphene_box_get_min ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- min : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO ()

    -- | Retrieves the coordinates of the minimum point of the given
    -- t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxGetMin ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m (Graphene.Point3D.Point3D)
    boxGetMin :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Point3D
    boxGetMin Box
    box = IO Point3D -> m Point3D
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Point3D -> m Point3D) -> IO Point3D -> m Point3D
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        min <- SP.callocBoxedBytes 12 :: IO (Ptr Graphene.Point3D.Point3D)
        graphene_box_get_min box' min
        min' <- (wrapBoxed Graphene.Point3D.Point3D) min
        touchManagedPtr box
        return min'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetMinMethodInfo
    instance (signature ~ (m (Graphene.Point3D.Point3D)), MonadIO m) => O.OverloadedMethod BoxGetMinMethodInfo Box signature where
        overloadedMethod = boxGetMin

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

    #endif

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

    -- | Retrieves the size of the box on all three axes, and stores
    -- it into the given /@size@/ vector.
    --
    -- /Since: 1.2/
    boxGetSize ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m (Graphene.Vec3.Vec3)
    boxGetSize :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Vec3
    boxGetSize Box
    box = IO Vec3 -> m Vec3
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Vec3 -> m Vec3) -> IO Vec3 -> m Vec3
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        size <- SP.callocBoxedBytes 16 :: IO (Ptr Graphene.Vec3.Vec3)
        graphene_box_get_size box' size
        size' <- (wrapBoxed Graphene.Vec3.Vec3) size
        touchManagedPtr box
        return size'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetSizeMethodInfo
    instance (signature ~ (m (Graphene.Vec3.Vec3)), MonadIO m) => O.OverloadedMethod BoxGetSizeMethodInfo Box signature where
        overloadedMethod = boxGetSize

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

    #endif

    -- XXX Could not generate method Box::get_vertices
    -- Not implemented: Don't know how to allocate "vertices" of type TCArray False 8 (-1) (TInterface (Name {namespace = "Graphene", name = "Vec3"}))
    -- method Box::get_width
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_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_box_get_width" graphene_box_get_width ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO CFloat

    -- | Retrieves the size of the /@box@/ on the X axis.
    --
    -- /Since: 1.2/
    boxGetWidth ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Float
        -- ^ __Returns:__ the width of the box
    boxGetWidth :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Box -> m Float
    boxGetWidth Box
    box = 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
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        result <- graphene_box_get_width box'
        let result' = CFloat -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CFloat
    result
        touchManagedPtr box
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxGetWidthMethodInfo
    instance (signature ~ (m Float), MonadIO m) => O.OverloadedMethod BoxGetWidthMethodInfo Box signature where
        overloadedMethod = boxGetWidth

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

    #endif

    -- method Box::init
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_box_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates of the minimum vertex"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Point3D" }
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates of the maximum vertex"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_init" graphene_box_init ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Point3D.Point3D ->         -- min : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        Ptr Graphene.Point3D.Point3D ->         -- max : TInterface (Name {namespace = "Graphene", name = "Point3D"})
        IO (Ptr Box)

    -- | Initializes the given t'GI.Graphene.Structs.Box.Box' with two vertices.
    --
    -- /Since: 1.2/
    boxInit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
        -> Maybe (Graphene.Point3D.Point3D)
        -- ^ /@min@/: the coordinates of the minimum vertex
        -> Maybe (Graphene.Point3D.Point3D)
        -- ^ /@max@/: the coordinates of the maximum vertex
        -> m Box
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
    boxInit :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Maybe Point3D -> Maybe Point3D -> m Box
    boxInit Box
    box Maybe Point3D
    min Maybe Point3D
    max = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        maybeMin <- case min of
            Maybe Point3D
    Nothing -> Ptr Point3D -> IO (Ptr Point3D)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Point3D
    forall a. Ptr a
    FP.nullPtr
            Just Point3D
    jMin -> do
                jMin' <- Point3D -> IO (Ptr Point3D)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Point3D
    jMin
                return jMin'
        maybeMax <- case max of
            Maybe Point3D
    Nothing -> Ptr Point3D -> IO (Ptr Point3D)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Point3D
    forall a. Ptr a
    FP.nullPtr
            Just Point3D
    jMax -> do
                jMax' <- Point3D -> IO (Ptr Point3D)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Point3D
    jMax
                return jMax'
        result <- graphene_box_init box' maybeMin maybeMax
        checkUnexpectedReturnNULL "boxInit" result
        result' <- (newBoxed Box) result
        touchManagedPtr box
        whenJust min touchManagedPtr
        whenJust max touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxInitMethodInfo
    instance (signature ~ (Maybe (Graphene.Point3D.Point3D) -> Maybe (Graphene.Point3D.Point3D) -> m Box), MonadIO m) => O.OverloadedMethod BoxInitMethodInfo Box signature where
        overloadedMethod = boxInit

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

    #endif

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

    foreign import ccall "graphene_box_init_from_box" graphene_box_init_from_box ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Box ->                              -- src : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO (Ptr Box)

    -- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the vertices of
    -- another t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxInitFromBox ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
        -> Box
        -- ^ /@src@/: a t'GI.Graphene.Structs.Box.Box'
        -> m Box
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
    boxInitFromBox :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Box -> m Box
    boxInitFromBox Box
    box Box
    src = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        src' <- unsafeManagedPtrGetPtr src
        result <- graphene_box_init_from_box box' src'
        checkUnexpectedReturnNULL "boxInitFromBox" result
        result' <- (newBoxed Box) result
        touchManagedPtr box
        touchManagedPtr src
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxInitFromBoxMethodInfo
    instance (signature ~ (Box -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromBoxMethodInfo Box signature where
        overloadedMethod = boxInitFromBox

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

    #endif

    -- method Box::init_from_points
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_box_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_points"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the number #graphene_point3d_t in the @points array"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "points"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 1
    --                 (TInterface Name { namespace = "Graphene" , name = "Point3D" })
    --           , argCType = Just "const graphene_point3d_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an array of #graphene_point3d_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_points"
    --              , argType = TBasicType TUInt
    --              , argCType = Just "unsigned int"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just "the number #graphene_point3d_t in the @points array"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_init_from_points" graphene_box_init_from_points ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Word32 ->                               -- n_points : TBasicType TUInt
        Ptr Graphene.Point3D.Point3D ->         -- points : TCArray False (-1) 1 (TInterface (Name {namespace = "Graphene", name = "Point3D"}))
        IO (Ptr Box)

    -- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the given array
    -- of vertices.
    --
    -- If /@nPoints@/ is 0, the returned box is initialized with
    -- 'GI.Graphene.Functions.boxEmpty'.
    --
    -- /Since: 1.2/
    boxInitFromPoints ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
        -> [Graphene.Point3D.Point3D]
        -- ^ /@points@/: an array of t'GI.Graphene.Structs.Point3D.Point3D'
        -> m Box
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
    boxInitFromPoints :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> [Point3D] -> m Box
    boxInitFromPoints Box
    box [Point3D]
    points = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        let nPoints :: Word32
    nPoints = Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word32) -> Int -> Word32
    forall a b. (a -> b) -> a -> b
    $ [Point3D] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [Point3D]
    points
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        points' <- mapM unsafeManagedPtrGetPtr points
        points'' <- packBlockArray 12 points'
        result <- graphene_box_init_from_points box' nPoints points''
        checkUnexpectedReturnNULL "boxInitFromPoints" result
        result' <- (newBoxed Box) result
        touchManagedPtr box
        mapM_ touchManagedPtr points
        freeMem points''
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxInitFromPointsMethodInfo
    instance (signature ~ ([Graphene.Point3D.Point3D] -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromPointsMethodInfo Box signature where
        overloadedMethod = boxInitFromPoints

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

    #endif

    -- method Box::init_from_vec3
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_box_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "min"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates of the minimum vertex"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "max"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Vec3" }
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the coordinates of the maximum vertex"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_init_from_vec3" graphene_box_init_from_vec3 ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Graphene.Vec3.Vec3 ->               -- min : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        Ptr Graphene.Vec3.Vec3 ->               -- max : TInterface (Name {namespace = "Graphene", name = "Vec3"})
        IO (Ptr Box)

    -- | Initializes the given t'GI.Graphene.Structs.Box.Box' with two vertices
    -- stored inside t'GI.Graphene.Structs.Vec3.Vec3'.
    --
    -- /Since: 1.2/
    boxInitFromVec3 ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
        -> Maybe (Graphene.Vec3.Vec3)
        -- ^ /@min@/: the coordinates of the minimum vertex
        -> Maybe (Graphene.Vec3.Vec3)
        -- ^ /@max@/: the coordinates of the maximum vertex
        -> m Box
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
    boxInitFromVec3 :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Maybe Vec3 -> Maybe Vec3 -> m Box
    boxInitFromVec3 Box
    box Maybe Vec3
    min Maybe Vec3
    max = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        maybeMin <- case min of
            Maybe Vec3
    Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Vec3
    forall a. Ptr a
    FP.nullPtr
            Just Vec3
    jMin -> do
                jMin' <- Vec3 -> IO (Ptr Vec3)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec3
    jMin
                return jMin'
        maybeMax <- case max of
            Maybe Vec3
    Nothing -> Ptr Vec3 -> IO (Ptr Vec3)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Vec3
    forall a. Ptr a
    FP.nullPtr
            Just Vec3
    jMax -> do
                jMax' <- Vec3 -> IO (Ptr Vec3)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Vec3
    jMax
                return jMax'
        result <- graphene_box_init_from_vec3 box' maybeMin maybeMax
        checkUnexpectedReturnNULL "boxInitFromVec3" result
        result' <- (newBoxed Box) result
        touchManagedPtr box
        whenJust min touchManagedPtr
        whenJust max touchManagedPtr
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxInitFromVec3MethodInfo
    instance (signature ~ (Maybe (Graphene.Vec3.Vec3) -> Maybe (Graphene.Vec3.Vec3) -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromVec3MethodInfo Box signature where
        overloadedMethod = boxInitFromVec3

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

    #endif

    -- method Box::init_from_vectors
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "box"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the #graphene_box_t to initialize"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_vectors"
    --           , argType = TBasicType TUInt
    --           , argCType = Just "unsigned int"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the number #graphene_point3d_t in the @vectors array"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "vectors"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 1
    --                 (TInterface Name { namespace = "Graphene" , name = "Vec3" })
    --           , argCType = Just "const graphene_vec3_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an array of #graphene_vec3_t"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_vectors"
    --              , argType = TBasicType TUInt
    --              , argCType = Just "unsigned int"
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just "the number #graphene_point3d_t in the @vectors array"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TInterface Name { namespace = "Graphene" , name = "Box" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_init_from_vectors" graphene_box_init_from_vectors ::
        Ptr Box ->                              -- box : TInterface (Name {namespace = "Graphene", name = "Box"})
        Word32 ->                               -- n_vectors : TBasicType TUInt
        Ptr Graphene.Vec3.Vec3 ->               -- vectors : TCArray False (-1) 1 (TInterface (Name {namespace = "Graphene", name = "Vec3"}))
        IO (Ptr Box)

    -- | Initializes the given t'GI.Graphene.Structs.Box.Box' with the given array
    -- of vertices.
    --
    -- If /@nVectors@/ is 0, the returned box is initialized with
    -- 'GI.Graphene.Functions.boxEmpty'.
    --
    -- /Since: 1.2/
    boxInitFromVectors ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@box@/: the t'GI.Graphene.Structs.Box.Box' to initialize
        -> [Graphene.Vec3.Vec3]
        -- ^ /@vectors@/: an array of t'GI.Graphene.Structs.Vec3.Vec3'
        -> m Box
        -- ^ __Returns:__ the initialized t'GI.Graphene.Structs.Box.Box'
    boxInitFromVectors :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> [Vec3] -> m Box
    boxInitFromVectors Box
    box [Vec3]
    vectors = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        let nVectors :: Word32
    nVectors = Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word32) -> Int -> Word32
    forall a b. (a -> b) -> a -> b
    $ [Vec3] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    P.length [Vec3]
    vectors
        box' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    box
        vectors' <- mapM unsafeManagedPtrGetPtr vectors
        vectors'' <- packBlockArray 16 vectors'
        result <- graphene_box_init_from_vectors box' nVectors vectors''
        checkUnexpectedReturnNULL "boxInitFromVectors" result
        result' <- (newBoxed Box) result
        touchManagedPtr box
        mapM_ touchManagedPtr vectors
        freeMem vectors''
        return result'

    #if defined(ENABLE_OVERLOADING)
    data BoxInitFromVectorsMethodInfo
    instance (signature ~ ([Graphene.Vec3.Vec3] -> m Box), MonadIO m) => O.OverloadedMethod BoxInitFromVectorsMethodInfo Box signature where
        overloadedMethod = boxInitFromVectors

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

    #endif

    -- method Box::intersection
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_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: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "graphene_box_intersection" graphene_box_intersection ::
        Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO CInt

    -- | Intersects the two given t'GI.Graphene.Structs.Box.Box'.
    --
    -- If the two boxes do not intersect, /@res@/ will contain a degenerate box
    -- initialized with 'GI.Graphene.Functions.boxEmpty'.
    --
    -- /Since: 1.2/
    boxIntersection ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
        -> Box
        -- ^ /@b@/: a t'GI.Graphene.Structs.Box.Box'
        -> m ((Bool, Box))
        -- ^ __Returns:__ true if the two boxes intersect
    boxIntersection :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Box -> m (Bool, Box)
    boxIntersection Box
    a Box
    b = IO (Bool, Box) -> m (Bool, Box)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Bool, Box) -> m (Bool, Box))
    -> IO (Bool, Box) -> m (Bool, Box)
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
        result <- graphene_box_intersection a' b' res
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        res' <- (wrapBoxed Box) res
        touchManagedPtr a
        touchManagedPtr b
        return (result', res')

    #if defined(ENABLE_OVERLOADING)
    data BoxIntersectionMethodInfo
    instance (signature ~ (Box -> m ((Bool, Box))), MonadIO m) => O.OverloadedMethod BoxIntersectionMethodInfo Box signature where
        overloadedMethod = boxIntersection

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

    #endif

    -- method Box::union
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "a"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #graphene_box_t" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "b"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "const graphene_box_t*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the box to union to @a"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "res"
    --           , argType =
    --               TInterface Name { namespace = "Graphene" , name = "Box" }
    --           , argCType = Just "graphene_box_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_box_union" graphene_box_union ::
        Ptr Box ->                              -- a : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Box ->                              -- b : TInterface (Name {namespace = "Graphene", name = "Box"})
        Ptr Box ->                              -- res : TInterface (Name {namespace = "Graphene", name = "Box"})
        IO ()

    -- | Unions the two given t'GI.Graphene.Structs.Box.Box'.
    --
    -- /Since: 1.2/
    boxUnion ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Box
        -- ^ /@a@/: a t'GI.Graphene.Structs.Box.Box'
        -> Box
        -- ^ /@b@/: the box to union to /@a@/
        -> m (Box)
    boxUnion :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Box -> Box -> m Box
    boxUnion Box
    a Box
    b = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        a' <- Box -> IO (Ptr Box)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Box
    a
        b' <- unsafeManagedPtrGetPtr b
        res <- SP.callocBoxedBytes 32 :: IO (Ptr Box)
        graphene_box_union a' b' res
        res' <- (wrapBoxed Box) res
        touchManagedPtr a
        touchManagedPtr b
        return res'

    #if defined(ENABLE_OVERLOADING)
    data BoxUnionMethodInfo
    instance (signature ~ (Box -> m (Box)), MonadIO m) => O.OverloadedMethod BoxUnionMethodInfo Box signature where
        overloadedMethod = boxUnion

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

    #endif

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

    foreign import ccall "graphene_box_empty" graphene_box_empty ::
        IO (Ptr Box)

    -- | A degenerate t'GI.Graphene.Structs.Box.Box' that can only be expanded.
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxEmpty ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxEmpty :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxEmpty  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_empty
        checkUnexpectedReturnNULL "boxEmpty" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_box_infinite" graphene_box_infinite ::
        IO (Ptr Box)

    -- | A degenerate t'GI.Graphene.Structs.Box.Box' that cannot be expanded.
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxInfinite ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxInfinite :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxInfinite  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_infinite
        checkUnexpectedReturnNULL "boxInfinite" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_box_minus_one" graphene_box_minus_one ::
        IO (Ptr Box)

    -- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (-1, -1, -1) and the
    -- maximum vertex set at (0, 0, 0).
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxMinusOne ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxMinusOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxMinusOne  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_minus_one
        checkUnexpectedReturnNULL "boxMinusOne" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_box_one" graphene_box_one ::
        IO (Ptr Box)

    -- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (0, 0, 0) and the
    -- maximum vertex set at (1, 1, 1).
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxOne ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxOne  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_one
        checkUnexpectedReturnNULL "boxOne" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_box_one_minus_one" graphene_box_one_minus_one ::
        IO (Ptr Box)

    -- | A t'GI.Graphene.Structs.Box.Box' with the minimum vertex set at (-1, -1, -1) and the
    -- maximum vertex set at (1, 1, 1).
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxOneMinusOne ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxOneMinusOne :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxOneMinusOne  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_one_minus_one
        checkUnexpectedReturnNULL "boxOneMinusOne" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "graphene_box_zero" graphene_box_zero ::
        IO (Ptr Box)

    -- | A t'GI.Graphene.Structs.Box.Box' with both the minimum and maximum vertices set at (0, 0, 0).
    --
    -- The returned value is owned by Graphene and should not be modified or freed.
    --
    -- /Since: 1.2/
    boxZero ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Box
        -- ^ __Returns:__ a t'GI.Graphene.Structs.Box.Box'
    boxZero :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Box
    boxZero  = IO Box -> m Box
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Box -> m Box) -> IO Box -> m Box
    forall a b. (a -> b) -> a -> b
    $ do
        result <- IO (Ptr Box)
    graphene_box_zero
        checkUnexpectedReturnNULL "boxZero" result
        result' <- (newBoxed Box) result
        return result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveBoxMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveBoxMethod "containsBox" o = BoxContainsBoxMethodInfo
        ResolveBoxMethod "containsPoint" o = BoxContainsPointMethodInfo
        ResolveBoxMethod "equal" o = BoxEqualMethodInfo
        ResolveBoxMethod "expand" o = BoxExpandMethodInfo
        ResolveBoxMethod "expandScalar" o = BoxExpandScalarMethodInfo
        ResolveBoxMethod "expandVec3" o = BoxExpandVec3MethodInfo
        ResolveBoxMethod "free" o = BoxFreeMethodInfo
        ResolveBoxMethod "init" o = BoxInitMethodInfo
        ResolveBoxMethod "initFromBox" o = BoxInitFromBoxMethodInfo
        ResolveBoxMethod "initFromPoints" o = BoxInitFromPointsMethodInfo
        ResolveBoxMethod "initFromVec3" o = BoxInitFromVec3MethodInfo
        ResolveBoxMethod "initFromVectors" o = BoxInitFromVectorsMethodInfo
        ResolveBoxMethod "intersection" o = BoxIntersectionMethodInfo
        ResolveBoxMethod "union" o = BoxUnionMethodInfo
        ResolveBoxMethod "getBoundingSphere" o = BoxGetBoundingSphereMethodInfo
        ResolveBoxMethod "getCenter" o = BoxGetCenterMethodInfo
        ResolveBoxMethod "getDepth" o = BoxGetDepthMethodInfo
        ResolveBoxMethod "getHeight" o = BoxGetHeightMethodInfo
        ResolveBoxMethod "getMax" o = BoxGetMaxMethodInfo
        ResolveBoxMethod "getMin" o = BoxGetMinMethodInfo
        ResolveBoxMethod "getSize" o = BoxGetSizeMethodInfo
        ResolveBoxMethod "getWidth" o = BoxGetWidthMethodInfo
        ResolveBoxMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif