gi-javascriptcore 4.0.16 → 4.0.17

raw patch · 29 files changed

+8221/−9 lines, 29 filesdep ~haskell-gidep ~haskell-gi-basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

Files

• ChangeLog.md +4/−0
• GI/JavaScriptCore.hs +58/−0
• GI/JavaScriptCore/Callbacks.hs +808/−0
• GI/JavaScriptCore/Constants.hs +103/−0
• GI/JavaScriptCore/Enums.hs +199/−0
• GI/JavaScriptCore/Enums.hs-boot +30/−0
• GI/JavaScriptCore/Flags.hs +87/−0
• GI/JavaScriptCore/Flags.hs-boot +27/−0
• GI/JavaScriptCore/Functions.hs +772/−0
• GI/JavaScriptCore/Objects.hs +51/−0
• GI/JavaScriptCore/Objects/Class.hs +772/−0
• GI/JavaScriptCore/Objects/Class.hs-boot +59/−0
• GI/JavaScriptCore/Objects/Context.hs +1175/−0
• GI/JavaScriptCore/Objects/Context.hs-boot +80/−0
• GI/JavaScriptCore/Objects/Exception.hs +575/−0
• GI/JavaScriptCore/Objects/Exception.hs-boot +53/−0
• GI/JavaScriptCore/Objects/Value.hs +2132/−0
• GI/JavaScriptCore/Objects/Value.hs-boot +116/−0
• GI/JavaScriptCore/Objects/VirtualMachine.hs +156/−0
• GI/JavaScriptCore/Objects/VirtualMachine.hs-boot +29/−0
• GI/JavaScriptCore/Objects/WeakValue.hs +342/−0
• GI/JavaScriptCore/Objects/WeakValue.hs-boot +38/−0
• GI/JavaScriptCore/Structs.hs +41/−0
• GI/JavaScriptCore/Structs/ClassVTable.hs +449/−0
• GI/JavaScriptCore/Structs/ClassVTable.hs-boot +26/−0
• LICENSE +14/−0
• README.md +1/−1
• gi-javascriptcore.cabal +23/−7
• stack.yaml +1/−1

@@ -1,3 +1,7 @@+### 4.0.17+++ Update to haskell-gi(-base) 0.22+ ### 4.0.16  + Update stack version to 12.10

@@ -0,0 +1,58 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore+    (     module GI.JavaScriptCore.Callbacks      ,+    module GI.JavaScriptCore.Constants      ,+    module GI.JavaScriptCore.Enums          ,+    module GI.JavaScriptCore.Flags          ,+    module GI.JavaScriptCore.Functions      ,+    module GI.JavaScriptCore.Objects        ,+    module GI.JavaScriptCore.Structs        ,++++    module Data.GI.Base                     ,+++    ) where++import GI.JavaScriptCore.Callbacks+import GI.JavaScriptCore.Constants+import GI.JavaScriptCore.Enums+import GI.JavaScriptCore.Flags+import GI.JavaScriptCore.Functions+import GI.JavaScriptCore.Objects+import GI.JavaScriptCore.Structs++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 Data.GI.Base+

