{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A reply for a script message received.
-- If no reply has been sent by the user, an automatically generated reply with
-- undefined value with be sent.
-- 
-- /Since: 2.40/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.WebKit.Structs.ScriptMessageReply
    ( 

-- * Exported types
    ScriptMessageReply(..)                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [ref]("GI.WebKit.Structs.ScriptMessageReply#g:method:ref"), [returnErrorMessage]("GI.WebKit.Structs.ScriptMessageReply#g:method:returnErrorMessage"), [returnValue]("GI.WebKit.Structs.ScriptMessageReply#g:method:returnValue"), [unref]("GI.WebKit.Structs.ScriptMessageReply#g:method:unref").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveScriptMessageReplyMethod         ,
#endif

-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    ScriptMessageReplyRefMethodInfo         ,
#endif
    scriptMessageReplyRef                   ,


-- ** returnErrorMessage #method:returnErrorMessage#

#if defined(ENABLE_OVERLOADING)
    ScriptMessageReplyReturnErrorMessageMethodInfo,
#endif
    scriptMessageReplyReturnErrorMessage    ,


-- ** returnValue #method:returnValue#

#if defined(ENABLE_OVERLOADING)
    ScriptMessageReplyReturnValueMethodInfo ,
#endif
    scriptMessageReplyReturnValue           ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    ScriptMessageReplyUnrefMethodInfo       ,
#endif
    scriptMessageReplyUnref                 ,




    ) where

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

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

import qualified GI.JavaScriptCore.Objects.Value as JavaScriptCore.Value

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

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

foreign import ccall "webkit_script_message_reply_get_type" c_webkit_script_message_reply_get_type :: 
    IO GType

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

instance B.Types.TypedObject ScriptMessageReply where
    glibType :: IO GType
glibType = IO GType
c_webkit_script_message_reply_get_type

instance B.Types.GBoxed ScriptMessageReply

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


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

-- method ScriptMessageReply::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "script_message_reply"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit" , name = "ScriptMessageReply" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitScriptMessageReply"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "WebKit" , name = "ScriptMessageReply" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_script_message_reply_ref" webkit_script_message_reply_ref :: 
    Ptr ScriptMessageReply ->               -- script_message_reply : TInterface (Name {namespace = "WebKit", name = "ScriptMessageReply"})
    IO (Ptr ScriptMessageReply)

-- | Atomically increments the reference count of /@scriptMessageReply@/ by one.
-- 
-- /Since: 2.40/
scriptMessageReplyRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ScriptMessageReply
    -- ^ /@scriptMessageReply@/: A t'GI.WebKit.Structs.ScriptMessageReply.ScriptMessageReply'
    -> m ScriptMessageReply
    -- ^ __Returns:__ the /@scriptMessageReply@/ passed in.
scriptMessageReplyRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptMessageReply -> m ScriptMessageReply
scriptMessageReplyRef ScriptMessageReply
scriptMessageReply = IO ScriptMessageReply -> m ScriptMessageReply
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScriptMessageReply -> m ScriptMessageReply)
-> IO ScriptMessageReply -> m ScriptMessageReply
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptMessageReply
scriptMessageReply' <- ScriptMessageReply -> IO (Ptr ScriptMessageReply)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptMessageReply
scriptMessageReply
    Ptr ScriptMessageReply
result <- Ptr ScriptMessageReply -> IO (Ptr ScriptMessageReply)
webkit_script_message_reply_ref Ptr ScriptMessageReply
scriptMessageReply'
    Text -> Ptr ScriptMessageReply -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scriptMessageReplyRef" Ptr ScriptMessageReply
result
    ScriptMessageReply
result' <- ((ManagedPtr ScriptMessageReply -> ScriptMessageReply)
-> Ptr ScriptMessageReply -> IO ScriptMessageReply
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ScriptMessageReply -> ScriptMessageReply
ScriptMessageReply) Ptr ScriptMessageReply
result
    ScriptMessageReply -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptMessageReply
scriptMessageReply
    ScriptMessageReply -> IO ScriptMessageReply
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptMessageReply
result'