@@ -0,0 +1,808 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Callbacks+    ( ++ -- * Signals+-- ** ClassDeletePropertyFunction #signal:ClassDeletePropertyFunction#++    C_ClassDeletePropertyFunction           ,+    ClassDeletePropertyFunction             ,+    dynamic_ClassDeletePropertyFunction     ,+    genClosure_ClassDeletePropertyFunction  ,+    mk_ClassDeletePropertyFunction          ,+    noClassDeletePropertyFunction           ,+    wrap_ClassDeletePropertyFunction        ,+++-- ** ClassEnumeratePropertiesFunction #signal:ClassEnumeratePropertiesFunction#++    C_ClassEnumeratePropertiesFunction      ,+    ClassEnumeratePropertiesFunction        ,+    dynamic_ClassEnumeratePropertiesFunction,+    genClosure_ClassEnumeratePropertiesFunction,+    mk_ClassEnumeratePropertiesFunction     ,+    noClassEnumeratePropertiesFunction      ,+    wrap_ClassEnumeratePropertiesFunction   ,+++-- ** ClassGetPropertyFunction #signal:ClassGetPropertyFunction#++    C_ClassGetPropertyFunction              ,+    ClassGetPropertyFunction                ,+    dynamic_ClassGetPropertyFunction        ,+    genClosure_ClassGetPropertyFunction     ,+    mk_ClassGetPropertyFunction             ,+    noClassGetPropertyFunction              ,+    wrap_ClassGetPropertyFunction           ,+++-- ** ClassHasPropertyFunction #signal:ClassHasPropertyFunction#++    C_ClassHasPropertyFunction              ,+    ClassHasPropertyFunction                ,+    dynamic_ClassHasPropertyFunction        ,+    genClosure_ClassHasPropertyFunction     ,+    mk_ClassHasPropertyFunction             ,+    noClassHasPropertyFunction              ,+    wrap_ClassHasPropertyFunction           ,+++-- ** ClassSetPropertyFunction #signal:ClassSetPropertyFunction#++    C_ClassSetPropertyFunction              ,+    ClassSetPropertyFunction                ,+    dynamic_ClassSetPropertyFunction        ,+    genClosure_ClassSetPropertyFunction     ,+    mk_ClassSetPropertyFunction             ,+    noClassSetPropertyFunction              ,+    wrap_ClassSetPropertyFunction           ,+++-- ** ExceptionHandler #signal:ExceptionHandler#++    C_ExceptionHandler                      ,+    ExceptionHandler                        ,+    ExceptionHandler_WithClosures           ,+    drop_closures_ExceptionHandler          ,+    dynamic_ExceptionHandler                ,+    genClosure_ExceptionHandler             ,+    mk_ExceptionHandler                     ,+    noExceptionHandler                      ,+    noExceptionHandler_WithClosures         ,+    wrap_ExceptionHandler                   ,+++-- ** OptionsFunc #signal:OptionsFunc#++    C_OptionsFunc                           ,+    OptionsFunc                             ,+    OptionsFunc_WithClosures                ,+    drop_closures_OptionsFunc               ,+    dynamic_OptionsFunc                     ,+    genClosure_OptionsFunc                  ,+    mk_OptionsFunc                          ,+    noOptionsFunc                           ,+    noOptionsFunc_WithClosures              ,+    wrap_OptionsFunc                        ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 {-# SOURCE #-} qualified GI.JavaScriptCore.Enums as JavaScriptCore.Enums+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Exception as JavaScriptCore.Exception+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value++-- callback OptionsFunc+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE to stop the iteration, or %FALSE otherwise", sinceVersion = Nothing}, args = [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option #JSCOptionType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the option description, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Function used to iterate options.\n\nNot that @description string is not localized.", sinceVersion = Just "2.24"}}+-- | Type for the callback on the (unwrapped) C side.+type C_OptionsFunc =+    CString ->+    CUInt ->+    CString ->+    Ptr () ->+    IO CInt++-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option #JSCOptionType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the option description, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_OptionsFunc :: FunPtr C_OptionsFunc -> C_OptionsFunc++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_OptionsFunc ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    FunPtr C_OptionsFunc+    -> T.Text+    {- ^ /@option@/: the option name -}+    -> JavaScriptCore.Enums.OptionType+    {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -}+    -> Maybe (T.Text)+    {- ^ /@description@/: the option description, or 'Nothing' -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> m Bool+    {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -}+dynamic_OptionsFunc __funPtr option type_ description userData = liftIO $ do+    option' <- textToCString option+    let type_' = (fromIntegral . fromEnum) type_+    maybeDescription <- case description of+        Nothing -> return nullPtr+        Just jDescription -> do+            jDescription' <- textToCString jDescription+            return jDescription'+    result <- (__dynamic_C_OptionsFunc __funPtr) option' type_' maybeDescription userData+    let result' = (/= 0) result+    freeMem option'+    freeMem maybeDescription+    return result'++-- | Generate a function pointer callable from C code, from a `C_OptionsFunc`.+foreign import ccall "wrapper"+    mk_OptionsFunc :: C_OptionsFunc -> IO (FunPtr C_OptionsFunc)++{- |+Function used to iterate options.++Not that /@description@/ string is not localized.++/Since: 2.24/+-}+type OptionsFunc =+    T.Text+    {- ^ /@option@/: the option name -}+    -> JavaScriptCore.Enums.OptionType+    {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -}+    -> Maybe T.Text+    {- ^ /@description@/: the option description, or 'Nothing' -}+    -> IO Bool+    {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionsFunc`@.+noOptionsFunc :: Maybe OptionsFunc+noOptionsFunc = Nothing++{- |+Function used to iterate options.++Not that /@description@/ string is not localized.++/Since: 2.24/+-}+type OptionsFunc_WithClosures =+    T.Text+    {- ^ /@option@/: the option name -}+    -> JavaScriptCore.Enums.OptionType+    {- ^ /@type@/: the option 'GI.JavaScriptCore.Enums.OptionType' -}+    -> Maybe T.Text+    {- ^ /@description@/: the option description, or 'Nothing' -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> IO Bool+    {- ^ __Returns:__ 'True' to stop the iteration, or 'False' otherwise -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `OptionsFunc_WithClosures`@.+noOptionsFunc_WithClosures :: Maybe OptionsFunc_WithClosures+noOptionsFunc_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_OptionsFunc :: OptionsFunc -> OptionsFunc_WithClosures+drop_closures_OptionsFunc _f option type_ description _ = _f option type_ description++-- | Wrap the callback into a `GClosure`.+genClosure_OptionsFunc :: MonadIO m => OptionsFunc -> m (GClosure C_OptionsFunc)+genClosure_OptionsFunc cb = liftIO $ do+    let cb' = drop_closures_OptionsFunc cb+    let cb'' = wrap_OptionsFunc Nothing cb'+    mk_OptionsFunc cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `OptionsFunc` into a `C_OptionsFunc`.+wrap_OptionsFunc ::+    Maybe (Ptr (FunPtr C_OptionsFunc)) ->+    OptionsFunc_WithClosures ->+    C_OptionsFunc+wrap_OptionsFunc funptrptr _cb option type_ description userData = do+    option' <- cstringToText option+    let type_' = (toEnum . fromIntegral) type_+    maybeDescription <-+        if description == nullPtr+        then return Nothing+        else do+            description' <- cstringToText description+            return $ Just description'+    result <- _cb  option' type_' maybeDescription userData+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback ExceptionHandler+--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Function used to handle JavaScript exceptions in a #JSCContext.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ExceptionHandler =+    Ptr JavaScriptCore.Context.Context ->+    Ptr JavaScriptCore.Exception.Exception ->+    Ptr () ->+    IO ()++-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ExceptionHandler :: FunPtr C_ExceptionHandler -> C_ExceptionHandler++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ExceptionHandler ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Exception.IsException b) =>+    FunPtr C_ExceptionHandler+    -> a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> b+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> m ()+dynamic_ExceptionHandler __funPtr context exception userData = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    exception' <- unsafeManagedPtrCastPtr exception+    (__dynamic_C_ExceptionHandler __funPtr) context' exception' userData+    touchManagedPtr context+    touchManagedPtr exception+    return ()++-- | Generate a function pointer callable from C code, from a `C_ExceptionHandler`.+foreign import ccall "wrapper"+    mk_ExceptionHandler :: C_ExceptionHandler -> IO (FunPtr C_ExceptionHandler)++{- |+Function used to handle JavaScript exceptions in a 'GI.JavaScriptCore.Objects.Context.Context'.+-}+type ExceptionHandler =+    JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> JavaScriptCore.Exception.Exception+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ExceptionHandler`@.+noExceptionHandler :: Maybe ExceptionHandler+noExceptionHandler = Nothing++{- |+Function used to handle JavaScript exceptions in a 'GI.JavaScriptCore.Objects.Context.Context'.+-}+type ExceptionHandler_WithClosures =+    JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> JavaScriptCore.Exception.Exception+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> Ptr ()+    {- ^ /@userData@/: user data -}+    -> IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `ExceptionHandler_WithClosures`@.+noExceptionHandler_WithClosures :: Maybe ExceptionHandler_WithClosures+noExceptionHandler_WithClosures = Nothing++-- | A simple wrapper that ignores the closure arguments.+drop_closures_ExceptionHandler :: ExceptionHandler -> ExceptionHandler_WithClosures+drop_closures_ExceptionHandler _f context exception _ = _f context exception++-- | Wrap the callback into a `GClosure`.+genClosure_ExceptionHandler :: MonadIO m => ExceptionHandler -> m (GClosure C_ExceptionHandler)+genClosure_ExceptionHandler cb = liftIO $ do+    let cb' = drop_closures_ExceptionHandler cb+    let cb'' = wrap_ExceptionHandler Nothing cb'+    mk_ExceptionHandler cb'' >>= B.GClosure.newGClosure+++-- | Wrap a `ExceptionHandler` into a `C_ExceptionHandler`.+wrap_ExceptionHandler ::+    Maybe (Ptr (FunPtr C_ExceptionHandler)) ->+    ExceptionHandler_WithClosures ->+    C_ExceptionHandler+wrap_ExceptionHandler funptrptr _cb context exception userData = do+    context' <- (newObject JavaScriptCore.Context.Context) context+    exception' <- (newObject JavaScriptCore.Exception.Exception) exception+    _cb  context' exception' userData+    maybeReleaseFunPtr funptrptr+++-- callback ClassSetPropertyFunction+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if handled or %FALSE to forward the request to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of set_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ClassSetPropertyFunction =+    Ptr JavaScriptCore.Class.Class ->+    Ptr JavaScriptCore.Context.Context ->+    Ptr () ->+    CString ->+    Ptr JavaScriptCore.Value.Value ->+    IO CInt++-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ClassSetPropertyFunction :: FunPtr C_ClassSetPropertyFunction -> C_ClassSetPropertyFunction++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ClassSetPropertyFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b, JavaScriptCore.Value.IsValue c) =>+    FunPtr C_ClassSetPropertyFunction+    -> a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> b+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> c+    {- ^ /@value@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if handled or 'False' to forward the request to the parent class or prototype chain. -}+dynamic_ClassSetPropertyFunction __funPtr jscClass context instance_ name value = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    value' <- unsafeManagedPtrCastPtr value+    result <- (__dynamic_C_ClassSetPropertyFunction __funPtr) jscClass' context' instance_ name' value'+    let result' = (/= 0) result+    touchManagedPtr jscClass+    touchManagedPtr context+    touchManagedPtr value+    freeMem name'+    return result'++-- | Generate a function pointer callable from C code, from a `C_ClassSetPropertyFunction`.+foreign import ccall "wrapper"+    mk_ClassSetPropertyFunction :: C_ClassSetPropertyFunction -> IO (FunPtr C_ClassSetPropertyFunction)++{- |+The type of set_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle+external properties not added to the prototype.+-}+type ClassSetPropertyFunction =+    JavaScriptCore.Class.Class+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> JavaScriptCore.Value.Value+    {- ^ /@value@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -}+    -> IO Bool+    {- ^ __Returns:__ 'True' if handled or 'False' to forward the request to the parent class or prototype chain. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassSetPropertyFunction`@.+noClassSetPropertyFunction :: Maybe ClassSetPropertyFunction+noClassSetPropertyFunction = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_ClassSetPropertyFunction :: MonadIO m => ClassSetPropertyFunction -> m (GClosure C_ClassSetPropertyFunction)+genClosure_ClassSetPropertyFunction cb = liftIO $ do+    let cb' = wrap_ClassSetPropertyFunction Nothing cb+    mk_ClassSetPropertyFunction cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassSetPropertyFunction` into a `C_ClassSetPropertyFunction`.+wrap_ClassSetPropertyFunction ::+    Maybe (Ptr (FunPtr C_ClassSetPropertyFunction)) ->+    ClassSetPropertyFunction ->+    C_ClassSetPropertyFunction+wrap_ClassSetPropertyFunction funptrptr _cb jscClass context instance_ name value = do+    jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass+    context' <- (newObject JavaScriptCore.Context.Context) context+    name' <- cstringToText name+    value' <- (newObject JavaScriptCore.Value.Value) value+    result <- _cb  jscClass' context' instance_ name' value'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback ClassHasPropertyFunction+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if @instance has a property with @name or %FALSE to forward the request\n   to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of has_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ClassHasPropertyFunction =+    Ptr JavaScriptCore.Class.Class ->+    Ptr JavaScriptCore.Context.Context ->+    Ptr () ->+    CString ->+    IO CInt++-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ClassHasPropertyFunction :: FunPtr C_ClassHasPropertyFunction -> C_ClassHasPropertyFunction++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ClassHasPropertyFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>+    FunPtr C_ClassHasPropertyFunction+    -> a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> b+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@instance@/ has a property with /@name@/ or 'False' to forward the request+   to the parent class or prototype chain. -}+dynamic_ClassHasPropertyFunction __funPtr jscClass context instance_ name = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    result <- (__dynamic_C_ClassHasPropertyFunction __funPtr) jscClass' context' instance_ name'+    let result' = (/= 0) result+    touchManagedPtr jscClass+    touchManagedPtr context+    freeMem name'+    return result'++-- | Generate a function pointer callable from C code, from a `C_ClassHasPropertyFunction`.+foreign import ccall "wrapper"+    mk_ClassHasPropertyFunction :: C_ClassHasPropertyFunction -> IO (FunPtr C_ClassHasPropertyFunction)++{- |+The type of has_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle+external properties not added to the prototype.+-}+type ClassHasPropertyFunction =+    JavaScriptCore.Class.Class+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> IO Bool+    {- ^ __Returns:__ 'True' if /@instance@/ has a property with /@name@/ or 'False' to forward the request+   to the parent class or prototype chain. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassHasPropertyFunction`@.+noClassHasPropertyFunction :: Maybe ClassHasPropertyFunction+noClassHasPropertyFunction = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_ClassHasPropertyFunction :: MonadIO m => ClassHasPropertyFunction -> m (GClosure C_ClassHasPropertyFunction)+genClosure_ClassHasPropertyFunction cb = liftIO $ do+    let cb' = wrap_ClassHasPropertyFunction Nothing cb+    mk_ClassHasPropertyFunction cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassHasPropertyFunction` into a `C_ClassHasPropertyFunction`.+wrap_ClassHasPropertyFunction ::+    Maybe (Ptr (FunPtr C_ClassHasPropertyFunction)) ->+    ClassHasPropertyFunction ->+    C_ClassHasPropertyFunction+wrap_ClassHasPropertyFunction funptrptr _cb jscClass context instance_ name = do+    jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass+    context' <- (newObject JavaScriptCore.Context.Context) context+    name' <- cstringToText name+    result <- _cb  jscClass' context' instance_ name'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++-- callback ClassGetPropertyFunction+--          -> Callable {returnType = Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a #JSCValue or %NULL to forward the request to\n   the parent class or prototype chain", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of get_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ClassGetPropertyFunction =+    Ptr JavaScriptCore.Class.Class ->+    Ptr JavaScriptCore.Context.Context ->+    Ptr () ->+    CString ->+    IO (Ptr JavaScriptCore.Value.Value)++-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ClassGetPropertyFunction :: FunPtr C_ClassGetPropertyFunction -> C_ClassGetPropertyFunction++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ClassGetPropertyFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>+    FunPtr C_ClassGetPropertyFunction+    -> a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> b+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m (Maybe JavaScriptCore.Value.Value)+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' to forward the request to+   the parent class or prototype chain -}+dynamic_ClassGetPropertyFunction __funPtr jscClass context instance_ name = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    result <- (__dynamic_C_ClassGetPropertyFunction __funPtr) jscClass' context' instance_ name'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (wrapObject JavaScriptCore.Value.Value) result'+        return result''+    touchManagedPtr jscClass+    touchManagedPtr context+    freeMem name'+    return maybeResult++-- | Generate a function pointer callable from C code, from a `C_ClassGetPropertyFunction`.+foreign import ccall "wrapper"+    mk_ClassGetPropertyFunction :: C_ClassGetPropertyFunction -> IO (FunPtr C_ClassGetPropertyFunction)++{- |+The type of get_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle+external properties not added to the prototype.+-}+type ClassGetPropertyFunction =+    JavaScriptCore.Class.Class+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> IO (Maybe JavaScriptCore.Value.Value)+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' to forward the request to+   the parent class or prototype chain -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGetPropertyFunction`@.+noClassGetPropertyFunction :: Maybe ClassGetPropertyFunction+noClassGetPropertyFunction = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_ClassGetPropertyFunction :: MonadIO m => ClassGetPropertyFunction -> m (GClosure C_ClassGetPropertyFunction)+genClosure_ClassGetPropertyFunction cb = liftIO $ do+    let cb' = wrap_ClassGetPropertyFunction Nothing cb+    mk_ClassGetPropertyFunction cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassGetPropertyFunction` into a `C_ClassGetPropertyFunction`.+wrap_ClassGetPropertyFunction ::+    Maybe (Ptr (FunPtr C_ClassGetPropertyFunction)) ->+    ClassGetPropertyFunction ->+    C_ClassGetPropertyFunction+wrap_ClassGetPropertyFunction funptrptr _cb jscClass context instance_ name = do+    jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass+    context' <- (newObject JavaScriptCore.Context.Context) context+    name' <- cstringToText name+    result <- _cb  jscClass' context' instance_ name'+    maybeReleaseFunPtr funptrptr+    maybeM nullPtr result $ \result' -> do+        result'' <- B.ManagedPtr.disownObject result'+        return result''+++-- callback ClassEnumeratePropertiesFunction+--          -> Callable {returnType = Just (TCArray True (-1) (-1) (TBasicType TUTF8)), returnMayBeNull = True, returnTransfer = TransferEverything, returnDocumentation = Documentation {rawDocText = Just "a %NULL-terminated array of strings\n   containing the property names, or %NULL if @instance doesn't have enumerable properties.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of enumerate_properties in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ClassEnumeratePropertiesFunction =+    Ptr JavaScriptCore.Class.Class ->+    Ptr JavaScriptCore.Context.Context ->+    Ptr () ->+    IO (Ptr CString)++-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ClassEnumeratePropertiesFunction :: FunPtr C_ClassEnumeratePropertiesFunction -> C_ClassEnumeratePropertiesFunction++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ClassEnumeratePropertiesFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>+    FunPtr C_ClassEnumeratePropertiesFunction+    -> a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> b+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> m (Maybe [T.Text])+    {- ^ __Returns:__ a 'Nothing'-terminated array of strings+   containing the property names, or 'Nothing' if /@instance@/ doesn\'t have enumerable properties. -}+dynamic_ClassEnumeratePropertiesFunction __funPtr jscClass context instance_ = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    context' <- unsafeManagedPtrCastPtr context+    result <- (__dynamic_C_ClassEnumeratePropertiesFunction __funPtr) jscClass' context' instance_+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- unpackZeroTerminatedUTF8CArray result'+        mapZeroTerminatedCArray freeMem result'+        freeMem result'+        return result''+    touchManagedPtr jscClass+    touchManagedPtr context+    return maybeResult++-- | Generate a function pointer callable from C code, from a `C_ClassEnumeratePropertiesFunction`.+foreign import ccall "wrapper"+    mk_ClassEnumeratePropertiesFunction :: C_ClassEnumeratePropertiesFunction -> IO (FunPtr C_ClassEnumeratePropertiesFunction)++{- |+The type of enumerate_properties in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle+external properties not added to the prototype.+-}+type ClassEnumeratePropertiesFunction =+    JavaScriptCore.Class.Class+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> IO (Maybe [T.Text])+    {- ^ __Returns:__ a 'Nothing'-terminated array of strings+   containing the property names, or 'Nothing' if /@instance@/ doesn\'t have enumerable properties. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassEnumeratePropertiesFunction`@.+noClassEnumeratePropertiesFunction :: Maybe ClassEnumeratePropertiesFunction+noClassEnumeratePropertiesFunction = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_ClassEnumeratePropertiesFunction :: MonadIO m => ClassEnumeratePropertiesFunction -> m (GClosure C_ClassEnumeratePropertiesFunction)+genClosure_ClassEnumeratePropertiesFunction cb = liftIO $ do+    let cb' = wrap_ClassEnumeratePropertiesFunction Nothing cb+    mk_ClassEnumeratePropertiesFunction cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassEnumeratePropertiesFunction` into a `C_ClassEnumeratePropertiesFunction`.+wrap_ClassEnumeratePropertiesFunction ::+    Maybe (Ptr (FunPtr C_ClassEnumeratePropertiesFunction)) ->+    ClassEnumeratePropertiesFunction ->+    C_ClassEnumeratePropertiesFunction+wrap_ClassEnumeratePropertiesFunction funptrptr _cb jscClass context instance_ = do+    jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass+    context' <- (newObject JavaScriptCore.Context.Context) context+    result <- _cb  jscClass' context' instance_+    maybeReleaseFunPtr funptrptr+    maybeM nullPtr result $ \result' -> do+        result'' <- packZeroTerminatedUTF8CArray result'+        return result''+++-- callback ClassDeletePropertyFunction+--          -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if handled or %FALSE to to forward the request to the parent class or prototype chain.", sinceVersion = Nothing}, args = [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "The type of delete_property in #JSCClassVTable. This is only required when you need to handle\nexternal properties not added to the prototype.", sinceVersion = Nothing}}+-- | Type for the callback on the (unwrapped) C side.+type C_ClassDeletePropertyFunction =+    Ptr JavaScriptCore.Class.Class ->+    Ptr JavaScriptCore.Context.Context ->+    Ptr () ->+    CString ->+    IO CInt++-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the @jsc_class instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "dynamic" __dynamic_C_ClassDeletePropertyFunction :: FunPtr C_ClassDeletePropertyFunction -> C_ClassDeletePropertyFunction++-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.+dynamic_ClassDeletePropertyFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Class.IsClass a, JavaScriptCore.Context.IsContext b) =>+    FunPtr C_ClassDeletePropertyFunction+    -> a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> b+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m Bool+    {- ^ __Returns:__ 'True' if handled or 'False' to to forward the request to the parent class or prototype chain. -}+dynamic_ClassDeletePropertyFunction __funPtr jscClass context instance_ name = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    result <- (__dynamic_C_ClassDeletePropertyFunction __funPtr) jscClass' context' instance_ name'+    let result' = (/= 0) result+    touchManagedPtr jscClass+    touchManagedPtr context+    freeMem name'+    return result'++-- | Generate a function pointer callable from C code, from a `C_ClassDeletePropertyFunction`.+foreign import ccall "wrapper"+    mk_ClassDeletePropertyFunction :: C_ClassDeletePropertyFunction -> IO (FunPtr C_ClassDeletePropertyFunction)++{- |+The type of delete_property in 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable'. This is only required when you need to handle+external properties not added to the prototype.+-}+type ClassDeletePropertyFunction =+    JavaScriptCore.Class.Class+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> JavaScriptCore.Context.Context+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: the /@jscClass@/ instance -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> IO Bool+    {- ^ __Returns:__ 'True' if handled or 'False' to to forward the request to the parent class or prototype chain. -}++-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassDeletePropertyFunction`@.+noClassDeletePropertyFunction :: Maybe ClassDeletePropertyFunction+noClassDeletePropertyFunction = Nothing++-- | Wrap the callback into a `GClosure`.+genClosure_ClassDeletePropertyFunction :: MonadIO m => ClassDeletePropertyFunction -> m (GClosure C_ClassDeletePropertyFunction)+genClosure_ClassDeletePropertyFunction cb = liftIO $ do+    let cb' = wrap_ClassDeletePropertyFunction Nothing cb+    mk_ClassDeletePropertyFunction cb' >>= B.GClosure.newGClosure+++-- | Wrap a `ClassDeletePropertyFunction` into a `C_ClassDeletePropertyFunction`.+wrap_ClassDeletePropertyFunction ::+    Maybe (Ptr (FunPtr C_ClassDeletePropertyFunction)) ->+    ClassDeletePropertyFunction ->+    C_ClassDeletePropertyFunction+wrap_ClassDeletePropertyFunction funptrptr _cb jscClass context instance_ name = do+    jscClass' <- (newObject JavaScriptCore.Class.Class) jscClass+    context' <- (newObject JavaScriptCore.Context.Context) context+    name' <- cstringToText name+    result <- _cb  jscClass' context' instance_ name'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'+++

@@ -0,0 +1,103 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Constants+    ( +    pattern OPTIONS_USE_LLINT               ,+    pattern OPTIONS_USE_JIT                 ,+    pattern OPTIONS_USE_FTL                 ,+    pattern OPTIONS_USE_DFG                 ,+    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++{- |+Allows the LLINT to be used if 'True'.+Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean'+Default value: 'True'.++/Since: 2.24/+-}+pattern OPTIONS_USE_LLINT = "useLLInt" :: T.Text++{- |+Allows the executable pages to be allocated for JIT and thunks if 'True'.+Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean'+Default value: 'True'.++/Since: 2.24/+-}+pattern OPTIONS_USE_JIT = "useJIT" :: T.Text++{- |+Allows the FTL JIT to be used if 'True'.+Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean'+Default value: 'True'.++/Since: 2.24/+-}+pattern OPTIONS_USE_FTL = "useFTLJIT" :: T.Text++{- |+Allows the DFG JIT to be used if 'True'.+Option type: 'GI.JavaScriptCore.Enums.OptionTypeBoolean'+Default value: 'True'.++/Since: 2.24/+-}+pattern OPTIONS_USE_DFG = "useDFGJIT" :: T.Text++{- |+Like 'GI.JavaScriptCore.Functions.getMinorVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.+-}+pattern MINOR_VERSION = 24 :: Int32++{- |+Like 'GI.JavaScriptCore.Functions.getMicroVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.+-}+pattern MICRO_VERSION = 2 :: Int32++{- |+Like 'GI.JavaScriptCore.Functions.getMajorVersion', but from the headers used at+application compile time, rather than from the library linked+against at application run time.+-}+pattern MAJOR_VERSION = 2 :: Int32++

@@ -0,0 +1,199 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Enums+    ( ++ -- * Enumerations+-- ** CheckSyntaxMode #enum:CheckSyntaxMode#++    CheckSyntaxMode(..)                     ,+++-- ** CheckSyntaxResult #enum:CheckSyntaxResult#++    CheckSyntaxResult(..)                   ,+++-- ** OptionType #enum:OptionType#++    OptionType(..)                          ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++-- Enum OptionType+{- |+Enum values for options types.++/Since: 2.24/+-}+data OptionType = +      OptionTypeBoolean+    {- ^+    A 'Bool' option type.+    -}+    | OptionTypeInt+    {- ^+    A @/gint/@ option type.+    -}+    | OptionTypeUint+    {- ^+    A @/guint/@ option type.+    -}+    | OptionTypeSize+    {- ^+    A @/gsize/@ options type.+    -}+    | OptionTypeDouble+    {- ^+    A @/gdouble/@ options type.+    -}+    | OptionTypeString+    {- ^+    A string option type.+    -}+    | OptionTypeRangeString+    {- ^+    A range string option type.+    -}+    | AnotherOptionType Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum OptionType where+    fromEnum OptionTypeBoolean = 0+    fromEnum OptionTypeInt = 1+    fromEnum OptionTypeUint = 2+    fromEnum OptionTypeSize = 3+    fromEnum OptionTypeDouble = 4+    fromEnum OptionTypeString = 5+    fromEnum OptionTypeRangeString = 6+    fromEnum (AnotherOptionType k) = k++    toEnum 0 = OptionTypeBoolean+    toEnum 1 = OptionTypeInt+    toEnum 2 = OptionTypeUint+    toEnum 3 = OptionTypeSize+    toEnum 4 = OptionTypeDouble+    toEnum 5 = OptionTypeString+    toEnum 6 = OptionTypeRangeString+    toEnum k = AnotherOptionType k++instance P.Ord OptionType where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum CheckSyntaxResult+{- |+Enum values to specify the result of 'GI.JavaScriptCore.Objects.Context.contextCheckSyntax'.+-}+data CheckSyntaxResult = +      CheckSyntaxResultSuccess+    {- ^+    no errors+    -}+    | CheckSyntaxResultRecoverableError+    {- ^+    recoverable syntax error+    -}+    | CheckSyntaxResultIrrecoverableError+    {- ^+    irrecoverable syntax error+    -}+    | CheckSyntaxResultUnterminatedLiteralError+    {- ^+    unterminated literal error+    -}+    | CheckSyntaxResultOutOfMemoryError+    {- ^+    out of memory error+    -}+    | CheckSyntaxResultStackOverflowError+    {- ^+    stack overflow error+    -}+    | AnotherCheckSyntaxResult Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CheckSyntaxResult where+    fromEnum CheckSyntaxResultSuccess = 0+    fromEnum CheckSyntaxResultRecoverableError = 1+    fromEnum CheckSyntaxResultIrrecoverableError = 2+    fromEnum CheckSyntaxResultUnterminatedLiteralError = 3+    fromEnum CheckSyntaxResultOutOfMemoryError = 4+    fromEnum CheckSyntaxResultStackOverflowError = 5+    fromEnum (AnotherCheckSyntaxResult k) = k++    toEnum 0 = CheckSyntaxResultSuccess+    toEnum 1 = CheckSyntaxResultRecoverableError+    toEnum 2 = CheckSyntaxResultIrrecoverableError+    toEnum 3 = CheckSyntaxResultUnterminatedLiteralError+    toEnum 4 = CheckSyntaxResultOutOfMemoryError+    toEnum 5 = CheckSyntaxResultStackOverflowError+    toEnum k = AnotherCheckSyntaxResult k++instance P.Ord CheckSyntaxResult where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++-- Enum CheckSyntaxMode+{- |+Enum values to specify a mode to check for syntax errors in 'GI.JavaScriptCore.Objects.Context.contextCheckSyntax'.+-}+data CheckSyntaxMode = +      CheckSyntaxModeScript+    {- ^+    mode to check syntax of a script+    -}+    | CheckSyntaxModeModule+    {- ^+    mode to check syntax of a module+    -}+    | AnotherCheckSyntaxMode Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum CheckSyntaxMode where+    fromEnum CheckSyntaxModeScript = 0+    fromEnum CheckSyntaxModeModule = 1+    fromEnum (AnotherCheckSyntaxMode k) = k++    toEnum 0 = CheckSyntaxModeScript+    toEnum 1 = CheckSyntaxModeModule+    toEnum k = AnotherCheckSyntaxMode k++instance P.Ord CheckSyntaxMode where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++

@@ -0,0 +1,30 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Enums 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++data OptionType+instance P.Enum OptionType where+data CheckSyntaxResult+instance P.Enum CheckSyntaxResult where+data CheckSyntaxMode+instance P.Enum CheckSyntaxMode where

@@ -0,0 +1,87 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Flags+    ( ++ -- * Flags+-- ** ValuePropertyFlags #flag:ValuePropertyFlags#++    ValuePropertyFlags(..)                  ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++-- Flags ValuePropertyFlags+{- |+Flags used when defining properties with 'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyData' and+'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyAccessor'.+-}+data ValuePropertyFlags = +      ValuePropertyFlagsConfigurable+    {- ^+    the type of the property descriptor may be changed and the+     property may be deleted from the corresponding object.+    -}+    | ValuePropertyFlagsEnumerable+    {- ^+    the property shows up during enumeration of the properties on+     the corresponding object.+    -}+    | ValuePropertyFlagsWritable+    {- ^+    the value associated with the property may be changed with an+     assignment operator. This doesn\'t have any effect when passed to 'GI.JavaScriptCore.Objects.Value.valueObjectDefinePropertyAccessor'.+    -}+    | AnotherValuePropertyFlags Int+    -- ^ Catch-all for unknown values+    deriving (Show, Eq)++instance P.Enum ValuePropertyFlags where+    fromEnum ValuePropertyFlagsConfigurable = 1+    fromEnum ValuePropertyFlagsEnumerable = 2+    fromEnum ValuePropertyFlagsWritable = 4+    fromEnum (AnotherValuePropertyFlags k) = k++    toEnum 1 = ValuePropertyFlagsConfigurable+    toEnum 2 = ValuePropertyFlagsEnumerable+    toEnum 4 = ValuePropertyFlagsWritable+    toEnum k = AnotherValuePropertyFlags k++instance P.Ord ValuePropertyFlags where+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)++instance IsGFlag ValuePropertyFlags++

@@ -0,0 +1,27 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Flags 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++data ValuePropertyFlags+instance P.Enum ValuePropertyFlags where+instance IsGFlag ValuePropertyFlags

@@ -0,0 +1,772 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Functions+    ( ++ -- * Methods+-- ** getMajorVersion #method:getMajorVersion#++    getMajorVersion                         ,+++-- ** getMicroVersion #method:getMicroVersion#++    getMicroVersion                         ,+++-- ** getMinorVersion #method:getMinorVersion#++    getMinorVersion                         ,+++-- ** optionsForeach #method:optionsForeach#++    optionsForeach                          ,+++-- ** optionsGetBoolean #method:optionsGetBoolean#++    optionsGetBoolean                       ,+++-- ** optionsGetDouble #method:optionsGetDouble#++    optionsGetDouble                        ,+++-- ** optionsGetInt #method:optionsGetInt#++    optionsGetInt                           ,+++-- ** optionsGetOptionGroup #method:optionsGetOptionGroup#++    optionsGetOptionGroup                   ,+++-- ** optionsGetRangeString #method:optionsGetRangeString#++    optionsGetRangeString                   ,+++-- ** optionsGetSize #method:optionsGetSize#++    optionsGetSize                          ,+++-- ** optionsGetString #method:optionsGetString#++    optionsGetString                        ,+++-- ** optionsGetUint #method:optionsGetUint#++    optionsGetUint                          ,+++-- ** optionsSetBoolean #method:optionsSetBoolean#++    optionsSetBoolean                       ,+++-- ** optionsSetDouble #method:optionsSetDouble#++    optionsSetDouble                        ,+++-- ** optionsSetInt #method:optionsSetInt#++    optionsSetInt                           ,+++-- ** optionsSetRangeString #method:optionsSetRangeString#++    optionsSetRangeString                   ,+++-- ** optionsSetSize #method:optionsSetSize#++    optionsSetSize                          ,+++-- ** optionsSetString #method:optionsSetString#++    optionsSetString                        ,+++-- ** optionsSetUint #method:optionsSetUint#++    optionsSetUint                          ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GLib.Structs.OptionGroup as GLib.OptionGroup+import qualified GI.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks++-- function jsc_options_set_uint+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_uint" jsc_options_set_uint :: +    CString ->                              -- option : TBasicType TUTF8+    Word32 ->                               -- value : TBasicType TUInt+    IO CInt++{- |+Set /@option@/ as a @/guint/@ value.++/Since: 2.24/+-}+optionsSetUint ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> Word32+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetUint option value = liftIO $ do+    option' <- textToCString option+    result <- jsc_options_set_uint option' value+    let result' = (/= 0) result+    freeMem option'+    return result'+++-- function jsc_options_set_string+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_string" jsc_options_set_string :: +    CString ->                              -- option : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO CInt++{- |+Set /@option@/ as a string.++/Since: 2.24/+-}+optionsSetString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> T.Text+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetString option value = liftIO $ do+    option' <- textToCString option+    value' <- textToCString value+    result <- jsc_options_set_string option' value'+    let result' = (/= 0) result+    freeMem option'+    freeMem value'+    return result'+++-- function jsc_options_set_size+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_size" jsc_options_set_size :: +    CString ->                              -- option : TBasicType TUTF8+    Word64 ->                               -- value : TBasicType TUInt64+    IO CInt++{- |+Set /@option@/ as a @/gsize/@ value.++/Since: 2.24/+-}+optionsSetSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> Word64+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetSize option value = liftIO $ do+    option' <- textToCString option+    result <- jsc_options_set_size option' value+    let result' = (/= 0) result+    freeMem option'+    return result'+++-- function jsc_options_set_range_string+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_range_string" jsc_options_set_range_string :: +    CString ->                              -- option : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO CInt++{- |+Set /@option@/ as a range string. The string must be in the+format \<emphasis>[!]&lt;low&gt;[:&lt;high&gt;]\<\/emphasis> where low and high are @/guint/@ values.+Values between low and high (both included) will be considered in+the range, unless \<emphasis>!\<\/emphasis> is used to invert the range.++/Since: 2.24/+-}+optionsSetRangeString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> T.Text+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetRangeString option value = liftIO $ do+    option' <- textToCString option+    value' <- textToCString value+    result <- jsc_options_set_range_string option' value'+    let result' = (/= 0) result+    freeMem option'+    freeMem value'+    return result'+++-- function jsc_options_set_int+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_int" jsc_options_set_int :: +    CString ->                              -- option : TBasicType TUTF8+    Int32 ->                                -- value : TBasicType TInt+    IO CInt++{- |+Set /@option@/ as a @/gint/@ value.++/Since: 2.24/+-}+optionsSetInt ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> Int32+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetInt option value = liftIO $ do+    option' <- textToCString option+    result <- jsc_options_set_int option' value+    let result' = (/= 0) result+    freeMem option'+    return result'+++-- function jsc_options_set_double+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_double" jsc_options_set_double :: +    CString ->                              -- option : TBasicType TUTF8+    CDouble ->                              -- value : TBasicType TDouble+    IO CInt++{- |+Set /@option@/ as a @/gdouble/@ value.++/Since: 2.24/+-}+optionsSetDouble ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> Double+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetDouble option value = liftIO $ do+    option' <- textToCString option+    let value' = realToFrac value+    result <- jsc_options_set_double option' value'+    let result' = (/= 0) result+    freeMem option'+    return result'+++-- function jsc_options_set_boolean+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_set_boolean" jsc_options_set_boolean :: +    CString ->                              -- option : TBasicType TUTF8+    CInt ->                                 -- value : TBasicType TBoolean+    IO CInt++{- |+Set /@option@/ as a 'Bool' value.++/Since: 2.24/+-}+optionsSetBoolean ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> Bool+    {- ^ /@value@/: the value to set -}+    -> m Bool+    {- ^ __Returns:__ 'True' if option was correctly set or 'False' otherwise. -}+optionsSetBoolean option value = liftIO $ do+    option' <- textToCString option+    let value' = (fromIntegral . fromEnum) value+    result <- jsc_options_set_boolean option' value'+    let result' = (/= 0) result+    freeMem option'+    return result'+++-- function jsc_options_get_uint+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_uint" jsc_options_get_uint :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr Word32 ->                           -- value : TBasicType TUInt+    IO CInt++{- |+Get /@option@/ as a @/guint/@ value.++/Since: 2.24/+-}+optionsGetUint ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, Word32))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetUint option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr Word32)+    result <- jsc_options_get_uint option' value+    let result' = (/= 0) result+    value' <- peek value+    freeMem option'+    freeMem value+    return (result', value')+++-- function jsc_options_get_string+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_string" jsc_options_get_string :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt++{- |+Get /@option@/ as a string.++/Since: 2.24/+-}+optionsGetString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, T.Text))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetString option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr CString)+    result <- jsc_options_get_string option' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    freeMem option'+    freeMem value+    return (result', value'')+++-- function jsc_options_get_size+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_size" jsc_options_get_size :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr Word64 ->                           -- value : TBasicType TUInt64+    IO CInt++{- |+Get /@option@/ as a @/gsize/@ value.++/Since: 2.24/+-}+optionsGetSize ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, Word64))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetSize option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr Word64)+    result <- jsc_options_get_size option' value+    let result' = (/= 0) result+    value' <- peek value+    freeMem option'+    freeMem value+    return (result', value')+++-- function jsc_options_get_range_string+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_range_string" jsc_options_get_range_string :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt++{- |+Get /@option@/ as a range string. The string must be in the+format \<emphasis>[!]&lt;low&gt;[:&lt;high&gt;]\<\/emphasis> where low and high are @/guint/@ values.+Values between low and high (both included) will be considered in+the range, unless \<emphasis>!\<\/emphasis> is used to invert the range.++/Since: 2.24/+-}+optionsGetRangeString ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, T.Text))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetRangeString option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr CString)+    result <- jsc_options_get_range_string option' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    freeMem option'+    freeMem value+    return (result', value'')+++-- function jsc_options_get_option_group+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "OptionGroup"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_option_group" jsc_options_get_option_group :: +    IO (Ptr GLib.OptionGroup.OptionGroup)++{- |+Create a 'GI.GLib.Structs.OptionGroup.OptionGroup' to handle JSCOptions as command line arguments.+The options will be exposed as command line arguments with the form+\<emphasis>--jsc-&lt;option&gt;=&lt;value&gt;\<\/emphasis>.+Each entry in the returned 'GI.GLib.Structs.OptionGroup.OptionGroup' is configured to apply the+corresponding option during command line parsing. Applications only need to+pass the returned group to 'GI.GLib.Structs.OptionContext.optionContextAddGroup', and the rest will+be taken care for automatically.++/Since: 2.24/+-}+optionsGetOptionGroup ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m GLib.OptionGroup.OptionGroup+    {- ^ __Returns:__ a 'GI.GLib.Structs.OptionGroup.OptionGroup' for the JSCOptions -}+optionsGetOptionGroup  = liftIO $ do+    result <- jsc_options_get_option_group+    checkUnexpectedReturnNULL "optionsGetOptionGroup" result+    result' <- (wrapBoxed GLib.OptionGroup.OptionGroup) result+    return result'+++-- function jsc_options_get_int+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_int" jsc_options_get_int :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr Int32 ->                            -- value : TBasicType TInt+    IO CInt++{- |+Get /@option@/ as a @/gint/@ value.++/Since: 2.24/+-}+optionsGetInt ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, Int32))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetInt option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr Int32)+    result <- jsc_options_get_int option' value+    let result' = (/= 0) result+    value' <- peek value+    freeMem option'+    freeMem value+    return (result', value')+++-- function jsc_options_get_double+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_double" jsc_options_get_double :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr CDouble ->                          -- value : TBasicType TDouble+    IO CInt++{- |+Get /@option@/ as a @/gdouble/@ value.++/Since: 2.24/+-}+optionsGetDouble ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, Double))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetDouble option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr CDouble)+    result <- jsc_options_get_double option' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    freeMem option'+    freeMem value+    return (result', value'')+++-- function jsc_options_get_boolean+-- Args : [Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the option identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the option value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_get_boolean" jsc_options_get_boolean :: +    CString ->                              -- option : TBasicType TUTF8+    Ptr CInt ->                             -- value : TBasicType TBoolean+    IO CInt++{- |+Get /@option@/ as a 'Bool' value.++/Since: 2.24/+-}+optionsGetBoolean ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    T.Text+    {- ^ /@option@/: the option identifier -}+    -> m ((Bool, Bool))+    {- ^ __Returns:__ 'True' if /@value@/ has been set or 'False' if the option doesn\'t exist -}+optionsGetBoolean option = liftIO $ do+    option' <- textToCString option+    value <- allocMem :: IO (Ptr CInt)+    result <- jsc_options_get_boolean option' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = (/= 0) value'+    freeMem option'+    freeMem value+    return (result', value'')+++-- function jsc_options_foreach+-- Args : [Arg {argCName = "function", argType = TInterface (Name {namespace = "JavaScriptCore", name = "OptionsFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCOptionsFunc callback", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_options_foreach" jsc_options_foreach :: +    FunPtr JavaScriptCore.Callbacks.C_OptionsFunc -> -- function : TInterface (Name {namespace = "JavaScriptCore", name = "OptionsFunc"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    IO ()++{- |+Iterates all available options calling /@function@/ for each one. Iteration can+stop early if /@function@/ returns 'False'.++/Since: 2.24/+-}+optionsForeach ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    JavaScriptCore.Callbacks.OptionsFunc+    {- ^ /@function@/: a 'GI.JavaScriptCore.Callbacks.OptionsFunc' callback -}+    -> m ()+optionsForeach function = liftIO $ do+    function' <- JavaScriptCore.Callbacks.mk_OptionsFunc (JavaScriptCore.Callbacks.wrap_OptionsFunc Nothing (JavaScriptCore.Callbacks.drop_closures_OptionsFunc function))+    let userData = nullPtr+    jsc_options_foreach function' userData+    safeFreeFunPtr $ castFunPtrToPtr function'+    return ()+++-- function jsc_get_minor_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_get_minor_version" jsc_get_minor_version :: +    IO Word32++{- |+Returns the minor version number of the JavaScriptCore library.+(e.g. in JavaScriptCore version 1.8.3 this is 8.)++This function is in the library, so it represents the JavaScriptCore library+your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MINOR_VERSION'+macro, which represents the minor version of the JavaScriptCore headers you+have included when compiling your code.+-}+getMinorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the minor version number of the JavaScriptCore library -}+getMinorVersion  = liftIO $ do+    result <- jsc_get_minor_version+    return result+++-- function jsc_get_micro_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_get_micro_version" jsc_get_micro_version :: +    IO Word32++{- |+Returns the micro version number of the JavaScriptCore library.+(e.g. in JavaScriptCore version 1.8.3 this is 3.)++This function is in the library, so it represents the JavaScriptCore library+your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MICRO_VERSION'+macro, which represents the micro version of the JavaScriptCore headers you+have included when compiling your code.+-}+getMicroVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the micro version number of the JavaScriptCore library -}+getMicroVersion  = liftIO $ do+    result <- jsc_get_micro_version+    return result+++-- function jsc_get_major_version+-- Args : []+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_get_major_version" jsc_get_major_version :: +    IO Word32++{- |+Returns the major version number of the JavaScriptCore library.+(e.g. in JavaScriptCore version 1.8.3 this is 1.)++This function is in the library, so it represents the JavaScriptCore library+your code is running against. Contrast with the 'GI.JavaScriptCore.Constants.MAJOR_VERSION'+macro, which represents the major version of the JavaScriptCore headers you+have included when compiling your code.+-}+getMajorVersion ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Word32+    {- ^ __Returns:__ the major version number of the JavaScriptCore library -}+getMajorVersion  = liftIO $ do+    result <- jsc_get_major_version+    return result+++

@@ -0,0 +1,51 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects+    (     module GI.JavaScriptCore.Objects.Class  ,+    module GI.JavaScriptCore.Objects.Context,+    module GI.JavaScriptCore.Objects.Exception,+    module GI.JavaScriptCore.Objects.Value  ,+    module GI.JavaScriptCore.Objects.VirtualMachine,+    module GI.JavaScriptCore.Objects.WeakValue,+++    ) where++import GI.JavaScriptCore.Objects.Class+import GI.JavaScriptCore.Objects.Context+import GI.JavaScriptCore.Objects.Exception+import GI.JavaScriptCore.Objects.Value+import GI.JavaScriptCore.Objects.VirtualMachine+import GI.JavaScriptCore.Objects.WeakValue++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++

@@ -0,0 +1,772 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.Class+    ( ++-- * Exported types+    Class(..)                               ,+    IsClass                                 ,+    toClass                                 ,+    noClass                                 ,+++ -- * Methods+-- ** addConstructor #method:addConstructor#++#if ENABLE_OVERLOADING+    ClassAddConstructorMethodInfo           ,+#endif+    classAddConstructor                     ,+++-- ** addConstructorVariadic #method:addConstructorVariadic#++#if ENABLE_OVERLOADING+    ClassAddConstructorVariadicMethodInfo   ,+#endif+    classAddConstructorVariadic             ,+++-- ** addMethod #method:addMethod#++#if ENABLE_OVERLOADING+    ClassAddMethodMethodInfo                ,+#endif+    classAddMethod                          ,+++-- ** addMethodVariadic #method:addMethodVariadic#++#if ENABLE_OVERLOADING+    ClassAddMethodVariadicMethodInfo        ,+#endif+    classAddMethodVariadic                  ,+++-- ** addProperty #method:addProperty#++#if ENABLE_OVERLOADING+    ClassAddPropertyMethodInfo              ,+#endif+    classAddProperty                        ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    ClassGetNameMethodInfo                  ,+#endif+    classGetName                            ,+++-- ** getParent #method:getParent#++#if ENABLE_OVERLOADING+    ClassGetParentMethodInfo                ,+#endif+    classGetParent                          ,+++++ -- * Properties+-- ** context #attr:context#+{- | The 'GI.JavaScriptCore.Objects.Context.Context' in which the class was registered.+-}+#if ENABLE_OVERLOADING+    ClassContextPropertyInfo                ,+#endif+#if ENABLE_OVERLOADING+    classContext                            ,+#endif+    constructClassContext                   ,+    getClassContext                         ,+++-- ** name #attr:name#+{- | The name of the class.+-}+#if ENABLE_OVERLOADING+    ClassNamePropertyInfo                   ,+#endif+#if ENABLE_OVERLOADING+    className                               ,+#endif+    constructClassName                      ,+    getClassName                            ,+++-- ** parent #attr:parent#+{- | The parent class or 'Nothing' in case of final classes.+-}+#if ENABLE_OVERLOADING+    ClassParentPropertyInfo                 ,+#endif+#if ENABLE_OVERLOADING+    classParent                             ,+#endif+    constructClassParent                    ,+    getClassParent                          ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GObject.Callbacks as GObject.Callbacks+import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value++-- | Memory-managed wrapper type.+newtype Class = Class (ManagedPtr Class)+foreign import ccall "jsc_class_get_type"+    c_jsc_class_get_type :: IO GType++instance GObject Class where+    gobjectType = c_jsc_class_get_type+    ++-- | Type class for types which can be safely cast to `Class`, for instance with `toClass`.+class (GObject o, O.IsDescendantOf Class o) => IsClass o+instance (GObject o, O.IsDescendantOf Class o) => IsClass o++instance O.HasParentTypes Class+type instance O.ParentTypes Class = '[GObject.Object.Object]++-- | Cast to `Class`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toClass :: (MonadIO m, IsClass o) => o -> m Class+toClass = liftIO . unsafeCastTo Class++-- | A convenience alias for `Nothing` :: `Maybe` `Class`.+noClass :: Maybe Class+noClass = Nothing++#if ENABLE_OVERLOADING+type family ResolveClassMethod (t :: Symbol) (o :: *) :: * where+    ResolveClassMethod "addConstructor" o = ClassAddConstructorMethodInfo+    ResolveClassMethod "addConstructorVariadic" o = ClassAddConstructorVariadicMethodInfo+    ResolveClassMethod "addMethod" o = ClassAddMethodMethodInfo+    ResolveClassMethod "addMethodVariadic" o = ClassAddMethodVariadicMethodInfo+    ResolveClassMethod "addProperty" o = ClassAddPropertyMethodInfo+    ResolveClassMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveClassMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveClassMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveClassMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveClassMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveClassMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveClassMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveClassMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveClassMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveClassMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveClassMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveClassMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveClassMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveClassMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveClassMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveClassMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveClassMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveClassMethod "getName" o = ClassGetNameMethodInfo+    ResolveClassMethod "getParent" o = ClassGetParentMethodInfo+    ResolveClassMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveClassMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveClassMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveClassMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveClassMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveClassMethod t Class, O.MethodInfo info Class p) => OL.IsLabel t (Class -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "context"+   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Get the value of the “@context@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' class #context+@+-}+getClassContext :: (MonadIO m, IsClass o) => o -> m (Maybe JavaScriptCore.Context.Context)+getClassContext obj = liftIO $ B.Properties.getObjectPropertyObject obj "context" JavaScriptCore.Context.Context++{- |+Construct a `GValueConstruct` with valid value for the “@context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructClassContext :: (IsClass o, JavaScriptCore.Context.IsContext a) => a -> IO (GValueConstruct o)+constructClassContext val = B.Properties.constructObjectPropertyObject "context" (Just val)++#if ENABLE_OVERLOADING+data ClassContextPropertyInfo+instance AttrInfo ClassContextPropertyInfo where+    type AttrAllowedOps ClassContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ClassContextPropertyInfo = JavaScriptCore.Context.IsContext+    type AttrBaseTypeConstraint ClassContextPropertyInfo = IsClass+    type AttrGetType ClassContextPropertyInfo = (Maybe JavaScriptCore.Context.Context)+    type AttrLabel ClassContextPropertyInfo = "context"+    type AttrOrigin ClassContextPropertyInfo = Class+    attrGet _ = getClassContext+    attrSet _ = undefined+    attrConstruct _ = constructClassContext+    attrClear _ = undefined+#endif++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@name@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' class #name+@+-}+getClassName :: (MonadIO m, IsClass o) => o -> m T.Text+getClassName obj = liftIO $ checkUnexpectedNothing "getClassName" $ B.Properties.getObjectPropertyString obj "name"++{- |+Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructClassName :: (IsClass o) => T.Text -> IO (GValueConstruct o)+constructClassName val = B.Properties.constructObjectPropertyString "name" (Just val)++#if ENABLE_OVERLOADING+data ClassNamePropertyInfo+instance AttrInfo ClassNamePropertyInfo where+    type AttrAllowedOps ClassNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ClassNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ClassNamePropertyInfo = IsClass+    type AttrGetType ClassNamePropertyInfo = T.Text+    type AttrLabel ClassNamePropertyInfo = "name"+    type AttrOrigin ClassNamePropertyInfo = Class+    attrGet _ = getClassName+    attrSet _ = undefined+    attrConstruct _ = constructClassName+    attrClear _ = undefined+#endif++-- VVV Prop "parent"+   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@parent@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' class #parent+@+-}+getClassParent :: (MonadIO m, IsClass o) => o -> m Class+getClassParent obj = liftIO $ checkUnexpectedNothing "getClassParent" $ B.Properties.getObjectPropertyObject obj "parent" Class++{- |+Construct a `GValueConstruct` with valid value for the “@parent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructClassParent :: (IsClass o, IsClass a) => a -> IO (GValueConstruct o)+constructClassParent val = B.Properties.constructObjectPropertyObject "parent" (Just val)++#if ENABLE_OVERLOADING+data ClassParentPropertyInfo+instance AttrInfo ClassParentPropertyInfo where+    type AttrAllowedOps ClassParentPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ClassParentPropertyInfo = IsClass+    type AttrBaseTypeConstraint ClassParentPropertyInfo = IsClass+    type AttrGetType ClassParentPropertyInfo = Class+    type AttrLabel ClassParentPropertyInfo = "parent"+    type AttrOrigin ClassParentPropertyInfo = Class+    attrGet _ = getClassParent+    attrSet _ = undefined+    attrConstruct _ = constructClassParent+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Class+type instance O.AttributeList Class = ClassAttributeList+type ClassAttributeList = ('[ '("context", ClassContextPropertyInfo), '("name", ClassNamePropertyInfo), '("parent", ClassParentPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+classContext :: AttrLabelProxy "context"+classContext = AttrLabelProxy++className :: AttrLabelProxy "name"+className = AttrLabelProxy++classParent :: AttrLabelProxy "parent"+classParent = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Class = ClassSignalList+type ClassSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Class::add_constructor_variadic+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the constructor name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to create an instance of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the constructor return value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_add_constructor_variadic" jsc_class_add_constructor_variadic :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Add a constructor to /@jscClass@/. If /@name@/ is 'Nothing', the class name will be used. When \<function>new\<\/function>+is used with the constructor or @/jsc_value_constructor_call()/@ is called, /@callback@/ is invoked receiving+a 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s as arguments and /@userData@/ as the last parameter. When the constructor object+is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with /@userData@/ as parameter.++This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use+'GI.JavaScriptCore.Objects.Context.contextSetValue' to make the constructor available in the global object.++Note that the value returned by /@callback@/ is adopted by /@jscClass@/, and the 'GI.GLib.Callbacks.DestroyNotify' passed to+'GI.JavaScriptCore.Objects.Context.contextRegisterClass' is responsible for disposing of it.+-}+classAddConstructorVariadic ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> Maybe (T.Text)+    {- ^ /@name@/: the constructor name or 'Nothing' -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to create an instance of /@jscClass@/ -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the constructor return value -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the class constructor. -}+classAddConstructorVariadic jscClass name callback returnType = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    result <- jsc_class_add_constructor_variadic jscClass' maybeName callback' userData destroyNotify returnType'+    checkUnexpectedReturnNULL "classAddConstructorVariadic" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr jscClass+    freeMem maybeName+    return result'++#if ENABLE_OVERLOADING+data ClassAddConstructorVariadicMethodInfo+instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.MethodInfo ClassAddConstructorVariadicMethodInfo a signature where+    overloadedMethod _ = classAddConstructorVariadic++#endif++-- method Class::add_constructor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the constructor name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to create an instance of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the constructor return value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GType<!-- -->s, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_add_constructorv" jsc_class_add_constructorv :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr CGType ->                           -- parameter_types : TCArray False (-1) 6 (TBasicType TGType)+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Add a constructor to /@jscClass@/. If /@name@/ is 'Nothing', the class name will be used. When \<function>new\<\/function>+is used with the constructor or @/jsc_value_constructor_call()/@ is called, /@callback@/ is invoked receiving the+parameters and /@userData@/ as the last parameter. When the constructor object is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context,+/@destroyNotify@/ is called with /@userData@/ as parameter.++This function creates the constructor, which needs to be added to an object as a property to be able to use it. Use+'GI.JavaScriptCore.Objects.Context.contextSetValue' to make the constructor available in the global object.++Note that the value returned by /@callback@/ is adopted by /@jscClass@/, and the 'GI.GLib.Callbacks.DestroyNotify' passed to+'GI.JavaScriptCore.Objects.Context.contextRegisterClass' is responsible for disposing of it.+-}+classAddConstructor ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> Maybe (T.Text)+    {- ^ /@name@/: the constructor name or 'Nothing' -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to create an instance of /@jscClass@/ -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the constructor return value -}+    -> Maybe ([GType])+    {- ^ /@parameterTypes@/: a list of 'GType'\<!-- -->s, one for each parameter, or 'Nothing' -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the class constructor. -}+classAddConstructor jscClass name callback returnType parameterTypes = liftIO $ do+    let nParameters = case parameterTypes of+            Nothing -> 0+            Just jParameterTypes -> fromIntegral $ length jParameterTypes+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    maybeParameterTypes <- case parameterTypes of+        Nothing -> return nullPtr+        Just jParameterTypes -> do+            jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes+            return jParameterTypes'+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    result <- jsc_class_add_constructorv jscClass' maybeName callback' userData destroyNotify returnType' nParameters maybeParameterTypes+    checkUnexpectedReturnNULL "classAddConstructor" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr jscClass+    freeMem maybeName+    freeMem maybeParameterTypes+    return result'++#if ENABLE_OVERLOADING+data ClassAddConstructorMethodInfo+instance (signature ~ (Maybe (T.Text) -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m JavaScriptCore.Value.Value), MonadIO m, IsClass a) => O.MethodInfo ClassAddConstructorMethodInfo a signature where+    overloadedMethod _ = classAddConstructor++#endif++-- method Class::add_method_variadic+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to invoke method @name of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the method return value, or %G_TYPE_NONE if the method is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_add_method_variadic" jsc_class_add_method_variadic :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    IO ()++{- |+Add method with /@name@/ to /@jscClass@/. When the method is called by JavaScript or @/jsc_value_object_invoke_method()/@,+/@callback@/ is called receiving the class instance as first parameter, followed by a 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s+with the method arguments and then /@userData@/ as last parameter. When the method is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context,+/@destroyNotify@/ is called with /@userData@/ as parameter.++Note that the value returned by /@callback@/ must be transfer full. In case of non-refcounted boxed types, you should use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter.+-}+classAddMethodVariadic ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> T.Text+    {- ^ /@name@/: the method name -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to invoke method /@name@/ of /@jscClass@/ -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the method return value, or @/G_TYPE_NONE/@ if the method is void. -}+    -> m ()+classAddMethodVariadic jscClass name callback returnType = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    name' <- textToCString name+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    jsc_class_add_method_variadic jscClass' name' callback' userData destroyNotify returnType'+    touchManagedPtr jscClass+    freeMem name'+    return ()++#if ENABLE_OVERLOADING+data ClassAddMethodVariadicMethodInfo+instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddMethodVariadicMethodInfo a signature where+    overloadedMethod _ = classAddMethodVariadic++#endif++-- method Class::add_method+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to invoke method @name of @jsc_class", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the method return value, or %G_TYPE_NONE if the method is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameter types to follow or 0 if the method doesn't receive parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GType<!-- -->s, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameter types to follow or 0 if the method doesn't receive parameters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_add_methodv" jsc_class_add_methodv :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr CGType ->                           -- parameter_types : TCArray False (-1) 6 (TBasicType TGType)+    IO ()++{- |+Add method with /@name@/ to /@jscClass@/. When the method is called by JavaScript or @/jsc_value_object_invoke_method()/@,+/@callback@/ is called receiving the class instance as first parameter, followed by the method parameters and then+/@userData@/ as last parameter. When the method is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with+/@userData@/ as parameter.++Note that the value returned by /@callback@/ must be transfer full. In case of non-refcounted boxed types, you should use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter.+-}+classAddMethod ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> T.Text+    {- ^ /@name@/: the method name -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback' to be called to invoke method /@name@/ of /@jscClass@/ -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the method return value, or @/G_TYPE_NONE/@ if the method is void. -}+    -> Maybe ([GType])+    {- ^ /@parameterTypes@/: a list of 'GType'\<!-- -->s, one for each parameter, or 'Nothing' -}+    -> m ()+classAddMethod jscClass name callback returnType parameterTypes = liftIO $ do+    let nParameters = case parameterTypes of+            Nothing -> 0+            Just jParameterTypes -> fromIntegral $ length jParameterTypes+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    name' <- textToCString name+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    maybeParameterTypes <- case parameterTypes of+        Nothing -> return nullPtr+        Just jParameterTypes -> do+            jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes+            return jParameterTypes'+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    jsc_class_add_methodv jscClass' name' callback' userData destroyNotify returnType' nParameters maybeParameterTypes+    touchManagedPtr jscClass+    freeMem name'+    freeMem maybeParameterTypes+    return ()++#if ENABLE_OVERLOADING+data ClassAddMethodMethodInfo+instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> GType -> Maybe ([GType]) -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddMethodMethodInfo a signature where+    overloadedMethod _ = classAddMethod++#endif++-- method Class::add_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the property value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "getter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to get the property value", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to set the property value", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @getter and @setter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_add_property" jsc_class_add_property :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- name : TBasicType TUTF8+    CGType ->                               -- property_type : TBasicType TGType+    FunPtr GObject.Callbacks.C_Callback ->  -- getter : TInterface (Name {namespace = "GObject", name = "Callback"})+    FunPtr GObject.Callbacks.C_Callback ->  -- setter : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Add a property with /@name@/ to /@jscClass@/. When the property value needs to be getted, /@getter@/ is called+receiving the the class instance as first parameter and /@userData@/ as last parameter. When the property+value needs to be set, /@setter@/ is called receiving the the class instance as first parameter, followed+by the value to be set and then /@userData@/ as the last parameter. When the property is cleared in the+'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with /@userData@/ as parameter.++Note that the value returned by /@getter@/ must be transfer full. In case of non-refcounted boxed types, you should use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as the instance parameter.+-}+classAddProperty ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> GType+    {- ^ /@propertyType@/: the 'GType' of the property value -}+    -> Maybe (GObject.Callbacks.Callback)+    {- ^ /@getter@/: a 'GI.GObject.Callbacks.Callback' to be called to get the property value -}+    -> Maybe (GObject.Callbacks.Callback)+    {- ^ /@setter@/: a 'GI.GObject.Callbacks.Callback' to be called to set the property value -}+    -> m ()+classAddProperty jscClass name propertyType getter setter = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    name' <- textToCString name+    let propertyType' = gtypeToCGType propertyType+    maybeGetter <- case getter of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGetter -> do+            ptrgetter <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))+            jGetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrgetter) jGetter)+            poke ptrgetter jGetter'+            return jGetter'+    maybeSetter <- case setter of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jSetter -> do+            jSetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing jSetter)+            return jSetter'+    let userData = castFunPtrToPtr maybeSetter+    let destroyNotify = safeFreeFunPtrPtr+    jsc_class_add_property jscClass' name' propertyType' maybeGetter maybeSetter userData destroyNotify+    touchManagedPtr jscClass+    freeMem name'+    return ()++#if ENABLE_OVERLOADING+data ClassAddPropertyMethodInfo+instance (signature ~ (T.Text -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsClass a) => O.MethodInfo ClassAddPropertyMethodInfo a signature where+    overloadedMethod _ = classAddProperty++#endif++-- method Class::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a @JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_get_name" jsc_class_get_name :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    IO CString++{- |+Get the class name of /@jscClass@/+-}+classGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a /@jSCClass@/ -}+    -> m T.Text+    {- ^ __Returns:__ the name of /@jscClass@/ -}+classGetName jscClass = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    result <- jsc_class_get_name jscClass'+    checkUnexpectedReturnNULL "classGetName" result+    result' <- cstringToText result+    touchManagedPtr jscClass+    return result'++#if ENABLE_OVERLOADING+data ClassGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsClass a) => O.MethodInfo ClassGetNameMethodInfo a signature where+    overloadedMethod _ = classGetName++#endif++-- method Class::get_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a @JSCClass", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Class"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_class_get_parent" jsc_class_get_parent :: +    Ptr Class ->                            -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    IO (Ptr Class)++{- |+Get the parent class of /@jscClass@/+-}+classGetParent ::+    (B.CallStack.HasCallStack, MonadIO m, IsClass a) =>+    a+    {- ^ /@jscClass@/: a /@jSCClass@/ -}+    -> m Class+    {- ^ __Returns:__ the parent class of /@jscClass@/ -}+classGetParent jscClass = liftIO $ do+    jscClass' <- unsafeManagedPtrCastPtr jscClass+    result <- jsc_class_get_parent jscClass'+    checkUnexpectedReturnNULL "classGetParent" result+    result' <- (newObject Class) result+    touchManagedPtr jscClass+    return result'++#if ENABLE_OVERLOADING+data ClassGetParentMethodInfo+instance (signature ~ (m Class), MonadIO m, IsClass a) => O.MethodInfo ClassGetParentMethodInfo a signature where+    overloadedMethod _ = classGetParent++#endif++

@@ -0,0 +1,59 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.Class 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype Class = Class (ManagedPtr Class)+instance GObject Class where+class (GObject o, O.IsDescendantOf Class o) => IsClass o+instance (GObject o, O.IsDescendantOf Class o) => IsClass o+instance O.HasParentTypes Class+#if ENABLE_OVERLOADING+data ClassContextPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ClassNamePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ClassParentPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ClassAddConstructorVariadicMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassAddConstructorMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassAddMethodVariadicMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassAddMethodMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassAddPropertyMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ClassGetParentMethodInfo+#endif

@@ -0,0 +1,1175 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.Context+    ( ++-- * Exported types+    Context(..)                             ,+    IsContext                               ,+    toContext                               ,+    noContext                               ,+++ -- * Methods+-- ** checkSyntax #method:checkSyntax#++#if ENABLE_OVERLOADING+    ContextCheckSyntaxMethodInfo            ,+#endif+    contextCheckSyntax                      ,+++-- ** clearException #method:clearException#++#if ENABLE_OVERLOADING+    ContextClearExceptionMethodInfo         ,+#endif+    contextClearException                   ,+++-- ** evaluate #method:evaluate#++#if ENABLE_OVERLOADING+    ContextEvaluateMethodInfo               ,+#endif+    contextEvaluate                         ,+++-- ** evaluateInObject #method:evaluateInObject#++#if ENABLE_OVERLOADING+    ContextEvaluateInObjectMethodInfo       ,+#endif+    contextEvaluateInObject                 ,+++-- ** evaluateWithSourceUri #method:evaluateWithSourceUri#++#if ENABLE_OVERLOADING+    ContextEvaluateWithSourceUriMethodInfo  ,+#endif+    contextEvaluateWithSourceUri            ,+++-- ** getCurrent #method:getCurrent#++    contextGetCurrent                       ,+++-- ** getException #method:getException#++#if ENABLE_OVERLOADING+    ContextGetExceptionMethodInfo           ,+#endif+    contextGetException                     ,+++-- ** getGlobalObject #method:getGlobalObject#++#if ENABLE_OVERLOADING+    ContextGetGlobalObjectMethodInfo        ,+#endif+    contextGetGlobalObject                  ,+++-- ** getValue #method:getValue#++#if ENABLE_OVERLOADING+    ContextGetValueMethodInfo               ,+#endif+    contextGetValue                         ,+++-- ** getVirtualMachine #method:getVirtualMachine#++#if ENABLE_OVERLOADING+    ContextGetVirtualMachineMethodInfo      ,+#endif+    contextGetVirtualMachine                ,+++-- ** new #method:new#++    contextNew                              ,+++-- ** newWithVirtualMachine #method:newWithVirtualMachine#++    contextNewWithVirtualMachine            ,+++-- ** popExceptionHandler #method:popExceptionHandler#++#if ENABLE_OVERLOADING+    ContextPopExceptionHandlerMethodInfo    ,+#endif+    contextPopExceptionHandler              ,+++-- ** pushExceptionHandler #method:pushExceptionHandler#++#if ENABLE_OVERLOADING+    ContextPushExceptionHandlerMethodInfo   ,+#endif+    contextPushExceptionHandler             ,+++-- ** registerClass #method:registerClass#++#if ENABLE_OVERLOADING+    ContextRegisterClassMethodInfo          ,+#endif+    contextRegisterClass                    ,+++-- ** setValue #method:setValue#++#if ENABLE_OVERLOADING+    ContextSetValueMethodInfo               ,+#endif+    contextSetValue                         ,+++-- ** throw #method:throw#++#if ENABLE_OVERLOADING+    ContextThrowMethodInfo                  ,+#endif+    contextThrow                            ,+++-- ** throwException #method:throwException#++#if ENABLE_OVERLOADING+    ContextThrowExceptionMethodInfo         ,+#endif+    contextThrowException                   ,+++-- ** throwWithName #method:throwWithName#++#if ENABLE_OVERLOADING+    ContextThrowWithNameMethodInfo          ,+#endif+    contextThrowWithName                    ,+++++ -- * Properties+-- ** virtualMachine #attr:virtualMachine#+{- | The 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' in which the context was created.+-}+#if ENABLE_OVERLOADING+    ContextVirtualMachinePropertyInfo       ,+#endif+    constructContextVirtualMachine          ,+#if ENABLE_OVERLOADING+    contextVirtualMachine                   ,+#endif+    getContextVirtualMachine                ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GObject.Objects.Object as GObject.Object+import qualified GI.JavaScriptCore.Callbacks as JavaScriptCore.Callbacks+import {-# SOURCE #-} qualified GI.JavaScriptCore.Enums as JavaScriptCore.Enums+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Exception as JavaScriptCore.Exception+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.VirtualMachine as JavaScriptCore.VirtualMachine+import {-# SOURCE #-} qualified GI.JavaScriptCore.Structs.ClassVTable as JavaScriptCore.ClassVTable++-- | Memory-managed wrapper type.+newtype Context = Context (ManagedPtr Context)+foreign import ccall "jsc_context_get_type"+    c_jsc_context_get_type :: IO GType++instance GObject Context where+    gobjectType = c_jsc_context_get_type+    ++-- | Type class for types which can be safely cast to `Context`, for instance with `toContext`.+class (GObject o, O.IsDescendantOf Context o) => IsContext o+instance (GObject o, O.IsDescendantOf Context o) => IsContext o++instance O.HasParentTypes Context+type instance O.ParentTypes Context = '[GObject.Object.Object]++-- | Cast to `Context`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toContext :: (MonadIO m, IsContext o) => o -> m Context+toContext = liftIO . unsafeCastTo Context++-- | A convenience alias for `Nothing` :: `Maybe` `Context`.+noContext :: Maybe Context+noContext = Nothing++#if ENABLE_OVERLOADING+type family ResolveContextMethod (t :: Symbol) (o :: *) :: * where+    ResolveContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveContextMethod "checkSyntax" o = ContextCheckSyntaxMethodInfo+    ResolveContextMethod "clearException" o = ContextClearExceptionMethodInfo+    ResolveContextMethod "evaluate" o = ContextEvaluateMethodInfo+    ResolveContextMethod "evaluateInObject" o = ContextEvaluateInObjectMethodInfo+    ResolveContextMethod "evaluateWithSourceUri" o = ContextEvaluateWithSourceUriMethodInfo+    ResolveContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveContextMethod "popExceptionHandler" o = ContextPopExceptionHandlerMethodInfo+    ResolveContextMethod "pushExceptionHandler" o = ContextPushExceptionHandlerMethodInfo+    ResolveContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveContextMethod "registerClass" o = ContextRegisterClassMethodInfo+    ResolveContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveContextMethod "throw" o = ContextThrowMethodInfo+    ResolveContextMethod "throwException" o = ContextThrowExceptionMethodInfo+    ResolveContextMethod "throwWithName" o = ContextThrowWithNameMethodInfo+    ResolveContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveContextMethod "getException" o = ContextGetExceptionMethodInfo+    ResolveContextMethod "getGlobalObject" o = ContextGetGlobalObjectMethodInfo+    ResolveContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveContextMethod "getValue" o = ContextGetValueMethodInfo+    ResolveContextMethod "getVirtualMachine" o = ContextGetVirtualMachineMethodInfo+    ResolveContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveContextMethod "setValue" o = ContextSetValueMethodInfo+    ResolveContextMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveContextMethod t Context, O.MethodInfo info Context p) => OL.IsLabel t (Context -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "virtual-machine"+   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@virtual-machine@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' context #virtualMachine+@+-}+getContextVirtualMachine :: (MonadIO m, IsContext o) => o -> m JavaScriptCore.VirtualMachine.VirtualMachine+getContextVirtualMachine obj = liftIO $ checkUnexpectedNothing "getContextVirtualMachine" $ B.Properties.getObjectPropertyObject obj "virtual-machine" JavaScriptCore.VirtualMachine.VirtualMachine++{- |+Construct a `GValueConstruct` with valid value for the “@virtual-machine@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructContextVirtualMachine :: (IsContext o, JavaScriptCore.VirtualMachine.IsVirtualMachine a) => a -> IO (GValueConstruct o)+constructContextVirtualMachine val = B.Properties.constructObjectPropertyObject "virtual-machine" (Just val)++#if ENABLE_OVERLOADING+data ContextVirtualMachinePropertyInfo+instance AttrInfo ContextVirtualMachinePropertyInfo where+    type AttrAllowedOps ContextVirtualMachinePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ContextVirtualMachinePropertyInfo = JavaScriptCore.VirtualMachine.IsVirtualMachine+    type AttrBaseTypeConstraint ContextVirtualMachinePropertyInfo = IsContext+    type AttrGetType ContextVirtualMachinePropertyInfo = JavaScriptCore.VirtualMachine.VirtualMachine+    type AttrLabel ContextVirtualMachinePropertyInfo = "virtual-machine"+    type AttrOrigin ContextVirtualMachinePropertyInfo = Context+    attrGet _ = getContextVirtualMachine+    attrSet _ = undefined+    attrConstruct _ = constructContextVirtualMachine+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Context+type instance O.AttributeList Context = ContextAttributeList+type ContextAttributeList = ('[ '("virtualMachine", ContextVirtualMachinePropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+contextVirtualMachine :: AttrLabelProxy "virtualMachine"+contextVirtualMachine = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Context = ContextSignalList+type ContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Context::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_new" jsc_context_new :: +    IO (Ptr Context)++{- |+Create a new 'GI.JavaScriptCore.Objects.Context.Context'. The context is created in a new 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'.+Use 'GI.JavaScriptCore.Objects.Context.contextNewWithVirtualMachine' to create a new 'GI.JavaScriptCore.Objects.Context.Context' in an+existing 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'.+-}+contextNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m Context+    {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.Context.Context'. -}+contextNew  = liftIO $ do+    result <- jsc_context_new+    checkUnexpectedReturnNULL "contextNew" result+    result' <- (wrapObject Context) result+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Context::new_with_virtual_machine+-- method type : Constructor+-- Args : [Arg {argCName = "vm", argType = TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCVirtualMachine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_new_with_virtual_machine" jsc_context_new_with_virtual_machine :: +    Ptr JavaScriptCore.VirtualMachine.VirtualMachine -> -- vm : TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"})+    IO (Ptr Context)++{- |+Create a new 'GI.JavaScriptCore.Objects.Context.Context' in /@virtualMachine@/.+-}+contextNewWithVirtualMachine ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.VirtualMachine.IsVirtualMachine a) =>+    a+    {- ^ /@vm@/: a 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' -}+    -> m Context+    {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.Context.Context'. -}+contextNewWithVirtualMachine vm = liftIO $ do+    vm' <- unsafeManagedPtrCastPtr vm+    result <- jsc_context_new_with_virtual_machine vm'+    checkUnexpectedReturnNULL "contextNewWithVirtualMachine" result+    result' <- (wrapObject Context) result+    touchManagedPtr vm+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Context::check_syntax+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCCheckSyntaxMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #JSCException, or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxResult"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_check_syntax" jsc_context_check_syntax :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- code : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    CUInt ->                                -- mode : TInterface (Name {namespace = "JavaScriptCore", name = "CheckSyntaxMode"})+    CString ->                              -- uri : TBasicType TUTF8+    Word32 ->                               -- line_number : TBasicType TUInt+    Ptr (Ptr JavaScriptCore.Exception.Exception) -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CUInt++{- |+Check the given /@code@/ in /@context@/ for syntax errors. The /@lineNumber@/ is the starting line number in /@uri@/;+the value is one-based so the first line is 1. /@uri@/ and /@lineNumber@/ are only used to fill the /@exception@/.+In case of errors /@exception@/ will be set to a new 'GI.JavaScriptCore.Objects.Exception.Exception' with the details. You can pass 'Nothing' to+/@exception@/ to ignore the error details.+-}+contextCheckSyntax ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@code@/: a JavaScript script to check -}+    -> Int64+    {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -}+    -> JavaScriptCore.Enums.CheckSyntaxMode+    {- ^ /@mode@/: a 'GI.JavaScriptCore.Enums.CheckSyntaxMode' -}+    -> T.Text+    {- ^ /@uri@/: the source URI -}+    -> Word32+    {- ^ /@lineNumber@/: the starting line number -}+    -> m ((JavaScriptCore.Enums.CheckSyntaxResult, JavaScriptCore.Exception.Exception))+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Enums.CheckSyntaxResult' -}+contextCheckSyntax context code length_ mode uri lineNumber = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    code' <- textToCString code+    let mode' = (fromIntegral . fromEnum) mode+    uri' <- textToCString uri+    exception <- allocMem :: IO (Ptr (Ptr JavaScriptCore.Exception.Exception))+    result <- jsc_context_check_syntax context' code' length_ mode' uri' lineNumber exception+    let result' = (toEnum . fromIntegral) result+    exception' <- peek exception+    exception'' <- (wrapObject JavaScriptCore.Exception.Exception) exception'+    touchManagedPtr context+    freeMem code'+    freeMem uri'+    freeMem exception+    return (result', exception'')++#if ENABLE_OVERLOADING+data ContextCheckSyntaxMethodInfo+instance (signature ~ (T.Text -> Int64 -> JavaScriptCore.Enums.CheckSyntaxMode -> T.Text -> Word32 -> m ((JavaScriptCore.Enums.CheckSyntaxResult, JavaScriptCore.Exception.Exception))), MonadIO m, IsContext a) => O.MethodInfo ContextCheckSyntaxMethodInfo a signature where+    overloadedMethod _ = contextCheckSyntax++#endif++-- method Context::clear_exception+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_clear_exception" jsc_context_clear_exception :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO ()++{- |+Clear the uncaught exception in /@context@/ if any.+-}+contextClearException ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m ()+contextClearException context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    jsc_context_clear_exception context'+    touchManagedPtr context+    return ()++#if ENABLE_OVERLOADING+data ContextClearExceptionMethodInfo+instance (signature ~ (m ()), MonadIO m, IsContext a) => O.MethodInfo ContextClearExceptionMethodInfo a signature where+    overloadedMethod _ = contextClearException++#endif++-- method Context::evaluate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_evaluate" jsc_context_evaluate :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- code : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Evaluate /@code@/ in /@context@/.+-}+contextEvaluate ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@code@/: a JavaScript script to evaluate -}+    -> Int64+    {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -}+contextEvaluate context code length_ = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    code' <- textToCString code+    result <- jsc_context_evaluate context' code' length_+    checkUnexpectedReturnNULL "contextEvaluate" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr context+    freeMem code'+    return result'++#if ENABLE_OVERLOADING+data ContextEvaluateMethodInfo+instance (signature ~ (T.Text -> Int64 -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextEvaluateMethodInfo a signature where+    overloadedMethod _ = contextEvaluate++#endif++-- method Context::evaluate_in_object+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an object instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #JSCClass or %NULL to use the default", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #JSCValue.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_evaluate_in_object" jsc_context_evaluate_in_object :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- code : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    Ptr () ->                               -- object_instance : TBasicType TPtr+    Ptr JavaScriptCore.Class.Class ->       -- object_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    CString ->                              -- uri : TBasicType TUTF8+    Word32 ->                               -- line_number : TBasicType TUInt+    Ptr (Ptr JavaScriptCore.Value.Value) -> -- object : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Evaluate /@code@/ and create an new object where symbols defined in /@code@/ will be added as properties,+instead of being added to /@context@/ global object. The new object is returned as /@object@/ parameter.+Similar to how 'GI.JavaScriptCore.Objects.Value.valueNewObject' works, if /@objectInstance@/ is not 'Nothing' /@objectClass@/ must be provided too.+The /@lineNumber@/ is the starting line number in /@uri@/; the value is one-based so the first line is 1.+/@uri@/ and /@lineNumber@/ will be shown in exceptions and they don\'t affect the behavior of the script.+-}+contextEvaluateInObject ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@code@/: a JavaScript script to evaluate -}+    -> Int64+    {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -}+    -> Ptr ()+    {- ^ /@objectInstance@/: an object instance -}+    -> Maybe (b)+    {- ^ /@objectClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' or 'Nothing' to use the default -}+    -> T.Text+    {- ^ /@uri@/: the source URI -}+    -> Word32+    {- ^ /@lineNumber@/: the starting line number -}+    -> m ((JavaScriptCore.Value.Value, JavaScriptCore.Value.Value))+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -}+contextEvaluateInObject context code length_ objectInstance objectClass uri lineNumber = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    code' <- textToCString code+    maybeObjectClass <- case objectClass of+        Nothing -> return nullPtr+        Just jObjectClass -> do+            jObjectClass' <- unsafeManagedPtrCastPtr jObjectClass+            return jObjectClass'+    uri' <- textToCString uri+    object <- allocMem :: IO (Ptr (Ptr JavaScriptCore.Value.Value))+    result <- jsc_context_evaluate_in_object context' code' length_ objectInstance maybeObjectClass uri' lineNumber object+    checkUnexpectedReturnNULL "contextEvaluateInObject" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    object' <- peek object+    object'' <- (wrapObject JavaScriptCore.Value.Value) object'+    touchManagedPtr context+    whenJust objectClass touchManagedPtr+    freeMem code'+    freeMem uri'+    freeMem object+    return (result', object'')++#if ENABLE_OVERLOADING+data ContextEvaluateInObjectMethodInfo+instance (signature ~ (T.Text -> Int64 -> Ptr () -> Maybe (b) -> T.Text -> Word32 -> m ((JavaScriptCore.Value.Value, JavaScriptCore.Value.Value))), MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => O.MethodInfo ContextEvaluateInObjectMethodInfo a signature where+    overloadedMethod _ = contextEvaluateInObject++#endif++-- method Context::evaluate_with_source_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a JavaScript script to evaluate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @code, or -1 if @code is a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source URI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_number", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the starting line number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_evaluate_with_source_uri" jsc_context_evaluate_with_source_uri :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- code : TBasicType TUTF8+    Int64 ->                                -- length : TBasicType TInt64+    CString ->                              -- uri : TBasicType TUTF8+    Word32 ->                               -- line_number : TBasicType TUInt+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Evaluate /@code@/ in /@context@/ using /@uri@/ as the source URI. The /@lineNumber@/ is the starting line number+in /@uri@/; the value is one-based so the first line is 1. /@uri@/ and /@lineNumber@/ will be shown in exceptions and+they don\'t affect the behavior of the script.+-}+contextEvaluateWithSourceUri ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@code@/: a JavaScript script to evaluate -}+    -> Int64+    {- ^ /@length@/: length of /@code@/, or -1 if /@code@/ is a nul-terminated string -}+    -> T.Text+    {- ^ /@uri@/: the source URI -}+    -> Word32+    {- ^ /@lineNumber@/: the starting line number -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' representing the last value generated by the script. -}+contextEvaluateWithSourceUri context code length_ uri lineNumber = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    code' <- textToCString code+    uri' <- textToCString uri+    result <- jsc_context_evaluate_with_source_uri context' code' length_ uri' lineNumber+    checkUnexpectedReturnNULL "contextEvaluateWithSourceUri" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr context+    freeMem code'+    freeMem uri'+    return result'++#if ENABLE_OVERLOADING+data ContextEvaluateWithSourceUriMethodInfo+instance (signature ~ (T.Text -> Int64 -> T.Text -> Word32 -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextEvaluateWithSourceUriMethodInfo a signature where+    overloadedMethod _ = contextEvaluateWithSourceUri++#endif++-- method Context::get_exception+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_get_exception" jsc_context_get_exception :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO (Ptr JavaScriptCore.Exception.Exception)++{- |+Get the last unhandled exception thrown in /@context@/ by API functions calls.+-}+contextGetException ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m (Maybe JavaScriptCore.Exception.Exception)+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Exception.Exception' or 'Nothing' if there isn\'t any+   unhandled exception in the 'GI.JavaScriptCore.Objects.Context.Context'. -}+contextGetException context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    result <- jsc_context_get_exception context'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject JavaScriptCore.Exception.Exception) result'+        return result''+    touchManagedPtr context+    return maybeResult++#if ENABLE_OVERLOADING+data ContextGetExceptionMethodInfo+instance (signature ~ (m (Maybe JavaScriptCore.Exception.Exception)), MonadIO m, IsContext a) => O.MethodInfo ContextGetExceptionMethodInfo a signature where+    overloadedMethod _ = contextGetException++#endif++-- method Context::get_global_object+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_get_global_object" jsc_context_get_global_object :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Get a 'GI.JavaScriptCore.Objects.Value.Value' referencing the /@context@/ global object+-}+contextGetGlobalObject ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' -}+contextGetGlobalObject context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    result <- jsc_context_get_global_object context'+    checkUnexpectedReturnNULL "contextGetGlobalObject" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+data ContextGetGlobalObjectMethodInfo+instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextGetGlobalObjectMethodInfo a signature where+    overloadedMethod _ = contextGetGlobalObject++#endif++-- method Context::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_get_value" jsc_context_get_value :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Get a property of /@context@/ global object with /@name@/.+-}+contextGetValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@name@/: the value name -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' -}+contextGetValue context name = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    result <- jsc_context_get_value context' name'+    checkUnexpectedReturnNULL "contextGetValue" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr context+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ContextGetValueMethodInfo+instance (signature ~ (T.Text -> m JavaScriptCore.Value.Value), MonadIO m, IsContext a) => O.MethodInfo ContextGetValueMethodInfo a signature where+    overloadedMethod _ = contextGetValue++#endif++-- method Context::get_virtual_machine+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_get_virtual_machine" jsc_context_get_virtual_machine :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO (Ptr JavaScriptCore.VirtualMachine.VirtualMachine)++{- |+Get the 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' where /@context@/ was created.+-}+contextGetVirtualMachine ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m JavaScriptCore.VirtualMachine.VirtualMachine+    {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine' where the 'GI.JavaScriptCore.Objects.Context.Context' was created. -}+contextGetVirtualMachine context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    result <- jsc_context_get_virtual_machine context'+    checkUnexpectedReturnNULL "contextGetVirtualMachine" result+    result' <- (newObject JavaScriptCore.VirtualMachine.VirtualMachine) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+data ContextGetVirtualMachineMethodInfo+instance (signature ~ (m JavaScriptCore.VirtualMachine.VirtualMachine), MonadIO m, IsContext a) => O.MethodInfo ContextGetVirtualMachineMethodInfo a signature where+    overloadedMethod _ = contextGetVirtualMachine++#endif++-- method Context::pop_exception_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_pop_exception_handler" jsc_context_pop_exception_handler :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO ()++{- |+Remove the last 'GI.JavaScriptCore.Callbacks.ExceptionHandler' previously pushed to /@context@/ with+'GI.JavaScriptCore.Objects.Context.contextPushExceptionHandler'.+-}+contextPopExceptionHandler ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m ()+contextPopExceptionHandler context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    jsc_context_pop_exception_handler context'+    touchManagedPtr context+    return ()++#if ENABLE_OVERLOADING+data ContextPopExceptionHandlerMethodInfo+instance (signature ~ (m ()), MonadIO m, IsContext a) => O.MethodInfo ContextPopExceptionHandlerMethodInfo a signature where+    overloadedMethod _ = contextPopExceptionHandler++#endif++-- method Context::push_exception_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "handler", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ExceptionHandler"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCExceptionHandler", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @handler", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_push_exception_handler" jsc_context_push_exception_handler :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    FunPtr JavaScriptCore.Callbacks.C_ExceptionHandler -> -- handler : TInterface (Name {namespace = "JavaScriptCore", name = "ExceptionHandler"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Push an exception handler in /@context@/. Whenever a JavaScript exception happens in+the 'GI.JavaScriptCore.Objects.Context.Context', the given /@handler@/ will be called. The default 'GI.JavaScriptCore.Callbacks.ExceptionHandler'+simply calls 'GI.JavaScriptCore.Objects.Context.contextThrowException' to throw the exception to the 'GI.JavaScriptCore.Objects.Context.Context'.+If you don\'t want to catch the exception, but only get notified about it, call+'GI.JavaScriptCore.Objects.Context.contextThrowException' in /@handler@/ like the default one does.+The last exception handler pushed is the only one used by the 'GI.JavaScriptCore.Objects.Context.Context', use+'GI.JavaScriptCore.Objects.Context.contextPopExceptionHandler' to remove it and set the previous one. When /@handler@/+is removed from the context, /@destroyNotify@/ i called with /@userData@/ as parameter.+-}+contextPushExceptionHandler ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> JavaScriptCore.Callbacks.ExceptionHandler+    {- ^ /@handler@/: a 'GI.JavaScriptCore.Callbacks.ExceptionHandler' -}+    -> m ()+contextPushExceptionHandler context handler = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    handler' <- JavaScriptCore.Callbacks.mk_ExceptionHandler (JavaScriptCore.Callbacks.wrap_ExceptionHandler Nothing (JavaScriptCore.Callbacks.drop_closures_ExceptionHandler handler))+    let userData = castFunPtrToPtr handler'+    let destroyNotify = safeFreeFunPtrPtr+    jsc_context_push_exception_handler context' handler' userData destroyNotify+    touchManagedPtr context+    return ()++#if ENABLE_OVERLOADING+data ContextPushExceptionHandlerMethodInfo+instance (signature ~ (JavaScriptCore.Callbacks.ExceptionHandler -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextPushExceptionHandlerMethodInfo a signature where+    overloadedMethod _ = contextPushExceptionHandler++#endif++-- method Context::register_class+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #JSCClass or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "vtable", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ClassVTable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an optional #JSCClassVTable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a destroy notifier for class instances", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Class"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_register_class" jsc_context_register_class :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    Ptr JavaScriptCore.Class.Class ->       -- parent_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    Ptr JavaScriptCore.ClassVTable.ClassVTable -> -- vtable : TInterface (Name {namespace = "JavaScriptCore", name = "ClassVTable"})+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO (Ptr JavaScriptCore.Class.Class)++{- |+Register a custom class in /@context@/ using the given /@name@/. If the new class inherits from+another 'GI.JavaScriptCore.Objects.Class.Class', the parent should be passed as /@parentClass@/, otherwise 'Nothing' should be+used. The optional /@vtable@/ parameter allows to provide a custom implementation for handling+the class, for example, to handle external properties not added to the prototype.+When an instance of the 'GI.JavaScriptCore.Objects.Class.Class' is cleared in the context, /@destroyNotify@/ is called with+the instance as parameter.+-}+contextRegisterClass ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@name@/: the class name -}+    -> Maybe (b)+    {- ^ /@parentClass@/: a 'GI.JavaScriptCore.Objects.Class.Class' or 'Nothing' -}+    -> Maybe (JavaScriptCore.ClassVTable.ClassVTable)+    {- ^ /@vtable@/: an optional 'GI.JavaScriptCore.Structs.ClassVTable.ClassVTable' or 'Nothing' -}+    -> Maybe (GLib.Callbacks.DestroyNotify)+    {- ^ /@destroyNotify@/: a destroy notifier for class instances -}+    -> m JavaScriptCore.Class.Class+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Class.Class' -}+contextRegisterClass context name parentClass vtable destroyNotify = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    maybeParentClass <- case parentClass of+        Nothing -> return nullPtr+        Just jParentClass -> do+            jParentClass' <- unsafeManagedPtrCastPtr jParentClass+            return jParentClass'+    maybeVtable <- case vtable of+        Nothing -> return nullPtr+        Just jVtable -> do+            jVtable' <- unsafeManagedPtrGetPtr jVtable+            return jVtable'+    maybeDestroyNotify <- case destroyNotify of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jDestroyNotify -> do+            ptrdestroyNotify <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify))+            jDestroyNotify' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdestroyNotify) jDestroyNotify)+            poke ptrdestroyNotify jDestroyNotify'+            return jDestroyNotify'+    result <- jsc_context_register_class context' name' maybeParentClass maybeVtable maybeDestroyNotify+    checkUnexpectedReturnNULL "contextRegisterClass" result+    result' <- (newObject JavaScriptCore.Class.Class) result+    touchManagedPtr context+    whenJust parentClass touchManagedPtr+    whenJust vtable touchManagedPtr+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ContextRegisterClassMethodInfo+instance (signature ~ (T.Text -> Maybe (b) -> Maybe (JavaScriptCore.ClassVTable.ClassVTable) -> Maybe (GLib.Callbacks.DestroyNotify) -> m JavaScriptCore.Class.Class), MonadIO m, IsContext a, JavaScriptCore.Class.IsClass b) => O.MethodInfo ContextRegisterClassMethodInfo a signature where+    overloadedMethod _ = contextRegisterClass++#endif++-- method Context::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_set_value" jsc_context_set_value :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    Ptr JavaScriptCore.Value.Value ->       -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO ()++{- |+Set a property of /@context@/ global object with /@name@/ and /@value@/.+-}+contextSetValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Value.IsValue b) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@name@/: the value name -}+    -> b+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m ()+contextSetValue context name value = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    value' <- unsafeManagedPtrCastPtr value+    jsc_context_set_value context' name' value'+    touchManagedPtr context+    touchManagedPtr value+    freeMem name'+    return ()++#if ENABLE_OVERLOADING+data ContextSetValueMethodInfo+instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsContext a, JavaScriptCore.Value.IsValue b) => O.MethodInfo ContextSetValueMethodInfo a signature where+    overloadedMethod _ = contextSetValue++#endif++-- method Context::throw+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_throw" jsc_context_throw :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- error_message : TBasicType TUTF8+    IO ()++{- |+Throw an exception to /@context@/ using the given error message. The created 'GI.JavaScriptCore.Objects.Exception.Exception'+can be retrieved with 'GI.JavaScriptCore.Objects.Context.contextGetException'.+-}+contextThrow ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@errorMessage@/: an error message -}+    -> m ()+contextThrow context errorMessage = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    errorMessage' <- textToCString errorMessage+    jsc_context_throw context' errorMessage'+    touchManagedPtr context+    freeMem errorMessage'+    return ()++#if ENABLE_OVERLOADING+data ContextThrowMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextThrowMethodInfo a signature where+    overloadedMethod _ = contextThrow++#endif++-- method Context::throw_exception+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_throw_exception" jsc_context_throw_exception :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    Ptr JavaScriptCore.Exception.Exception -> -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO ()++{- |+Throw /@exception@/ to /@context@/.+-}+contextThrowException ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a, JavaScriptCore.Exception.IsException b) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> b+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m ()+contextThrowException context exception = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    exception' <- unsafeManagedPtrCastPtr exception+    jsc_context_throw_exception context' exception'+    touchManagedPtr context+    touchManagedPtr exception+    return ()++#if ENABLE_OVERLOADING+data ContextThrowExceptionMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, IsContext a, JavaScriptCore.Exception.IsException b) => O.MethodInfo ContextThrowExceptionMethodInfo a signature where+    overloadedMethod _ = contextThrowException++#endif++-- method Context::throw_with_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_throw_with_name" jsc_context_throw_with_name :: +    Ptr Context ->                          -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- error_name : TBasicType TUTF8+    CString ->                              -- error_message : TBasicType TUTF8+    IO ()++{- |+Throw an exception to /@context@/ using the given error name and message. The created 'GI.JavaScriptCore.Objects.Exception.Exception'+can be retrieved with 'GI.JavaScriptCore.Objects.Context.contextGetException'.+-}+contextThrowWithName ::+    (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@errorName@/: the error name -}+    -> T.Text+    {- ^ /@errorMessage@/: an error message -}+    -> m ()+contextThrowWithName context errorName errorMessage = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    errorName' <- textToCString errorName+    errorMessage' <- textToCString errorMessage+    jsc_context_throw_with_name context' errorName' errorMessage'+    touchManagedPtr context+    freeMem errorName'+    freeMem errorMessage'+    return ()++#if ENABLE_OVERLOADING+data ContextThrowWithNameMethodInfo+instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsContext a) => O.MethodInfo ContextThrowWithNameMethodInfo a signature where+    overloadedMethod _ = contextThrowWithName++#endif++-- method Context::get_current+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_context_get_current" jsc_context_get_current :: +    IO (Ptr Context)++{- |+Get the 'GI.JavaScriptCore.Objects.Context.Context' that is currently executing a function. This should only be+called within a function or method callback, otherwise 'Nothing' will be returned.+-}+contextGetCurrent ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m (Maybe Context)+    {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.Context.Context' that is currently executing. -}+contextGetCurrent  = liftIO $ do+    result <- jsc_context_get_current+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- (newObject Context) result'+        return result''+    return maybeResult++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,80 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.Context 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype Context = Context (ManagedPtr Context)+instance GObject Context where+class (GObject o, O.IsDescendantOf Context o) => IsContext o+instance (GObject o, O.IsDescendantOf Context o) => IsContext o+instance O.HasParentTypes Context+#if ENABLE_OVERLOADING+data ContextVirtualMachinePropertyInfo+#endif+#if ENABLE_OVERLOADING+data ContextCheckSyntaxMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextClearExceptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextEvaluateMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextEvaluateInObjectMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextEvaluateWithSourceUriMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextGetExceptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextGetGlobalObjectMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextGetValueMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextGetVirtualMachineMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextPopExceptionHandlerMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextPushExceptionHandlerMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextRegisterClassMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextSetValueMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextThrowMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextThrowExceptionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ContextThrowWithNameMethodInfo+#endif

@@ -0,0 +1,575 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.Exception+    ( ++-- * Exported types+    Exception(..)                           ,+    IsException                             ,+    toException                             ,+    noException                             ,+++ -- * Methods+-- ** getBacktraceString #method:getBacktraceString#++#if ENABLE_OVERLOADING+    ExceptionGetBacktraceStringMethodInfo   ,+#endif+    exceptionGetBacktraceString             ,+++-- ** getColumnNumber #method:getColumnNumber#++#if ENABLE_OVERLOADING+    ExceptionGetColumnNumberMethodInfo      ,+#endif+    exceptionGetColumnNumber                ,+++-- ** getLineNumber #method:getLineNumber#++#if ENABLE_OVERLOADING+    ExceptionGetLineNumberMethodInfo        ,+#endif+    exceptionGetLineNumber                  ,+++-- ** getMessage #method:getMessage#++#if ENABLE_OVERLOADING+    ExceptionGetMessageMethodInfo           ,+#endif+    exceptionGetMessage                     ,+++-- ** getName #method:getName#++#if ENABLE_OVERLOADING+    ExceptionGetNameMethodInfo              ,+#endif+    exceptionGetName                        ,+++-- ** getSourceUri #method:getSourceUri#++#if ENABLE_OVERLOADING+    ExceptionGetSourceUriMethodInfo         ,+#endif+    exceptionGetSourceUri                   ,+++-- ** new #method:new#++    exceptionNew                            ,+++-- ** newWithName #method:newWithName#++    exceptionNewWithName                    ,+++-- ** report #method:report#++#if ENABLE_OVERLOADING+    ExceptionReportMethodInfo               ,+#endif+    exceptionReport                         ,+++-- ** toString #method:toString#++#if ENABLE_OVERLOADING+    ExceptionToStringMethodInfo             ,+#endif+    exceptionToString                       ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context++-- | Memory-managed wrapper type.+newtype Exception = Exception (ManagedPtr Exception)+foreign import ccall "jsc_exception_get_type"+    c_jsc_exception_get_type :: IO GType++instance GObject Exception where+    gobjectType = c_jsc_exception_get_type+    ++-- | Type class for types which can be safely cast to `Exception`, for instance with `toException`.+class (GObject o, O.IsDescendantOf Exception o) => IsException o+instance (GObject o, O.IsDescendantOf Exception o) => IsException o++instance O.HasParentTypes Exception+type instance O.ParentTypes Exception = '[GObject.Object.Object]++-- | Cast to `Exception`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toException :: (MonadIO m, IsException o) => o -> m Exception+toException = liftIO . unsafeCastTo Exception++-- | A convenience alias for `Nothing` :: `Maybe` `Exception`.+noException :: Maybe Exception+noException = Nothing++#if ENABLE_OVERLOADING+type family ResolveExceptionMethod (t :: Symbol) (o :: *) :: * where+    ResolveExceptionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveExceptionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveExceptionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveExceptionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveExceptionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveExceptionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveExceptionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveExceptionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveExceptionMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveExceptionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveExceptionMethod "report" o = ExceptionReportMethodInfo+    ResolveExceptionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveExceptionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveExceptionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveExceptionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveExceptionMethod "toString" o = ExceptionToStringMethodInfo+    ResolveExceptionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveExceptionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveExceptionMethod "getBacktraceString" o = ExceptionGetBacktraceStringMethodInfo+    ResolveExceptionMethod "getColumnNumber" o = ExceptionGetColumnNumberMethodInfo+    ResolveExceptionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveExceptionMethod "getLineNumber" o = ExceptionGetLineNumberMethodInfo+    ResolveExceptionMethod "getMessage" o = ExceptionGetMessageMethodInfo+    ResolveExceptionMethod "getName" o = ExceptionGetNameMethodInfo+    ResolveExceptionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveExceptionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveExceptionMethod "getSourceUri" o = ExceptionGetSourceUriMethodInfo+    ResolveExceptionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveExceptionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveExceptionMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveExceptionMethod t Exception, O.MethodInfo info Exception p) => OL.IsLabel t (Exception -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Exception+type instance O.AttributeList Exception = ExceptionAttributeList+type ExceptionAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Exception = ExceptionSignalList+type ExceptionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Exception::new+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_new" jsc_exception_new :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- message : TBasicType TUTF8+    IO (Ptr Exception)++{- |+Create a new 'GI.JavaScriptCore.Objects.Exception.Exception' in /@context@/ with /@message@/.+-}+exceptionNew ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@message@/: the error message -}+    -> m Exception+    {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Exception.Exception'. -}+exceptionNew context message = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    message' <- textToCString message+    result <- jsc_exception_new context' message'+    checkUnexpectedReturnNULL "exceptionNew" result+    result' <- (wrapObject Exception) result+    touchManagedPtr context+    freeMem message'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Exception::new_with_name+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the error message", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_new_with_name" jsc_exception_new_with_name :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- message : TBasicType TUTF8+    IO (Ptr Exception)++{- |+Create a new 'GI.JavaScriptCore.Objects.Exception.Exception' in /@context@/ with /@name@/ and /@message@/.+-}+exceptionNewWithName ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> T.Text+    {- ^ /@name@/: the error name -}+    -> T.Text+    {- ^ /@message@/: the error message -}+    -> m Exception+    {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Exception.Exception'. -}+exceptionNewWithName context name message = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    name' <- textToCString name+    message' <- textToCString message+    result <- jsc_exception_new_with_name context' name' message'+    checkUnexpectedReturnNULL "exceptionNewWithName" result+    result' <- (wrapObject Exception) result+    touchManagedPtr context+    freeMem name'+    freeMem message'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Exception::get_backtrace_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_backtrace_string" jsc_exception_get_backtrace_string :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Get a string with the exception backtrace.+-}+exceptionGetBacktraceString ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the exception backtrace string or 'Nothing'. -}+exceptionGetBacktraceString exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_backtrace_string exception'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr exception+    return maybeResult++#if ENABLE_OVERLOADING+data ExceptionGetBacktraceStringMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsException a) => O.MethodInfo ExceptionGetBacktraceStringMethodInfo a signature where+    overloadedMethod _ = exceptionGetBacktraceString++#endif++-- method Exception::get_column_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_column_number" jsc_exception_get_column_number :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO Word32++{- |+Get the column number at which /@exception@/ happened.+-}+exceptionGetColumnNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m Word32+    {- ^ __Returns:__ the column number of /@exception@/. -}+exceptionGetColumnNumber exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_column_number exception'+    touchManagedPtr exception+    return result++#if ENABLE_OVERLOADING+data ExceptionGetColumnNumberMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsException a) => O.MethodInfo ExceptionGetColumnNumberMethodInfo a signature where+    overloadedMethod _ = exceptionGetColumnNumber++#endif++-- method Exception::get_line_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUInt)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_line_number" jsc_exception_get_line_number :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO Word32++{- |+Get the line number at which /@exception@/ happened.+-}+exceptionGetLineNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m Word32+    {- ^ __Returns:__ the line number of /@exception@/. -}+exceptionGetLineNumber exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_line_number exception'+    touchManagedPtr exception+    return result++#if ENABLE_OVERLOADING+data ExceptionGetLineNumberMethodInfo+instance (signature ~ (m Word32), MonadIO m, IsException a) => O.MethodInfo ExceptionGetLineNumberMethodInfo a signature where+    overloadedMethod _ = exceptionGetLineNumber++#endif++-- method Exception::get_message+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_message" jsc_exception_get_message :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Get the error message of /@exception@/.+-}+exceptionGetMessage ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m T.Text+    {- ^ __Returns:__ the /@exception@/ error message. -}+exceptionGetMessage exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_message exception'+    checkUnexpectedReturnNULL "exceptionGetMessage" result+    result' <- cstringToText result+    touchManagedPtr exception+    return result'++#if ENABLE_OVERLOADING+data ExceptionGetMessageMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionGetMessageMethodInfo a signature where+    overloadedMethod _ = exceptionGetMessage++#endif++-- method Exception::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_name" jsc_exception_get_name :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Get the error name of /@exception@/+-}+exceptionGetName ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m T.Text+    {- ^ __Returns:__ the /@exception@/ error name. -}+exceptionGetName exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_name exception'+    checkUnexpectedReturnNULL "exceptionGetName" result+    result' <- cstringToText result+    touchManagedPtr exception+    return result'++#if ENABLE_OVERLOADING+data ExceptionGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionGetNameMethodInfo a signature where+    overloadedMethod _ = exceptionGetName++#endif++-- method Exception::get_source_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_get_source_uri" jsc_exception_get_source_uri :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Get the source URI of /@exception@/.+-}+exceptionGetSourceUri ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m (Maybe T.Text)+    {- ^ __Returns:__ the the source URI of /@exception@/, or 'Nothing'. -}+exceptionGetSourceUri exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_get_source_uri exception'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- cstringToText result'+        return result''+    touchManagedPtr exception+    return maybeResult++#if ENABLE_OVERLOADING+data ExceptionGetSourceUriMethodInfo+instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsException a) => O.MethodInfo ExceptionGetSourceUriMethodInfo a signature where+    overloadedMethod _ = exceptionGetSourceUri++#endif++-- method Exception::report+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_report" jsc_exception_report :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Return a report message of /@exception@/, containing all the possible details such us+source URI, line, column and backtrace, and formatted to be printed.+-}+exceptionReport ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m T.Text+    {- ^ __Returns:__ a new string with the exception report -}+exceptionReport exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_report exception'+    checkUnexpectedReturnNULL "exceptionReport" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr exception+    return result'++#if ENABLE_OVERLOADING+data ExceptionReportMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionReportMethodInfo a signature where+    overloadedMethod _ = exceptionReport++#endif++-- method Exception::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "exception", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Exception"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCException", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_exception_to_string" jsc_exception_to_string :: +    Ptr Exception ->                        -- exception : TInterface (Name {namespace = "JavaScriptCore", name = "Exception"})+    IO CString++{- |+Get the string representation of /@exception@/ error.+-}+exceptionToString ::+    (B.CallStack.HasCallStack, MonadIO m, IsException a) =>+    a+    {- ^ /@exception@/: a 'GI.JavaScriptCore.Objects.Exception.Exception' -}+    -> m T.Text+    {- ^ __Returns:__ the string representation of /@exception@/. -}+exceptionToString exception = liftIO $ do+    exception' <- unsafeManagedPtrCastPtr exception+    result <- jsc_exception_to_string exception'+    checkUnexpectedReturnNULL "exceptionToString" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr exception+    return result'++#if ENABLE_OVERLOADING+data ExceptionToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsException a) => O.MethodInfo ExceptionToStringMethodInfo a signature where+    overloadedMethod _ = exceptionToString++#endif++

@@ -0,0 +1,53 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.Exception 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype Exception = Exception (ManagedPtr Exception)+instance GObject Exception where+class (GObject o, O.IsDescendantOf Exception o) => IsException o+instance (GObject o, O.IsDescendantOf Exception o) => IsException o+instance O.HasParentTypes Exception+#if ENABLE_OVERLOADING+data ExceptionGetBacktraceStringMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionGetColumnNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionGetLineNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionGetMessageMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionGetNameMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionGetSourceUriMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionReportMethodInfo+#endif+#if ENABLE_OVERLOADING+data ExceptionToStringMethodInfo+#endif

@@ -0,0 +1,2132 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.Value+    ( ++-- * Exported types+    Value(..)                               ,+    IsValue                                 ,+    toValue                                 ,+    noValue                                 ,+++ -- * Methods+-- ** constructorCall #method:constructorCall#++#if ENABLE_OVERLOADING+    ValueConstructorCallMethodInfo          ,+#endif+    valueConstructorCall                    ,+++-- ** functionCall #method:functionCall#++#if ENABLE_OVERLOADING+    ValueFunctionCallMethodInfo             ,+#endif+    valueFunctionCall                       ,+++-- ** getContext #method:getContext#++#if ENABLE_OVERLOADING+    ValueGetContextMethodInfo               ,+#endif+    valueGetContext                         ,+++-- ** isArray #method:isArray#++#if ENABLE_OVERLOADING+    ValueIsArrayMethodInfo                  ,+#endif+    valueIsArray                            ,+++-- ** isBoolean #method:isBoolean#++#if ENABLE_OVERLOADING+    ValueIsBooleanMethodInfo                ,+#endif+    valueIsBoolean                          ,+++-- ** isConstructor #method:isConstructor#++#if ENABLE_OVERLOADING+    ValueIsConstructorMethodInfo            ,+#endif+    valueIsConstructor                      ,+++-- ** isFunction #method:isFunction#++#if ENABLE_OVERLOADING+    ValueIsFunctionMethodInfo               ,+#endif+    valueIsFunction                         ,+++-- ** isNull #method:isNull#++#if ENABLE_OVERLOADING+    ValueIsNullMethodInfo                   ,+#endif+    valueIsNull                             ,+++-- ** isNumber #method:isNumber#++#if ENABLE_OVERLOADING+    ValueIsNumberMethodInfo                 ,+#endif+    valueIsNumber                           ,+++-- ** isObject #method:isObject#++#if ENABLE_OVERLOADING+    ValueIsObjectMethodInfo                 ,+#endif+    valueIsObject                           ,+++-- ** isString #method:isString#++#if ENABLE_OVERLOADING+    ValueIsStringMethodInfo                 ,+#endif+    valueIsString                           ,+++-- ** isUndefined #method:isUndefined#++#if ENABLE_OVERLOADING+    ValueIsUndefinedMethodInfo              ,+#endif+    valueIsUndefined                        ,+++-- ** newArrayFromGarray #method:newArrayFromGarray#++    valueNewArrayFromGarray                 ,+++-- ** newArrayFromStrv #method:newArrayFromStrv#++    valueNewArrayFromStrv                   ,+++-- ** newBoolean #method:newBoolean#++    valueNewBoolean                         ,+++-- ** newFunction #method:newFunction#++    valueNewFunction                        ,+++-- ** newFunctionVariadic #method:newFunctionVariadic#++    valueNewFunctionVariadic                ,+++-- ** newNull #method:newNull#++    valueNewNull                            ,+++-- ** newNumber #method:newNumber#++    valueNewNumber                          ,+++-- ** newObject #method:newObject#++    valueNewObject                          ,+++-- ** newString #method:newString#++    valueNewString                          ,+++-- ** newStringFromBytes #method:newStringFromBytes#++    valueNewStringFromBytes                 ,+++-- ** newUndefined #method:newUndefined#++    valueNewUndefined                       ,+++-- ** objectDefinePropertyAccessor #method:objectDefinePropertyAccessor#++#if ENABLE_OVERLOADING+    ValueObjectDefinePropertyAccessorMethodInfo,+#endif+    valueObjectDefinePropertyAccessor       ,+++-- ** objectDefinePropertyData #method:objectDefinePropertyData#++#if ENABLE_OVERLOADING+    ValueObjectDefinePropertyDataMethodInfo ,+#endif+    valueObjectDefinePropertyData           ,+++-- ** objectDeleteProperty #method:objectDeleteProperty#++#if ENABLE_OVERLOADING+    ValueObjectDeletePropertyMethodInfo     ,+#endif+    valueObjectDeleteProperty               ,+++-- ** objectEnumerateProperties #method:objectEnumerateProperties#++#if ENABLE_OVERLOADING+    ValueObjectEnumeratePropertiesMethodInfo,+#endif+    valueObjectEnumerateProperties          ,+++-- ** objectGetProperty #method:objectGetProperty#++#if ENABLE_OVERLOADING+    ValueObjectGetPropertyMethodInfo        ,+#endif+    valueObjectGetProperty                  ,+++-- ** objectGetPropertyAtIndex #method:objectGetPropertyAtIndex#++#if ENABLE_OVERLOADING+    ValueObjectGetPropertyAtIndexMethodInfo ,+#endif+    valueObjectGetPropertyAtIndex           ,+++-- ** objectHasProperty #method:objectHasProperty#++#if ENABLE_OVERLOADING+    ValueObjectHasPropertyMethodInfo        ,+#endif+    valueObjectHasProperty                  ,+++-- ** objectInvokeMethod #method:objectInvokeMethod#++#if ENABLE_OVERLOADING+    ValueObjectInvokeMethodMethodInfo       ,+#endif+    valueObjectInvokeMethod                 ,+++-- ** objectIsInstanceOf #method:objectIsInstanceOf#++#if ENABLE_OVERLOADING+    ValueObjectIsInstanceOfMethodInfo       ,+#endif+    valueObjectIsInstanceOf                 ,+++-- ** objectSetProperty #method:objectSetProperty#++#if ENABLE_OVERLOADING+    ValueObjectSetPropertyMethodInfo        ,+#endif+    valueObjectSetProperty                  ,+++-- ** objectSetPropertyAtIndex #method:objectSetPropertyAtIndex#++#if ENABLE_OVERLOADING+    ValueObjectSetPropertyAtIndexMethodInfo ,+#endif+    valueObjectSetPropertyAtIndex           ,+++-- ** toBoolean #method:toBoolean#++#if ENABLE_OVERLOADING+    ValueToBooleanMethodInfo                ,+#endif+    valueToBoolean                          ,+++-- ** toDouble #method:toDouble#++#if ENABLE_OVERLOADING+    ValueToDoubleMethodInfo                 ,+#endif+    valueToDouble                           ,+++-- ** toInt32 #method:toInt32#++#if ENABLE_OVERLOADING+    ValueToInt32MethodInfo                  ,+#endif+    valueToInt32                            ,+++-- ** toString #method:toString#++#if ENABLE_OVERLOADING+    ValueToStringMethodInfo                 ,+#endif+    valueToString                           ,+++-- ** toStringAsBytes #method:toStringAsBytes#++#if ENABLE_OVERLOADING+    ValueToStringAsBytesMethodInfo          ,+#endif+    valueToStringAsBytes                    ,+++++ -- * Properties+-- ** context #attr:context#+{- | The 'GI.JavaScriptCore.Objects.Context.Context' in which the value was created.+-}+#if ENABLE_OVERLOADING+    ValueContextPropertyInfo                ,+#endif+    constructValueContext                   ,+    getValueContext                         ,+#if ENABLE_OVERLOADING+    valueContext                            ,+#endif+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GLib.Callbacks as GLib.Callbacks+import qualified GI.GLib.Structs.Bytes as GLib.Bytes+import qualified GI.GObject.Callbacks as GObject.Callbacks+import qualified GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.JavaScriptCore.Flags as JavaScriptCore.Flags+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Class as JavaScriptCore.Class+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Context as JavaScriptCore.Context++-- | Memory-managed wrapper type.+newtype Value = Value (ManagedPtr Value)+foreign import ccall "jsc_value_get_type"+    c_jsc_value_get_type :: IO GType++instance GObject Value where+    gobjectType = c_jsc_value_get_type+    ++-- | Type class for types which can be safely cast to `Value`, for instance with `toValue`.+class (GObject o, O.IsDescendantOf Value o) => IsValue o+instance (GObject o, O.IsDescendantOf Value o) => IsValue o++instance O.HasParentTypes Value+type instance O.ParentTypes Value = '[GObject.Object.Object]++-- | Cast to `Value`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toValue :: (MonadIO m, IsValue o) => o -> m Value+toValue = liftIO . unsafeCastTo Value++-- | A convenience alias for `Nothing` :: `Maybe` `Value`.+noValue :: Maybe Value+noValue = Nothing++#if ENABLE_OVERLOADING+type family ResolveValueMethod (t :: Symbol) (o :: *) :: * where+    ResolveValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveValueMethod "constructorCall" o = ValueConstructorCallMethodInfo+    ResolveValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveValueMethod "functionCall" o = ValueFunctionCallMethodInfo+    ResolveValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveValueMethod "isArray" o = ValueIsArrayMethodInfo+    ResolveValueMethod "isBoolean" o = ValueIsBooleanMethodInfo+    ResolveValueMethod "isConstructor" o = ValueIsConstructorMethodInfo+    ResolveValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveValueMethod "isFunction" o = ValueIsFunctionMethodInfo+    ResolveValueMethod "isNull" o = ValueIsNullMethodInfo+    ResolveValueMethod "isNumber" o = ValueIsNumberMethodInfo+    ResolveValueMethod "isObject" o = ValueIsObjectMethodInfo+    ResolveValueMethod "isString" o = ValueIsStringMethodInfo+    ResolveValueMethod "isUndefined" o = ValueIsUndefinedMethodInfo+    ResolveValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveValueMethod "objectDefinePropertyAccessor" o = ValueObjectDefinePropertyAccessorMethodInfo+    ResolveValueMethod "objectDefinePropertyData" o = ValueObjectDefinePropertyDataMethodInfo+    ResolveValueMethod "objectDeleteProperty" o = ValueObjectDeletePropertyMethodInfo+    ResolveValueMethod "objectEnumerateProperties" o = ValueObjectEnumeratePropertiesMethodInfo+    ResolveValueMethod "objectGetProperty" o = ValueObjectGetPropertyMethodInfo+    ResolveValueMethod "objectGetPropertyAtIndex" o = ValueObjectGetPropertyAtIndexMethodInfo+    ResolveValueMethod "objectHasProperty" o = ValueObjectHasPropertyMethodInfo+    ResolveValueMethod "objectInvokeMethod" o = ValueObjectInvokeMethodMethodInfo+    ResolveValueMethod "objectIsInstanceOf" o = ValueObjectIsInstanceOfMethodInfo+    ResolveValueMethod "objectSetProperty" o = ValueObjectSetPropertyMethodInfo+    ResolveValueMethod "objectSetPropertyAtIndex" o = ValueObjectSetPropertyAtIndexMethodInfo+    ResolveValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveValueMethod "toBoolean" o = ValueToBooleanMethodInfo+    ResolveValueMethod "toDouble" o = ValueToDoubleMethodInfo+    ResolveValueMethod "toInt32" o = ValueToInt32MethodInfo+    ResolveValueMethod "toString" o = ValueToStringMethodInfo+    ResolveValueMethod "toStringAsBytes" o = ValueToStringAsBytesMethodInfo+    ResolveValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveValueMethod "getContext" o = ValueGetContextMethodInfo+    ResolveValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveValueMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveValueMethod t Value, O.MethodInfo info Value p) => OL.IsLabel t (Value -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- VVV Prop "context"+   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Just False,Nothing)++{- |+Get the value of the “@context@” property.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Attributes.get' value #context+@+-}+getValueContext :: (MonadIO m, IsValue o) => o -> m JavaScriptCore.Context.Context+getValueContext obj = liftIO $ checkUnexpectedNothing "getValueContext" $ B.Properties.getObjectPropertyObject obj "context" JavaScriptCore.Context.Context++{- |+Construct a `GValueConstruct` with valid value for the “@context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructValueContext :: (IsValue o, JavaScriptCore.Context.IsContext a) => a -> IO (GValueConstruct o)+constructValueContext val = B.Properties.constructObjectPropertyObject "context" (Just val)++#if ENABLE_OVERLOADING+data ValueContextPropertyInfo+instance AttrInfo ValueContextPropertyInfo where+    type AttrAllowedOps ValueContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]+    type AttrSetTypeConstraint ValueContextPropertyInfo = JavaScriptCore.Context.IsContext+    type AttrBaseTypeConstraint ValueContextPropertyInfo = IsValue+    type AttrGetType ValueContextPropertyInfo = JavaScriptCore.Context.Context+    type AttrLabel ValueContextPropertyInfo = "context"+    type AttrOrigin ValueContextPropertyInfo = Value+    attrGet _ = getValueContext+    attrSet _ = undefined+    attrConstruct _ = constructValueContext+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList Value+type instance O.AttributeList Value = ValueAttributeList+type ValueAttributeList = ('[ '("context", ValueContextPropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+valueContext :: AttrLabelProxy "context"+valueContext = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+type instance O.SignalList Value = ValueSignalList+type ValueSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method Value::new_array_from_garray+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TPtrArray (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GPtrArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_array_from_garray" jsc_value_new_array_from_garray :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    Ptr (GPtrArray (Ptr Value)) ->          -- array : TPtrArray (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing an array with the items from /@array@/. If /@array@/+is 'Nothing' or empty a new empty array will be created. Elements of /@array@/ should be+pointers to a 'GI.JavaScriptCore.Objects.Value.Value'.+-}+valueNewArrayFromGarray ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Maybe ([Value])+    {- ^ /@array@/: a 'GI.GLib.Structs.PtrArray.PtrArray' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewArrayFromGarray context array = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    maybeArray <- case array of+        Nothing -> return nullPtr+        Just jArray -> do+            jArray' <- mapM unsafeManagedPtrCastPtr jArray+            jArray'' <- packGPtrArray jArray'+            return jArray''+    result <- jsc_value_new_array_from_garray context' maybeArray+    checkUnexpectedReturnNULL "valueNewArrayFromGarray" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    whenJust array (mapM_ touchManagedPtr)+    unrefPtrArray maybeArray+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_array_from_strv+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "strv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a %NULL-terminated array of strings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_array_from_strv" jsc_value_new_array_from_strv :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    Ptr CString ->                          -- strv : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing an array of strings with the items from /@strv@/. If /@array@/+is 'Nothing' or empty a new empty array will be created.+-}+valueNewArrayFromStrv ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> [T.Text]+    {- ^ /@strv@/: a 'Nothing'-terminated array of strings -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewArrayFromStrv context strv = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    strv' <- packZeroTerminatedUTF8CArray strv+    result <- jsc_value_new_array_from_strv context' strv'+    checkUnexpectedReturnNULL "valueNewArrayFromStrv" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    mapZeroTerminatedCArray freeMem strv'+    freeMem strv'+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_boolean+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #gboolean", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_boolean" jsc_value_new_boolean :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CInt ->                                 -- value : TBasicType TBoolean+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@value@/+-}+valueNewBoolean ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Bool+    {- ^ /@value@/: a 'Bool' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewBoolean context value = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    let value' = (fromIntegral . fromEnum) value+    result <- jsc_value_new_boolean context' value'+    checkUnexpectedReturnNULL "valueNewBoolean" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_function_variadic+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the function return value, or %G_TYPE_NONE if the function is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_function_variadic" jsc_value_new_function_variadic :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    IO (Ptr Value)++{- |+Create a function in /@context@/. If /@name@/ is 'Nothing' an anonymous function will be created.+When the function is called by JavaScript or @/jsc_value_function_call()/@, /@callback@/ is called+receiving an 'GI.GLib.Structs.PtrArray.PtrArray' of 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s with the arguments and then /@userData@/ as last parameter.+When the function is cleared in /@context@/, /@destroyNotify@/ is called with /@userData@/ as parameter.++Note that the value returned by /@callback@/ must be fully transferred. In case of boxed types, you could use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter.+-}+valueNewFunctionVariadic ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Maybe (T.Text)+    {- ^ /@name@/: the function name or 'Nothing' -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback'. -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the function return value, or @/G_TYPE_NONE/@ if the function is void. -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewFunctionVariadic context name callback returnType = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    result <- jsc_value_new_function_variadic context' maybeName callback' userData destroyNotify returnType'+    checkUnexpectedReturnNULL "valueNewFunctionVariadic" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    freeMem maybeName+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_function+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the function name or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCallback.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "return_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the function return value, or %G_TYPE_NONE if the function is void.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameter_types", argType = TCArray False (-1) 6 (TBasicType TGType), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of #GType<!-- -->s, one for each parameter, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_functionv" jsc_value_new_functionv :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- name : TBasicType TUTF8+    FunPtr GObject.Callbacks.C_Callback ->  -- callback : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    CGType ->                               -- return_type : TBasicType TGType+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr CGType ->                           -- parameter_types : TCArray False (-1) 6 (TBasicType TGType)+    IO (Ptr Value)++{- |+Create a function in /@context@/. If /@name@/ is 'Nothing' an anonymous function will be created.+When the function is called by JavaScript or @/jsc_value_function_call()/@, /@callback@/ is called+receiving the function parameters and then /@userData@/ as last parameter. When the function is+cleared in /@context@/, /@destroyNotify@/ is called with /@userData@/ as parameter.++Note that the value returned by /@callback@/ must be fully transferred. In case of boxed types, you could use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter.+-}+valueNewFunction ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Maybe (T.Text)+    {- ^ /@name@/: the function name or 'Nothing' -}+    -> GObject.Callbacks.Callback+    {- ^ /@callback@/: a 'GI.GObject.Callbacks.Callback'. -}+    -> GType+    {- ^ /@returnType@/: the 'GType' of the function return value, or @/G_TYPE_NONE/@ if the function is void. -}+    -> Maybe ([GType])+    {- ^ /@parameterTypes@/: a list of 'GType'\<!-- -->s, one for each parameter, or 'Nothing' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewFunction context name callback returnType parameterTypes = liftIO $ do+    let nParameters = case parameterTypes of+            Nothing -> 0+            Just jParameterTypes -> fromIntegral $ length jParameterTypes+    context' <- unsafeManagedPtrCastPtr context+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    callback' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing callback)+    let returnType' = gtypeToCGType returnType+    maybeParameterTypes <- case parameterTypes of+        Nothing -> return nullPtr+        Just jParameterTypes -> do+            jParameterTypes' <- (packMapStorableArray gtypeToCGType) jParameterTypes+            return jParameterTypes'+    let userData = castFunPtrToPtr callback'+    let destroyNotify = safeFreeFunPtrPtr+    result <- jsc_value_new_functionv context' maybeName callback' userData destroyNotify returnType' nParameters maybeParameterTypes+    checkUnexpectedReturnNULL "valueNewFunction" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    freeMem maybeName+    freeMem maybeParameterTypes+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_null+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_null" jsc_value_new_null :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing \<function>null\<\/function> in /@context@/.+-}+valueNewNull ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewNull context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    result <- jsc_value_new_null context'+    checkUnexpectedReturnNULL "valueNewNull" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_number+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "number", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_number" jsc_value_new_number :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CDouble ->                              -- number : TBasicType TDouble+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@number@/.+-}+valueNewNumber ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Double+    {- ^ /@number@/: a number -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewNumber context number = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    let number' = realToFrac number+    result <- jsc_value_new_number context' number'+    checkUnexpectedReturnNULL "valueNewNumber" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_object+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "instance", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an object instance or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "jsc_class", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Class"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCClass of @instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_object" jsc_value_new_object :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    Ptr () ->                               -- instance : TBasicType TPtr+    Ptr JavaScriptCore.Class.Class ->       -- jsc_class : TInterface (Name {namespace = "JavaScriptCore", name = "Class"})+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@instance@/. If /@instance@/ is 'Nothing' a new empty object is created.+When /@instance@/ is provided, /@jscClass@/ must be provided too. /@jscClass@/ takes ownership of+/@instance@/ that will be freed by the 'GI.GLib.Callbacks.DestroyNotify' passed to 'GI.JavaScriptCore.Objects.Context.contextRegisterClass'.+-}+valueNewObject ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a, JavaScriptCore.Class.IsClass b) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Ptr ()+    {- ^ /@instance@/: an object instance or 'Nothing' -}+    -> Maybe (b)+    {- ^ /@jscClass@/: the 'GI.JavaScriptCore.Objects.Class.Class' of /@instance@/ -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewObject context instance_ jscClass = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    maybeJscClass <- case jscClass of+        Nothing -> return nullPtr+        Just jJscClass -> do+            jJscClass' <- unsafeManagedPtrCastPtr jJscClass+            return jJscClass'+    result <- jsc_value_new_object context' instance_ maybeJscClass+    checkUnexpectedReturnNULL "valueNewObject" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    whenJust jscClass touchManagedPtr+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_string+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a null-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_string" jsc_value_new_string :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@string@/. If you need to create a 'GI.JavaScriptCore.Objects.Value.Value' from a+string containing null characters, use 'GI.JavaScriptCore.Objects.Value.valueNewStringFromBytes' instead.+-}+valueNewString ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Maybe (T.Text)+    {- ^ /@string@/: a null-terminated string -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewString context string = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    maybeString <- case string of+        Nothing -> return nullPtr+        Just jString -> do+            jString' <- textToCString jString+            return jString'+    result <- jsc_value_new_string context' maybeString+    checkUnexpectedReturnNULL "valueNewString" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    freeMem maybeString+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_string_from_bytes+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes", argType = TInterface (Name {namespace = "GLib", name = "Bytes"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GBytes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_string_from_bytes" jsc_value_new_string_from_bytes :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    Ptr GLib.Bytes.Bytes ->                 -- bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' from /@bytes@/.+-}+valueNewStringFromBytes ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> Maybe (GLib.Bytes.Bytes)+    {- ^ /@bytes@/: a 'GI.GLib.Structs.Bytes.Bytes' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewStringFromBytes context bytes = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    maybeBytes <- case bytes of+        Nothing -> return nullPtr+        Just jBytes -> do+            jBytes' <- unsafeManagedPtrGetPtr jBytes+            return jBytes'+    result <- jsc_value_new_string_from_bytes context' maybeBytes+    checkUnexpectedReturnNULL "valueNewStringFromBytes" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    whenJust bytes touchManagedPtr+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::new_undefined+-- method type : Constructor+-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCContext", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_new_undefined" jsc_value_new_undefined :: +    Ptr JavaScriptCore.Context.Context ->   -- context : TInterface (Name {namespace = "JavaScriptCore", name = "Context"})+    IO (Ptr Value)++{- |+Create a new 'GI.JavaScriptCore.Objects.Value.Value' referencing \<function>undefined\<\/function> in /@context@/.+-}+valueNewUndefined ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Context.IsContext a) =>+    a+    {- ^ /@context@/: a 'GI.JavaScriptCore.Objects.Context.Context' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueNewUndefined context = liftIO $ do+    context' <- unsafeManagedPtrCastPtr context+    result <- jsc_value_new_undefined context'+    checkUnexpectedReturnNULL "valueNewUndefined" result+    result' <- (wrapObject Value) result+    touchManagedPtr context+    return result'++#if ENABLE_OVERLOADING+#endif++-- method Value::constructor_call+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValue<!-- -->s to pass as parameters to the constructor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_constructor_callv" jsc_value_constructor_callv :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr (Ptr Value) ->                      -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+    IO (Ptr Value)++{- |+Invoke \<function>new\<\/function> with constructor referenced by /@value@/. If /@nParameters@/+is 0 no parameters will be passed to the constructor.+-}+valueConstructorCall ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> Maybe ([Value])+    {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s to pass as parameters to the constructor, or 'Nothing' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' referencing the newly created object instance. -}+valueConstructorCall value parameters = liftIO $ do+    let nParameters = case parameters of+            Nothing -> 0+            Just jParameters -> fromIntegral $ length jParameters+    value' <- unsafeManagedPtrCastPtr value+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            jParameters' <- mapM unsafeManagedPtrCastPtr jParameters+            jParameters'' <- packPtrArray jParameters'+            return jParameters''+    result <- jsc_value_constructor_callv value' nParameters maybeParameters+    checkUnexpectedReturnNULL "valueConstructorCall" result+    result' <- (wrapObject Value) result+    touchManagedPtr value+    whenJust parameters (mapM_ touchManagedPtr)+    freeMem maybeParameters+    return result'++#if ENABLE_OVERLOADING+data ValueConstructorCallMethodInfo+instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueConstructorCallMethodInfo a signature where+    overloadedMethod _ = valueConstructorCall++#endif++-- method Value::function_call+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValue<!-- -->s to pass as parameters to the function, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_function_callv" jsc_value_function_callv :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr (Ptr Value) ->                      -- parameters : TCArray False (-1) 1 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+    IO (Ptr Value)++{- |+Call function referenced by /@value@/, passing the given /@parameters@/. If /@nParameters@/+is 0 no parameters will be passed to the function.++This function always returns a 'GI.JavaScriptCore.Objects.Value.Value', in case of void functions a 'GI.JavaScriptCore.Objects.Value.Value' referencing+\<function>undefined\<\/function> is returned+-}+valueFunctionCall ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> Maybe ([Value])+    {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s to pass as parameters to the function, or 'Nothing' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' with the return value of the function. -}+valueFunctionCall value parameters = liftIO $ do+    let nParameters = case parameters of+            Nothing -> 0+            Just jParameters -> fromIntegral $ length jParameters+    value' <- unsafeManagedPtrCastPtr value+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            jParameters' <- mapM unsafeManagedPtrCastPtr jParameters+            jParameters'' <- packPtrArray jParameters'+            return jParameters''+    result <- jsc_value_function_callv value' nParameters maybeParameters+    checkUnexpectedReturnNULL "valueFunctionCall" result+    result' <- (wrapObject Value) result+    touchManagedPtr value+    whenJust parameters (mapM_ touchManagedPtr)+    freeMem maybeParameters+    return result'++#if ENABLE_OVERLOADING+data ValueFunctionCallMethodInfo+instance (signature ~ (Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueFunctionCallMethodInfo a signature where+    overloadedMethod _ = valueFunctionCall++#endif++-- method Value::get_context+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Context"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_get_context" jsc_value_get_context :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO (Ptr JavaScriptCore.Context.Context)++{- |+Get the 'GI.JavaScriptCore.Objects.Context.Context' in which /@value@/ was created.+-}+valueGetContext ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m JavaScriptCore.Context.Context+    {- ^ __Returns:__ the 'GI.JavaScriptCore.Objects.Value.Value' context. -}+valueGetContext value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_get_context value'+    checkUnexpectedReturnNULL "valueGetContext" result+    result' <- (newObject JavaScriptCore.Context.Context) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueGetContextMethodInfo+instance (signature ~ (m JavaScriptCore.Context.Context), MonadIO m, IsValue a) => O.MethodInfo ValueGetContextMethodInfo a signature where+    overloadedMethod _ = valueGetContext++#endif++-- method Value::is_array+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_array" jsc_value_is_array :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is an array.+-}+valueIsArray ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is an array. -}+valueIsArray value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_array value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsArrayMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsArrayMethodInfo a signature where+    overloadedMethod _ = valueIsArray++#endif++-- method Value::is_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_boolean" jsc_value_is_boolean :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is a boolean.+-}+valueIsBoolean ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is a boolean. -}+valueIsBoolean value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_boolean value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsBooleanMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsBooleanMethodInfo a signature where+    overloadedMethod _ = valueIsBoolean++#endif++-- method Value::is_constructor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_constructor" jsc_value_is_constructor :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is a constructor.+-}+valueIsConstructor ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is a constructor. -}+valueIsConstructor value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_constructor value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsConstructorMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsConstructorMethodInfo a signature where+    overloadedMethod _ = valueIsConstructor++#endif++-- method Value::is_function+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_function" jsc_value_is_function :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is a function+-}+valueIsFunction ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is a function. -}+valueIsFunction value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_function value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsFunctionMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsFunctionMethodInfo a signature where+    overloadedMethod _ = valueIsFunction++#endif++-- method Value::is_null+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_null" jsc_value_is_null :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is \<function>null\<\/function>.+-}+valueIsNull ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is null. -}+valueIsNull value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_null value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsNullMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsNullMethodInfo a signature where+    overloadedMethod _ = valueIsNull++#endif++-- method Value::is_number+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_number" jsc_value_is_number :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is a number.+-}+valueIsNumber ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is a number. -}+valueIsNumber value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_number value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsNumberMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsNumberMethodInfo a signature where+    overloadedMethod _ = valueIsNumber++#endif++-- method Value::is_object+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_object" jsc_value_is_object :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is an object.+-}+valueIsObject ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is an object. -}+valueIsObject value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_object value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsObjectMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsObjectMethodInfo a signature where+    overloadedMethod _ = valueIsObject++#endif++-- method Value::is_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_string" jsc_value_is_string :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is a string+-}+valueIsString ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is a string -}+valueIsString value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_string value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsStringMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsStringMethodInfo a signature where+    overloadedMethod _ = valueIsString++#endif++-- method Value::is_undefined+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_is_undefined" jsc_value_is_undefined :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Get whether the value referenced by /@value@/ is \<function>undefined\<\/function>.+-}+valueIsUndefined ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ whether the value is undefined. -}+valueIsUndefined value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_is_undefined value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueIsUndefinedMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueIsUndefinedMethodInfo a signature where+    overloadedMethod _ = valueIsUndefined++#endif++-- method Value::object_define_property_accessor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to define", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#JSCValuePropertyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GType of the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "getter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to get the property value", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setter", argType = TInterface (Name {namespace = "GObject", name = "Callback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCallback to be called to set the property value", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 6, argDestroy = 7, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @getter and @setter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "destroy notifier for @user_data", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_define_property_accessor" jsc_value_object_define_property_accessor :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- property_name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"})+    CGType ->                               -- property_type : TBasicType TGType+    FunPtr GObject.Callbacks.C_Callback ->  -- getter : TInterface (Name {namespace = "GObject", name = "Callback"})+    FunPtr GObject.Callbacks.C_Callback ->  -- setter : TInterface (Name {namespace = "GObject", name = "Callback"})+    Ptr () ->                               -- user_data : TBasicType TPtr+    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})+    IO ()++{- |+Define or modify a property with /@propertyName@/ in object referenced by /@value@/. When the+property value needs to be getted or set, /@getter@/ and /@setter@/ callbacks will be called.+When the property is cleared in the 'GI.JavaScriptCore.Objects.Class.Class' context, /@destroyNotify@/ is called with+/@userData@/ as parameter. This is equivalent to JavaScript \<function>Object.@/defineProperty()/@\<\/function>+when used with an accessor descriptor.++Note that the value returned by /@getter@/ must be fully transferred. In case of boxed types, you could use+@/G_TYPE_POINTER/@ instead of the actual boxed 'GType' to ensure that the instance owned by 'GI.JavaScriptCore.Objects.Class.Class' is used.+If you really want to return a new copy of the boxed type, use @/JSC_TYPE_VALUE/@ and return a 'GI.JavaScriptCore.Objects.Value.Value' created+with 'GI.JavaScriptCore.Objects.Value.valueNewObject' that receives the copy as instance parameter.+-}+valueObjectDefinePropertyAccessor ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@propertyName@/: the name of the property to define -}+    -> [JavaScriptCore.Flags.ValuePropertyFlags]+    {- ^ /@flags@/: 'GI.JavaScriptCore.Flags.ValuePropertyFlags' -}+    -> GType+    {- ^ /@propertyType@/: the 'GType' of the property -}+    -> Maybe (GObject.Callbacks.Callback)+    {- ^ /@getter@/: a 'GI.GObject.Callbacks.Callback' to be called to get the property value -}+    -> Maybe (GObject.Callbacks.Callback)+    {- ^ /@setter@/: a 'GI.GObject.Callbacks.Callback' to be called to set the property value -}+    -> m ()+valueObjectDefinePropertyAccessor value propertyName flags propertyType getter setter = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    propertyName' <- textToCString propertyName+    let flags' = gflagsToWord flags+    let propertyType' = gtypeToCGType propertyType+    maybeGetter <- case getter of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jGetter -> do+            ptrgetter <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))+            jGetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrgetter) jGetter)+            poke ptrgetter jGetter'+            return jGetter'+    maybeSetter <- case setter of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jSetter -> do+            jSetter' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing jSetter)+            return jSetter'+    let userData = castFunPtrToPtr maybeSetter+    let destroyNotify = safeFreeFunPtrPtr+    jsc_value_object_define_property_accessor value' propertyName' flags' propertyType' maybeGetter maybeSetter userData destroyNotify+    touchManagedPtr value+    freeMem propertyName'+    return ()++#if ENABLE_OVERLOADING+data ValueObjectDefinePropertyAccessorMethodInfo+instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> GType -> Maybe (GObject.Callbacks.Callback) -> Maybe (GObject.Callbacks.Callback) -> m ()), MonadIO m, IsValue a) => O.MethodInfo ValueObjectDefinePropertyAccessorMethodInfo a signature where+    overloadedMethod _ = valueObjectDefinePropertyAccessor++#endif++-- method Value::object_define_property_data+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the property to define", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#JSCValuePropertyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the default property value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_define_property_data" jsc_value_object_define_property_data :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- property_name : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface (Name {namespace = "JavaScriptCore", name = "ValuePropertyFlags"})+    Ptr Value ->                            -- property_value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO ()++{- |+Define or modify a property with /@propertyName@/ in object referenced by /@value@/. This is equivalent to+JavaScript \<function>Object.@/defineProperty()/@\<\/function> when used with a data descriptor.+-}+valueObjectDefinePropertyData ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@propertyName@/: the name of the property to define -}+    -> [JavaScriptCore.Flags.ValuePropertyFlags]+    {- ^ /@flags@/: 'GI.JavaScriptCore.Flags.ValuePropertyFlags' -}+    -> Maybe (b)+    {- ^ /@propertyValue@/: the default property value -}+    -> m ()+valueObjectDefinePropertyData value propertyName flags propertyValue = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    propertyName' <- textToCString propertyName+    let flags' = gflagsToWord flags+    maybePropertyValue <- case propertyValue of+        Nothing -> return nullPtr+        Just jPropertyValue -> do+            jPropertyValue' <- unsafeManagedPtrCastPtr jPropertyValue+            return jPropertyValue'+    jsc_value_object_define_property_data value' propertyName' flags' maybePropertyValue+    touchManagedPtr value+    whenJust propertyValue touchManagedPtr+    freeMem propertyName'+    return ()++#if ENABLE_OVERLOADING+data ValueObjectDefinePropertyDataMethodInfo+instance (signature ~ (T.Text -> [JavaScriptCore.Flags.ValuePropertyFlags] -> Maybe (b) -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectDefinePropertyDataMethodInfo a signature where+    overloadedMethod _ = valueObjectDefinePropertyData++#endif++-- method Value::object_delete_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_delete_property" jsc_value_object_delete_property :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    IO CInt++{- |+Try to delete property with /@name@/ from /@value@/. This function will return 'False' if+the property was defined without 'GI.JavaScriptCore.Flags.ValuePropertyFlagsConfigurable' flag.+-}+valueObjectDeleteProperty ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m Bool+    {- ^ __Returns:__ 'True' if the property was deleted, or 'False' otherwise. -}+valueObjectDeleteProperty value name = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    result <- jsc_value_object_delete_property value' name'+    let result' = (/= 0) result+    touchManagedPtr value+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ValueObjectDeletePropertyMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectDeletePropertyMethodInfo a signature where+    overloadedMethod _ = valueObjectDeleteProperty++#endif++-- method Value::object_enumerate_properties+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_enumerate_properties" jsc_value_object_enumerate_properties :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO (Ptr CString)++{- |+Get the list of property names of /@value@/. Only properties defined with 'GI.JavaScriptCore.Flags.ValuePropertyFlagsEnumerable'+flag will be collected.+-}+valueObjectEnumerateProperties ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m (Maybe [T.Text])+    {- ^ __Returns:__ a 'Nothing'-terminated array of strings containing the+   property names, or 'Nothing' if /@value@/ doesn\'t have enumerable properties.  Use 'GI.GLib.Functions.strfreev' to free. -}+valueObjectEnumerateProperties value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_object_enumerate_properties value'+    maybeResult <- convertIfNonNull result $ \result' -> do+        result'' <- unpackZeroTerminatedUTF8CArray result'+        mapZeroTerminatedCArray freeMem result'+        freeMem result'+        return result''+    touchManagedPtr value+    return maybeResult++#if ENABLE_OVERLOADING+data ValueObjectEnumeratePropertiesMethodInfo+instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsValue a) => O.MethodInfo ValueObjectEnumeratePropertiesMethodInfo a signature where+    overloadedMethod _ = valueObjectEnumerateProperties++#endif++-- method Value::object_get_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_get_property" jsc_value_object_get_property :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Value)++{- |+Get property with /@name@/ from /@value@/.+-}+valueObjectGetProperty ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m Value+    {- ^ __Returns:__ the property 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueObjectGetProperty value name = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    result <- jsc_value_object_get_property value' name'+    checkUnexpectedReturnNULL "valueObjectGetProperty" result+    result' <- (wrapObject Value) result+    touchManagedPtr value+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ValueObjectGetPropertyMethodInfo+instance (signature ~ (T.Text -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectGetPropertyMethodInfo a signature where+    overloadedMethod _ = valueObjectGetProperty++#endif++-- method Value::object_get_property_at_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_get_property_at_index" jsc_value_object_get_property_at_index :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    Word32 ->                               -- index : TBasicType TUInt+    IO (Ptr Value)++{- |+Get property at /@index@/ from /@value@/.+-}+valueObjectGetPropertyAtIndex ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> Word32+    {- ^ /@index@/: the property index -}+    -> m Value+    {- ^ __Returns:__ the property 'GI.JavaScriptCore.Objects.Value.Value'. -}+valueObjectGetPropertyAtIndex value index = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_object_get_property_at_index value' index+    checkUnexpectedReturnNULL "valueObjectGetPropertyAtIndex" result+    result' <- (wrapObject Value) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueObjectGetPropertyAtIndexMethodInfo+instance (signature ~ (Word32 -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectGetPropertyAtIndexMethodInfo a signature where+    overloadedMethod _ = valueObjectGetPropertyAtIndex++#endif++-- method Value::object_has_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_has_property" jsc_value_object_has_property :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    IO CInt++{- |+Get whether /@value@/ has property with /@name@/.+-}+valueObjectHasProperty ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> m Bool+    {- ^ __Returns:__ 'True' if /@value@/ has a property with /@name@/, or 'False' otherwise -}+valueObjectHasProperty value name = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    result <- jsc_value_object_has_property value' name'+    let result' = (/= 0) result+    touchManagedPtr value+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ValueObjectHasPropertyMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectHasPropertyMethodInfo a signature where+    overloadedMethod _ = valueObjectHasProperty++#endif++-- method Value::object_invoke_method+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the method name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parameters", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #JSCValue<!-- -->s to pass as parameters to the method, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_parameters", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of parameters", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_invoke_methodv" jsc_value_object_invoke_methodv :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    Word32 ->                               -- n_parameters : TBasicType TUInt+    Ptr (Ptr Value) ->                      -- parameters : TCArray False (-1) 2 (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+    IO (Ptr Value)++{- |+Invoke method with /@name@/ on object referenced by /@value@/, passing the given /@parameters@/. If+/@nParameters@/ is 0 no parameters will be passed to the method.+The object instance will be handled automatically even when the method is a custom one+registered with @/jsc_class_add_method()/@, so it should never be passed explicitly as parameter+of this function.++This function always returns a 'GI.JavaScriptCore.Objects.Value.Value', in case of void methods a 'GI.JavaScriptCore.Objects.Value.Value' referencing+\<function>undefined\<\/function> is returned.+-}+valueObjectInvokeMethod ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: the method name -}+    -> Maybe ([Value])+    {- ^ /@parameters@/: the 'GI.JavaScriptCore.Objects.Value.Value'\<!-- -->s to pass as parameters to the method, or 'Nothing' -}+    -> m Value+    {- ^ __Returns:__ a 'GI.JavaScriptCore.Objects.Value.Value' with the return value of the method. -}+valueObjectInvokeMethod value name parameters = liftIO $ do+    let nParameters = case parameters of+            Nothing -> 0+            Just jParameters -> fromIntegral $ length jParameters+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    maybeParameters <- case parameters of+        Nothing -> return nullPtr+        Just jParameters -> do+            jParameters' <- mapM unsafeManagedPtrCastPtr jParameters+            jParameters'' <- packPtrArray jParameters'+            return jParameters''+    result <- jsc_value_object_invoke_methodv value' name' nParameters maybeParameters+    checkUnexpectedReturnNULL "valueObjectInvokeMethod" result+    result' <- (wrapObject Value) result+    touchManagedPtr value+    whenJust parameters (mapM_ touchManagedPtr)+    freeMem name'+    freeMem maybeParameters+    return result'++#if ENABLE_OVERLOADING+data ValueObjectInvokeMethodMethodInfo+instance (signature ~ (T.Text -> Maybe ([Value]) -> m Value), MonadIO m, IsValue a) => O.MethodInfo ValueObjectInvokeMethodMethodInfo a signature where+    overloadedMethod _ = valueObjectInvokeMethod++#endif++-- method Value::object_is_instance_of+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a class name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_is_instance_of" jsc_value_object_is_instance_of :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    IO CInt++{- |+Get whether the value referenced by /@value@/ is an instance of class /@name@/.+-}+valueObjectIsInstanceOf ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: a class name -}+    -> m Bool+    {- ^ __Returns:__ whether the value is an object instance of class /@name@/. -}+valueObjectIsInstanceOf value name = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    result <- jsc_value_object_is_instance_of value' name'+    let result' = (/= 0) result+    touchManagedPtr value+    freeMem name'+    return result'++#if ENABLE_OVERLOADING+data ValueObjectIsInstanceOfMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueObjectIsInstanceOfMethodInfo a signature where+    overloadedMethod _ = valueObjectIsInstanceOf++#endif++-- method Value::object_set_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_set_property" jsc_value_object_set_property :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    CString ->                              -- name : TBasicType TUTF8+    Ptr Value ->                            -- property : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO ()++{- |+Set /@property@/ with /@name@/ on /@value@/.+-}+valueObjectSetProperty ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> T.Text+    {- ^ /@name@/: the property name -}+    -> b+    {- ^ /@property@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -}+    -> m ()+valueObjectSetProperty value name property = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    name' <- textToCString name+    property' <- unsafeManagedPtrCastPtr property+    jsc_value_object_set_property value' name' property'+    touchManagedPtr value+    touchManagedPtr property+    freeMem name'+    return ()++#if ENABLE_OVERLOADING+data ValueObjectSetPropertyMethodInfo+instance (signature ~ (T.Text -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectSetPropertyMethodInfo a signature where+    overloadedMethod _ = valueObjectSetProperty++#endif++-- method Value::object_set_property_at_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the property index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #JSCValue to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Nothing+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_object_set_property_at_index" jsc_value_object_set_property_at_index :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    Word32 ->                               -- index : TBasicType TUInt+    Ptr Value ->                            -- property : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO ()++{- |+Set /@property@/ at /@index@/ on /@value@/.+-}+valueObjectSetPropertyAtIndex ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a, IsValue b) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> Word32+    {- ^ /@index@/: the property index -}+    -> b+    {- ^ /@property@/: the 'GI.JavaScriptCore.Objects.Value.Value' to set -}+    -> m ()+valueObjectSetPropertyAtIndex value index property = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    property' <- unsafeManagedPtrCastPtr property+    jsc_value_object_set_property_at_index value' index property'+    touchManagedPtr value+    touchManagedPtr property+    return ()++#if ENABLE_OVERLOADING+data ValueObjectSetPropertyAtIndexMethodInfo+instance (signature ~ (Word32 -> b -> m ()), MonadIO m, IsValue a, IsValue b) => O.MethodInfo ValueObjectSetPropertyAtIndexMethodInfo a signature where+    overloadedMethod _ = valueObjectSetPropertyAtIndex++#endif++-- method Value::to_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TBoolean)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_to_boolean" jsc_value_to_boolean :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CInt++{- |+Convert /@value@/ to a boolean.+-}+valueToBoolean ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Bool+    {- ^ __Returns:__ a 'Bool' result of the conversion. -}+valueToBoolean value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_to_boolean value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueToBooleanMethodInfo+instance (signature ~ (m Bool), MonadIO m, IsValue a) => O.MethodInfo ValueToBooleanMethodInfo a signature where+    overloadedMethod _ = valueToBoolean++#endif++-- method Value::to_double+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_to_double" jsc_value_to_double :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CDouble++{- |+Convert /@value@/ to a double.+-}+valueToDouble ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Double+    {- ^ __Returns:__ a @/gdouble/@ result of the conversion. -}+valueToDouble value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_to_double value'+    let result' = realToFrac result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueToDoubleMethodInfo+instance (signature ~ (m Double), MonadIO m, IsValue a) => O.MethodInfo ValueToDoubleMethodInfo a signature where+    overloadedMethod _ = valueToDouble++#endif++-- method Value::to_int32+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TInt32)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_to_int32" jsc_value_to_int32 :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO Int32++{- |+Convert /@value@/ to a @/gint32/@.+-}+valueToInt32 ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m Int32+    {- ^ __Returns:__ a @/gint32/@ result of the conversion. -}+valueToInt32 value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_to_int32 value'+    touchManagedPtr value+    return result++#if ENABLE_OVERLOADING+data ValueToInt32MethodInfo+instance (signature ~ (m Int32), MonadIO m, IsValue a) => O.MethodInfo ValueToInt32MethodInfo a signature where+    overloadedMethod _ = valueToInt32++#endif++-- method Value::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_to_string" jsc_value_to_string :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO CString++{- |+Convert /@value@/ to a string. Use 'GI.JavaScriptCore.Objects.Value.valueToStringAsBytes' instead, if you need to+handle strings containing null characters.+-}+valueToString ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m T.Text+    {- ^ __Returns:__ a null-terminated string result of the conversion. -}+valueToString value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_to_string value'+    checkUnexpectedReturnNULL "valueToString" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, IsValue a) => O.MethodInfo ValueToStringMethodInfo a signature where+    overloadedMethod _ = valueToString++#endif++-- method Value::to_string_as_bytes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Bytes"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_value_to_string_as_bytes" jsc_value_to_string_as_bytes :: +    Ptr Value ->                            -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO (Ptr GLib.Bytes.Bytes)++{- |+Convert /@value@/ to a string and return the results as 'GI.GLib.Structs.Bytes.Bytes'. This is needed+to handle strings with null characters.+-}+valueToStringAsBytes ::+    (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m GLib.Bytes.Bytes+    {- ^ __Returns:__ a 'GI.GLib.Structs.Bytes.Bytes' with the result of the conversion. -}+valueToStringAsBytes value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_value_to_string_as_bytes value'+    checkUnexpectedReturnNULL "valueToStringAsBytes" result+    result' <- (wrapBoxed GLib.Bytes.Bytes) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+data ValueToStringAsBytesMethodInfo+instance (signature ~ (m GLib.Bytes.Bytes), MonadIO m, IsValue a) => O.MethodInfo ValueToStringAsBytesMethodInfo a signature where+    overloadedMethod _ = valueToStringAsBytes++#endif++

@@ -0,0 +1,116 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.Value 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype Value = Value (ManagedPtr Value)+instance GObject Value where+class (GObject o, O.IsDescendantOf Value o) => IsValue o+instance (GObject o, O.IsDescendantOf Value o) => IsValue o+instance O.HasParentTypes Value+#if ENABLE_OVERLOADING+data ValueContextPropertyInfo+#endif+#if ENABLE_OVERLOADING+data ValueConstructorCallMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueFunctionCallMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueGetContextMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsArrayMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsBooleanMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsConstructorMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsFunctionMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsNullMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsNumberMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsObjectMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsStringMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueIsUndefinedMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectDefinePropertyAccessorMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectDefinePropertyDataMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectDeletePropertyMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectEnumeratePropertiesMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectGetPropertyMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectGetPropertyAtIndexMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectHasPropertyMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectInvokeMethodMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectIsInstanceOfMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectSetPropertyMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueObjectSetPropertyAtIndexMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueToBooleanMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueToDoubleMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueToInt32MethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueToStringMethodInfo+#endif+#if ENABLE_OVERLOADING+data ValueToStringAsBytesMethodInfo+#endif

@@ -0,0 +1,156 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.VirtualMachine+    ( ++-- * Exported types+    VirtualMachine(..)                      ,+    IsVirtualMachine                        ,+    toVirtualMachine                        ,+    noVirtualMachine                        ,+++ -- * Methods+-- ** new #method:new#++    virtualMachineNew                       ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object++-- | Memory-managed wrapper type.+newtype VirtualMachine = VirtualMachine (ManagedPtr VirtualMachine)+foreign import ccall "jsc_virtual_machine_get_type"+    c_jsc_virtual_machine_get_type :: IO GType++instance GObject VirtualMachine where+    gobjectType = c_jsc_virtual_machine_get_type+    ++-- | Type class for types which can be safely cast to `VirtualMachine`, for instance with `toVirtualMachine`.+class (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o+instance (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o++instance O.HasParentTypes VirtualMachine+type instance O.ParentTypes VirtualMachine = '[GObject.Object.Object]++-- | Cast to `VirtualMachine`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toVirtualMachine :: (MonadIO m, IsVirtualMachine o) => o -> m VirtualMachine+toVirtualMachine = liftIO . unsafeCastTo VirtualMachine++-- | A convenience alias for `Nothing` :: `Maybe` `VirtualMachine`.+noVirtualMachine :: Maybe VirtualMachine+noVirtualMachine = Nothing++#if ENABLE_OVERLOADING+type family ResolveVirtualMachineMethod (t :: Symbol) (o :: *) :: * where+    ResolveVirtualMachineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveVirtualMachineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveVirtualMachineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveVirtualMachineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveVirtualMachineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveVirtualMachineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveVirtualMachineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveVirtualMachineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveVirtualMachineMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveVirtualMachineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveVirtualMachineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveVirtualMachineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveVirtualMachineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveVirtualMachineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveVirtualMachineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveVirtualMachineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveVirtualMachineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveVirtualMachineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveVirtualMachineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveVirtualMachineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveVirtualMachineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveVirtualMachineMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveVirtualMachineMethod t VirtualMachine, O.MethodInfo info VirtualMachine p) => OL.IsLabel t (VirtualMachine -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList VirtualMachine+type instance O.AttributeList VirtualMachine = VirtualMachineAttributeList+type VirtualMachineAttributeList = ('[ ] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+#endif++#if ENABLE_OVERLOADING+type instance O.SignalList VirtualMachine = VirtualMachineSignalList+type VirtualMachineSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method VirtualMachine::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "VirtualMachine"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_virtual_machine_new" jsc_virtual_machine_new :: +    IO (Ptr VirtualMachine)++{- |+Create a new 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'.+-}+virtualMachineNew ::+    (B.CallStack.HasCallStack, MonadIO m) =>+    m VirtualMachine+    {- ^ __Returns:__ the newly created 'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'. -}+virtualMachineNew  = liftIO $ do+    result <- jsc_virtual_machine_new+    checkUnexpectedReturnNULL "virtualMachineNew" result+    result' <- (wrapObject VirtualMachine) result+    return result'++#if ENABLE_OVERLOADING+#endif++

@@ -0,0 +1,29 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.VirtualMachine 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype VirtualMachine = VirtualMachine (ManagedPtr VirtualMachine)+instance GObject VirtualMachine where+class (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o+instance (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o+instance O.HasParentTypes VirtualMachine

@@ -0,0 +1,342 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)++/No description available in the introspection data./+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Objects.WeakValue+    ( ++-- * Exported types+    WeakValue(..)                           ,+    IsWeakValue                             ,+    toWeakValue                             ,+    noWeakValue                             ,+++ -- * Methods+-- ** getValue #method:getValue#++#if ENABLE_OVERLOADING+    WeakValueGetValueMethodInfo             ,+#endif+    weakValueGetValue                       ,+++-- ** new #method:new#++    weakValueNew                            ,+++++ -- * Properties+-- ** value #attr:value#+{- | The 'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value.+-}+#if ENABLE_OVERLOADING+    WeakValueValuePropertyInfo              ,+#endif+    constructWeakValueValue                 ,+#if ENABLE_OVERLOADING+    weakValueValue                          ,+#endif+++++ -- * Signals+-- ** cleared #signal:cleared#++    C_WeakValueClearedCallback              ,+    WeakValueClearedCallback                ,+#if ENABLE_OVERLOADING+    WeakValueClearedSignalInfo              ,+#endif+    afterWeakValueCleared                   ,+    genClosure_WeakValueCleared             ,+    mk_WeakValueClearedCallback             ,+    noWeakValueClearedCallback              ,+    onWeakValueCleared                      ,+    wrap_WeakValueClearedCallback           ,+++++    ) 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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 GI.GObject.Objects.Object as GObject.Object+import {-# SOURCE #-} qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value++-- | Memory-managed wrapper type.+newtype WeakValue = WeakValue (ManagedPtr WeakValue)+foreign import ccall "jsc_weak_value_get_type"+    c_jsc_weak_value_get_type :: IO GType++instance GObject WeakValue where+    gobjectType = c_jsc_weak_value_get_type+    ++-- | Type class for types which can be safely cast to `WeakValue`, for instance with `toWeakValue`.+class (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o+instance (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o++instance O.HasParentTypes WeakValue+type instance O.ParentTypes WeakValue = '[GObject.Object.Object]++-- | Cast to `WeakValue`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.+toWeakValue :: (MonadIO m, IsWeakValue o) => o -> m WeakValue+toWeakValue = liftIO . unsafeCastTo WeakValue++-- | A convenience alias for `Nothing` :: `Maybe` `WeakValue`.+noWeakValue :: Maybe WeakValue+noWeakValue = Nothing++#if ENABLE_OVERLOADING+type family ResolveWeakValueMethod (t :: Symbol) (o :: *) :: * where+    ResolveWeakValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo+    ResolveWeakValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo+    ResolveWeakValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo+    ResolveWeakValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo+    ResolveWeakValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo+    ResolveWeakValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo+    ResolveWeakValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo+    ResolveWeakValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo+    ResolveWeakValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo+    ResolveWeakValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo+    ResolveWeakValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo+    ResolveWeakValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo+    ResolveWeakValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo+    ResolveWeakValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo+    ResolveWeakValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo+    ResolveWeakValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo+    ResolveWeakValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo+    ResolveWeakValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo+    ResolveWeakValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo+    ResolveWeakValueMethod "getValue" o = WeakValueGetValueMethodInfo+    ResolveWeakValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo+    ResolveWeakValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo+    ResolveWeakValueMethod l o = O.MethodResolutionFailed l o++instance (info ~ ResolveWeakValueMethod t WeakValue, O.MethodInfo info WeakValue p) => OL.IsLabel t (WeakValue -> p) where+#if MIN_VERSION_base(4,10,0)+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#else+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)+#endif++#endif++-- signal WeakValue::cleared+{- |+This signal is emitted when the JavaScript value is destroyed.+-}+type WeakValueClearedCallback =+    IO ()++-- | A convenience synonym for @`Nothing` :: `Maybe` `WeakValueClearedCallback`@.+noWeakValueClearedCallback :: Maybe WeakValueClearedCallback+noWeakValueClearedCallback = Nothing++-- | Type for the callback on the (unwrapped) C side.+type C_WeakValueClearedCallback =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++-- | Generate a function pointer callable from C code, from a `C_WeakValueClearedCallback`.+foreign import ccall "wrapper"+    mk_WeakValueClearedCallback :: C_WeakValueClearedCallback -> IO (FunPtr C_WeakValueClearedCallback)++-- | Wrap the callback into a `GClosure`.+genClosure_WeakValueCleared :: MonadIO m => WeakValueClearedCallback -> m (GClosure C_WeakValueClearedCallback)+genClosure_WeakValueCleared cb = liftIO $ do+    let cb' = wrap_WeakValueClearedCallback cb+    mk_WeakValueClearedCallback cb' >>= B.GClosure.newGClosure+++-- | Wrap a `WeakValueClearedCallback` into a `C_WeakValueClearedCallback`.+wrap_WeakValueClearedCallback ::+    WeakValueClearedCallback ->+    C_WeakValueClearedCallback+wrap_WeakValueClearedCallback _cb _ _ = do+    _cb +++{- |+Connect a signal handler for the “@cleared@” signal, to be run before the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.on' weakValue #cleared callback+@+-}+onWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId+onWeakValueCleared obj cb = liftIO $ do+    let cb' = wrap_WeakValueClearedCallback cb+    cb'' <- mk_WeakValueClearedCallback cb'+    connectSignalFunPtr obj "cleared" cb'' SignalConnectBefore++{- |+Connect a signal handler for the “@cleared@” signal, to be run after the default handler.+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to++@+'Data.GI.Base.Signals.after' weakValue #cleared callback+@+-}+afterWeakValueCleared :: (IsWeakValue a, MonadIO m) => a -> WeakValueClearedCallback -> m SignalHandlerId+afterWeakValueCleared obj cb = liftIO $ do+    let cb' = wrap_WeakValueClearedCallback cb+    cb'' <- mk_WeakValueClearedCallback cb'+    connectSignalFunPtr obj "cleared" cb'' SignalConnectAfter+++-- VVV Prop "value"+   -- Type: TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+   -- Flags: [PropertyWritable,PropertyConstructOnly]+   -- Nullable: (Nothing,Nothing)++{- |+Construct a `GValueConstruct` with valid value for the “@value@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.+-}+constructWeakValueValue :: (IsWeakValue o, JavaScriptCore.Value.IsValue a) => a -> IO (GValueConstruct o)+constructWeakValueValue val = B.Properties.constructObjectPropertyObject "value" (Just val)++#if ENABLE_OVERLOADING+data WeakValueValuePropertyInfo+instance AttrInfo WeakValueValuePropertyInfo where+    type AttrAllowedOps WeakValueValuePropertyInfo = '[ 'AttrConstruct, 'AttrClear]+    type AttrSetTypeConstraint WeakValueValuePropertyInfo = JavaScriptCore.Value.IsValue+    type AttrBaseTypeConstraint WeakValueValuePropertyInfo = IsWeakValue+    type AttrGetType WeakValueValuePropertyInfo = ()+    type AttrLabel WeakValueValuePropertyInfo = "value"+    type AttrOrigin WeakValueValuePropertyInfo = WeakValue+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructWeakValueValue+    attrClear _ = undefined+#endif++#if ENABLE_OVERLOADING+instance O.HasAttributeList WeakValue+type instance O.AttributeList WeakValue = WeakValueAttributeList+type WeakValueAttributeList = ('[ '("value", WeakValueValuePropertyInfo)] :: [(Symbol, *)])+#endif++#if ENABLE_OVERLOADING+weakValueValue :: AttrLabelProxy "value"+weakValueValue = AttrLabelProxy++#endif++#if ENABLE_OVERLOADING+data WeakValueClearedSignalInfo+instance SignalInfo WeakValueClearedSignalInfo where+    type HaskellCallbackType WeakValueClearedSignalInfo = WeakValueClearedCallback+    connectSignal _ obj cb connectMode = do+        let cb' = wrap_WeakValueClearedCallback cb+        cb'' <- mk_WeakValueClearedCallback cb'+        connectSignalFunPtr obj "cleared" cb'' connectMode++type instance O.SignalList WeakValue = WeakValueSignalList+type WeakValueSignalList = ('[ '("cleared", WeakValueClearedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])++#endif++-- method WeakValue::new+-- method type : Constructor+-- Args : [Arg {argCName = "value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_weak_value_new" jsc_weak_value_new :: +    Ptr JavaScriptCore.Value.Value ->       -- value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})+    IO (Ptr WeakValue)++{- |+Create a new 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' for the JavaScript value referenced by /@value@/.+-}+weakValueNew ::+    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) =>+    a+    {- ^ /@value@/: a 'GI.JavaScriptCore.Objects.Value.Value' -}+    -> m WeakValue+    {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' -}+weakValueNew value = liftIO $ do+    value' <- unsafeManagedPtrCastPtr value+    result <- jsc_weak_value_new value'+    checkUnexpectedReturnNULL "weakValueNew" result+    result' <- (wrapObject WeakValue) result+    touchManagedPtr value+    return result'++#if ENABLE_OVERLOADING+#endif++-- method WeakValue::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "weak_value", argType = TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #JSCWeakValue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : Just (TInterface (Name {namespace = "JavaScriptCore", name = "Value"}))+-- throws : False+-- Skip return : False++foreign import ccall "jsc_weak_value_get_value" jsc_weak_value_get_value :: +    Ptr WeakValue ->                        -- weak_value : TInterface (Name {namespace = "JavaScriptCore", name = "WeakValue"})+    IO (Ptr JavaScriptCore.Value.Value)++{- |+Get a 'GI.JavaScriptCore.Objects.Value.Value' referencing the JavaScript value of /@weakValue@/.+-}+weakValueGetValue ::+    (B.CallStack.HasCallStack, MonadIO m, IsWeakValue a) =>+    a+    {- ^ /@weakValue@/: a 'GI.JavaScriptCore.Objects.WeakValue.WeakValue' -}+    -> m JavaScriptCore.Value.Value+    {- ^ __Returns:__ a new 'GI.JavaScriptCore.Objects.Value.Value' or 'Nothing' if /@weakValue@/ was cleared. -}+weakValueGetValue weakValue = liftIO $ do+    weakValue' <- unsafeManagedPtrCastPtr weakValue+    result <- jsc_weak_value_get_value weakValue'+    checkUnexpectedReturnNULL "weakValueGetValue" result+    result' <- (wrapObject JavaScriptCore.Value.Value) result+    touchManagedPtr weakValue+    return result'++#if ENABLE_OVERLOADING+data WeakValueGetValueMethodInfo+instance (signature ~ (m JavaScriptCore.Value.Value), MonadIO m, IsWeakValue a) => O.MethodInfo WeakValueGetValueMethodInfo a signature where+    overloadedMethod _ = weakValueGetValue++#endif++

@@ -0,0 +1,38 @@+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))+module GI.JavaScriptCore.Objects.WeakValue 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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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++newtype WeakValue = WeakValue (ManagedPtr WeakValue)+instance GObject WeakValue where+class (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o+instance (GObject o, O.IsDescendantOf WeakValue o) => IsWeakValue o+instance O.HasParentTypes WeakValue+#if ENABLE_OVERLOADING+data WeakValueValuePropertyInfo+#endif+#if ENABLE_OVERLOADING+data WeakValueClearedSignalInfo+#endif+#if ENABLE_OVERLOADING+data WeakValueGetValueMethodInfo+#endif

@@ -0,0 +1,41 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)+-}++#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \+       && !defined(__HADDOCK_VERSION__))++module GI.JavaScriptCore.Structs+    (     module GI.JavaScriptCore.Structs.ClassVTable,+++    ) where++import GI.JavaScriptCore.Structs.ClassVTable++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.ManagedPtr as B.ManagedPtr+import qualified Data.GI.Base.GClosure as B.GClosure+import qualified Data.GI.Base.GError as B.GError+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.Text as T+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+++