#if defined(ENABLE_OVERLOADING)
data ScriptMessageReplyRefMethodInfo
instance (signature ~ (m ScriptMessageReply), MonadIO m) => O.OverloadedMethod ScriptMessageReplyRefMethodInfo ScriptMessageReply signature where
    overloadedMethod = scriptMessageReplyRef

instance O.OverloadedMethodInfo ScriptMessageReplyRefMethodInfo ScriptMessageReply where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit.Structs.ScriptMessageReply.scriptMessageReplyRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit-6.0.2/docs/GI-WebKit-Structs-ScriptMessageReply.html#v:scriptMessageReplyRef"
        })


#endif

-- method ScriptMessageReply::return_error_message
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "script_message_reply"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit" , name = "ScriptMessageReply" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitScriptMessageReply"
--                 , 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 to return as specified by the user's script message"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_script_message_reply_return_error_message" webkit_script_message_reply_return_error_message :: 
    Ptr ScriptMessageReply ->               -- script_message_reply : TInterface (Name {namespace = "WebKit", name = "ScriptMessageReply"})
    CString ->                              -- error_message : TBasicType TUTF8
    IO ()

-- | Reply to a script message with an error message.
-- 
-- /Since: 2.40/
scriptMessageReplyReturnErrorMessage ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ScriptMessageReply
    -- ^ /@scriptMessageReply@/: A t'GI.WebKit.Structs.ScriptMessageReply.ScriptMessageReply'
    -> T.Text
    -- ^ /@errorMessage@/: An error message to return as specified by the user\'s script message
    -> m ()
scriptMessageReplyReturnErrorMessage :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptMessageReply -> Text -> m ()
scriptMessageReplyReturnErrorMessage ScriptMessageReply
scriptMessageReply Text
errorMessage = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptMessageReply
scriptMessageReply' <- ScriptMessageReply -> IO (Ptr ScriptMessageReply)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptMessageReply
scriptMessageReply
    CString
errorMessage' <- Text -> IO CString
textToCString Text
errorMessage
    Ptr ScriptMessageReply -> CString -> IO ()
webkit_script_message_reply_return_error_message Ptr ScriptMessageReply
scriptMessageReply' CString
errorMessage'
    ScriptMessageReply -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptMessageReply
scriptMessageReply
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
errorMessage'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScriptMessageReplyReturnErrorMessageMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod ScriptMessageReplyReturnErrorMessageMethodInfo ScriptMessageReply signature where
    overloadedMethod = scriptMessageReplyReturnErrorMessage

instance O.OverloadedMethodInfo ScriptMessageReplyReturnErrorMessageMethodInfo ScriptMessageReply where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit.Structs.ScriptMessageReply.scriptMessageReplyReturnErrorMessage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit-6.0.2/docs/GI-WebKit-Structs-ScriptMessageReply.html#v:scriptMessageReplyReturnErrorMessage"
        })


#endif

-- method ScriptMessageReply::return_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "script_message_reply"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit" , name = "ScriptMessageReply" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitScriptMessageReply"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reply_value"
--           , argType =
--               TInterface Name { namespace = "JavaScriptCore" , name = "Value" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Reply value of the provided script message"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_script_message_reply_return_value" webkit_script_message_reply_return_value :: 
    Ptr ScriptMessageReply ->               -- script_message_reply : TInterface (Name {namespace = "WebKit", name = "ScriptMessageReply"})
    Ptr JavaScriptCore.Value.Value ->       -- reply_value : TInterface (Name {namespace = "JavaScriptCore", name = "Value"})
    IO ()

-- | Reply to a script message with a value.
-- 
-- This function can be called twice for passing the reply value in.
-- 
-- /Since: 2.40/
scriptMessageReplyReturnValue ::
    (B.CallStack.HasCallStack, MonadIO m, JavaScriptCore.Value.IsValue a) =>
    ScriptMessageReply
    -- ^ /@scriptMessageReply@/: A t'GI.WebKit.Structs.ScriptMessageReply.ScriptMessageReply'
    -> a
    -- ^ /@replyValue@/: Reply value of the provided script message
    -> m ()
scriptMessageReplyReturnValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsValue a) =>
ScriptMessageReply -> a -> m ()
scriptMessageReplyReturnValue ScriptMessageReply
scriptMessageReply a
replyValue = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptMessageReply
scriptMessageReply' <- ScriptMessageReply -> IO (Ptr ScriptMessageReply)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptMessageReply
scriptMessageReply
    Ptr Value
replyValue' <- a -> IO (Ptr Value)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
replyValue
    Ptr ScriptMessageReply -> Ptr Value -> IO ()
webkit_script_message_reply_return_value Ptr ScriptMessageReply
scriptMessageReply' Ptr Value
replyValue'
    ScriptMessageReply -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptMessageReply
scriptMessageReply
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
replyValue
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScriptMessageReplyReturnValueMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, JavaScriptCore.Value.IsValue a) => O.OverloadedMethod ScriptMessageReplyReturnValueMethodInfo ScriptMessageReply signature where
    overloadedMethod = scriptMessageReplyReturnValue

instance O.OverloadedMethodInfo ScriptMessageReplyReturnValueMethodInfo ScriptMessageReply where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit.Structs.ScriptMessageReply.scriptMessageReplyReturnValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit-6.0.2/docs/GI-WebKit-Structs-ScriptMessageReply.html#v:scriptMessageReplyReturnValue"
        })


#endif

-- method ScriptMessageReply::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "script_message_reply"
--           , argType =
--               TInterface
--                 Name { namespace = "WebKit" , name = "ScriptMessageReply" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitScriptMessageReply"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_script_message_reply_unref" webkit_script_message_reply_unref :: 
    Ptr ScriptMessageReply ->               -- script_message_reply : TInterface (Name {namespace = "WebKit", name = "ScriptMessageReply"})
    IO ()

-- | Atomically decrements the reference count of /@scriptMessageReply@/ by one.
-- 
-- If the reference count drops to 0, all the memory allocated by the
-- t'GI.WebKit.Structs.ScriptMessageReply.ScriptMessageReply' is released. This function is MT-safe and may
-- be called from any thread.
-- 
-- /Since: 2.40/
scriptMessageReplyUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ScriptMessageReply
    -- ^ /@scriptMessageReply@/: A t'GI.WebKit.Structs.ScriptMessageReply.ScriptMessageReply'
    -> m ()
scriptMessageReplyUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
ScriptMessageReply -> m ()
scriptMessageReplyUnref ScriptMessageReply
scriptMessageReply = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ScriptMessageReply
scriptMessageReply' <- ScriptMessageReply -> IO (Ptr ScriptMessageReply)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ScriptMessageReply
scriptMessageReply
    Ptr ScriptMessageReply -> IO ()
webkit_script_message_reply_unref Ptr ScriptMessageReply
scriptMessageReply'
    ScriptMessageReply -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ScriptMessageReply
scriptMessageReply
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScriptMessageReplyUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ScriptMessageReplyUnrefMethodInfo ScriptMessageReply signature where
    overloadedMethod = scriptMessageReplyUnref

instance O.OverloadedMethodInfo ScriptMessageReplyUnrefMethodInfo ScriptMessageReply where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.WebKit.Structs.ScriptMessageReply.scriptMessageReplyUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-webkit-6.0.2/docs/GI-WebKit-Structs-ScriptMessageReply.html#v:scriptMessageReplyUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveScriptMessageReplyMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveScriptMessageReplyMethod "ref" o = ScriptMessageReplyRefMethodInfo
    ResolveScriptMessageReplyMethod "returnErrorMessage" o = ScriptMessageReplyReturnErrorMessageMethodInfo
    ResolveScriptMessageReplyMethod "returnValue" o = ScriptMessageReplyReturnValueMethodInfo
    ResolveScriptMessageReplyMethod "unref" o = ScriptMessageReplyUnrefMethodInfo
    ResolveScriptMessageReplyMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveScriptMessageReplyMethod t ScriptMessageReply, O.OverloadedMethod info ScriptMessageReply p) => OL.IsLabel t (ScriptMessageReply -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveScriptMessageReplyMethod t ScriptMessageReply, O.OverloadedMethod info ScriptMessageReply p, R.HasField t ScriptMessageReply p) => R.HasField t ScriptMessageReply p where
    getField = O.overloadedMethod @info

#endif

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

#endif