{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.WebKit2.Objects.WebResource
    ( 

-- * Exported types
    WebResource(..)                         ,
    IsWebResource                           ,
    toWebResource                           ,
    noWebResource                           ,


 -- * Methods
-- ** getData #method:getData#
    WebResourceGetDataMethodInfo            ,
    webResourceGetData                      ,


-- ** getDataFinish #method:getDataFinish#
    WebResourceGetDataFinishMethodInfo      ,
    webResourceGetDataFinish                ,


-- ** getResponse #method:getResponse#
    WebResourceGetResponseMethodInfo        ,
    webResourceGetResponse                  ,


-- ** getUri #method:getUri#
    WebResourceGetUriMethodInfo             ,
    webResourceGetUri                       ,




 -- * Properties
-- ** response #attr:response#
    WebResourceResponsePropertyInfo         ,
    getWebResourceResponse                  ,
    webResourceResponse                     ,


-- ** uri #attr:uri#
    WebResourceUriPropertyInfo              ,
    getWebResourceUri                       ,
    webResourceUri                          ,




 -- * Signals
-- ** failed #signal:failed#
    C_WebResourceFailedCallback             ,
    WebResourceFailedCallback               ,
    WebResourceFailedSignalInfo             ,
    afterWebResourceFailed                  ,
    genClosure_WebResourceFailed            ,
    mk_WebResourceFailedCallback            ,
    noWebResourceFailedCallback             ,
    onWebResourceFailed                     ,
    wrap_WebResourceFailedCallback          ,


-- ** failedWithTlsErrors #signal:failedWithTlsErrors#
    C_WebResourceFailedWithTlsErrorsCallback,
    WebResourceFailedWithTlsErrorsCallback  ,
    WebResourceFailedWithTlsErrorsSignalInfo,
    afterWebResourceFailedWithTlsErrors     ,
    genClosure_WebResourceFailedWithTlsErrors,
    mk_WebResourceFailedWithTlsErrorsCallback,
    noWebResourceFailedWithTlsErrorsCallback,
    onWebResourceFailedWithTlsErrors        ,
    wrap_WebResourceFailedWithTlsErrorsCallback,


-- ** finished #signal:finished#
    C_WebResourceFinishedCallback           ,
    WebResourceFinishedCallback             ,
    WebResourceFinishedSignalInfo           ,
    afterWebResourceFinished                ,
    genClosure_WebResourceFinished          ,
    mk_WebResourceFinishedCallback          ,
    noWebResourceFinishedCallback           ,
    onWebResourceFinished                   ,
    wrap_WebResourceFinishedCallback        ,


-- ** receivedData #signal:receivedData#
    C_WebResourceReceivedDataCallback       ,
    WebResourceReceivedDataCallback         ,
    WebResourceReceivedDataSignalInfo       ,
    afterWebResourceReceivedData            ,
    genClosure_WebResourceReceivedData      ,
    mk_WebResourceReceivedDataCallback      ,
    noWebResourceReceivedDataCallback       ,
    onWebResourceReceivedData               ,
    wrap_WebResourceReceivedDataCallback    ,


-- ** sentRequest #signal:sentRequest#
    C_WebResourceSentRequestCallback        ,
    WebResourceSentRequestCallback          ,
    WebResourceSentRequestSignalInfo        ,
    afterWebResourceSentRequest             ,
    genClosure_WebResourceSentRequest       ,
    mk_WebResourceSentRequestCallback       ,
    noWebResourceSentRequestCallback        ,
    onWebResourceSentRequest                ,
    wrap_WebResourceSentRequestCallback     ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest
import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIResponse as WebKit2.URIResponse

newtype WebResource = WebResource (ManagedPtr WebResource)
foreign import ccall "webkit_web_resource_get_type"
    c_webkit_web_resource_get_type :: IO GType

instance GObject WebResource where
    gobjectType _ = c_webkit_web_resource_get_type
    

class GObject o => IsWebResource o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError WebResource a) =>
    IsWebResource a
#endif
instance IsWebResource WebResource
instance GObject.Object.IsObject WebResource

toWebResource :: IsWebResource o => o -> IO WebResource
toWebResource = unsafeCastTo WebResource

noWebResource :: Maybe WebResource
noWebResource = Nothing

type family ResolveWebResourceMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebResourceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebResourceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebResourceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebResourceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebResourceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebResourceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebResourceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebResourceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebResourceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebResourceMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebResourceMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWebResourceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebResourceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebResourceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebResourceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebResourceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebResourceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebResourceMethod "getData" o = WebResourceGetDataMethodInfo
    ResolveWebResourceMethod "getDataFinish" o = WebResourceGetDataFinishMethodInfo
    ResolveWebResourceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebResourceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebResourceMethod "getResponse" o = WebResourceGetResponseMethodInfo
    ResolveWebResourceMethod "getUri" o = WebResourceGetUriMethodInfo
    ResolveWebResourceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebResourceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebResourceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebResourceMethod t WebResource, O.MethodInfo info WebResource p) => O.IsLabelProxy t (WebResource -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWebResourceMethod t WebResource, O.MethodInfo info WebResource p) => O.IsLabel t (WebResource -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal WebResource::failed
type WebResourceFailedCallback =
    GError ->
    IO ()

noWebResourceFailedCallback :: Maybe WebResourceFailedCallback
noWebResourceFailedCallback = Nothing

type C_WebResourceFailedCallback =
    Ptr () ->                               -- object
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceFailedCallback :: C_WebResourceFailedCallback -> IO (FunPtr C_WebResourceFailedCallback)

genClosure_WebResourceFailed :: WebResourceFailedCallback -> IO Closure
genClosure_WebResourceFailed cb = do
    let cb' = wrap_WebResourceFailedCallback cb
    mk_WebResourceFailedCallback cb' >>= newCClosure


wrap_WebResourceFailedCallback ::
    WebResourceFailedCallback ->
    Ptr () ->
    Ptr GError ->
    Ptr () ->
    IO ()
wrap_WebResourceFailedCallback _cb _ error_ _ = do
    error_' <- (newBoxed GError) error_
    _cb  error_'


onWebResourceFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedCallback -> m SignalHandlerId
onWebResourceFailed obj cb = liftIO $ do
    let cb' = wrap_WebResourceFailedCallback cb
    cb'' <- mk_WebResourceFailedCallback cb'
    connectSignalFunPtr obj "failed" cb'' SignalConnectBefore

afterWebResourceFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedCallback -> m SignalHandlerId
afterWebResourceFailed obj cb = liftIO $ do
    let cb' = wrap_WebResourceFailedCallback cb
    cb'' <- mk_WebResourceFailedCallback cb'
    connectSignalFunPtr obj "failed" cb'' SignalConnectAfter


-- signal WebResource::failed-with-tls-errors
type WebResourceFailedWithTlsErrorsCallback =
    Gio.TlsCertificate.TlsCertificate ->
    [Gio.Flags.TlsCertificateFlags] ->
    IO ()

noWebResourceFailedWithTlsErrorsCallback :: Maybe WebResourceFailedWithTlsErrorsCallback
noWebResourceFailedWithTlsErrorsCallback = Nothing

type C_WebResourceFailedWithTlsErrorsCallback =
    Ptr () ->                               -- object
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceFailedWithTlsErrorsCallback :: C_WebResourceFailedWithTlsErrorsCallback -> IO (FunPtr C_WebResourceFailedWithTlsErrorsCallback)

genClosure_WebResourceFailedWithTlsErrors :: WebResourceFailedWithTlsErrorsCallback -> IO Closure
genClosure_WebResourceFailedWithTlsErrors cb = do
    let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb
    mk_WebResourceFailedWithTlsErrorsCallback cb' >>= newCClosure


wrap_WebResourceFailedWithTlsErrorsCallback ::
    WebResourceFailedWithTlsErrorsCallback ->
    Ptr () ->
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WebResourceFailedWithTlsErrorsCallback _cb _ certificate errors _ = do
    certificate' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate
    let errors' = wordToGFlags errors
    _cb  certificate' errors'


onWebResourceFailedWithTlsErrors :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedWithTlsErrorsCallback -> m SignalHandlerId
onWebResourceFailedWithTlsErrors obj cb = liftIO $ do
    let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb
    cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb'
    connectSignalFunPtr obj "failed-with-tls-errors" cb'' SignalConnectBefore

afterWebResourceFailedWithTlsErrors :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedWithTlsErrorsCallback -> m SignalHandlerId
afterWebResourceFailedWithTlsErrors obj cb = liftIO $ do
    let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb
    cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb'
    connectSignalFunPtr obj "failed-with-tls-errors" cb'' SignalConnectAfter


-- signal WebResource::finished
type WebResourceFinishedCallback =
    IO ()

noWebResourceFinishedCallback :: Maybe WebResourceFinishedCallback
noWebResourceFinishedCallback = Nothing

type C_WebResourceFinishedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceFinishedCallback :: C_WebResourceFinishedCallback -> IO (FunPtr C_WebResourceFinishedCallback)

genClosure_WebResourceFinished :: WebResourceFinishedCallback -> IO Closure
genClosure_WebResourceFinished cb = do
    let cb' = wrap_WebResourceFinishedCallback cb
    mk_WebResourceFinishedCallback cb' >>= newCClosure


wrap_WebResourceFinishedCallback ::
    WebResourceFinishedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebResourceFinishedCallback _cb _ _ = do
    _cb 


onWebResourceFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceFinishedCallback -> m SignalHandlerId
onWebResourceFinished obj cb = liftIO $ do
    let cb' = wrap_WebResourceFinishedCallback cb
    cb'' <- mk_WebResourceFinishedCallback cb'
    connectSignalFunPtr obj "finished" cb'' SignalConnectBefore

afterWebResourceFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceFinishedCallback -> m SignalHandlerId
afterWebResourceFinished obj cb = liftIO $ do
    let cb' = wrap_WebResourceFinishedCallback cb
    cb'' <- mk_WebResourceFinishedCallback cb'
    connectSignalFunPtr obj "finished" cb'' SignalConnectAfter


-- signal WebResource::received-data
type WebResourceReceivedDataCallback =
    Word64 ->
    IO ()

noWebResourceReceivedDataCallback :: Maybe WebResourceReceivedDataCallback
noWebResourceReceivedDataCallback = Nothing

type C_WebResourceReceivedDataCallback =
    Ptr () ->                               -- object
    Word64 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceReceivedDataCallback :: C_WebResourceReceivedDataCallback -> IO (FunPtr C_WebResourceReceivedDataCallback)

genClosure_WebResourceReceivedData :: WebResourceReceivedDataCallback -> IO Closure
genClosure_WebResourceReceivedData cb = do
    let cb' = wrap_WebResourceReceivedDataCallback cb
    mk_WebResourceReceivedDataCallback cb' >>= newCClosure


wrap_WebResourceReceivedDataCallback ::
    WebResourceReceivedDataCallback ->
    Ptr () ->
    Word64 ->
    Ptr () ->
    IO ()
wrap_WebResourceReceivedDataCallback _cb _ dataLength _ = do
    _cb  dataLength


onWebResourceReceivedData :: (IsWebResource a, MonadIO m) => a -> WebResourceReceivedDataCallback -> m SignalHandlerId
onWebResourceReceivedData obj cb = liftIO $ do
    let cb' = wrap_WebResourceReceivedDataCallback cb
    cb'' <- mk_WebResourceReceivedDataCallback cb'
    connectSignalFunPtr obj "received-data" cb'' SignalConnectBefore

afterWebResourceReceivedData :: (IsWebResource a, MonadIO m) => a -> WebResourceReceivedDataCallback -> m SignalHandlerId
afterWebResourceReceivedData obj cb = liftIO $ do
    let cb' = wrap_WebResourceReceivedDataCallback cb
    cb'' <- mk_WebResourceReceivedDataCallback cb'
    connectSignalFunPtr obj "received-data" cb'' SignalConnectAfter


-- signal WebResource::sent-request
type WebResourceSentRequestCallback =
    WebKit2.URIRequest.URIRequest ->
    WebKit2.URIResponse.URIResponse ->
    IO ()

noWebResourceSentRequestCallback :: Maybe WebResourceSentRequestCallback
noWebResourceSentRequestCallback = Nothing

type C_WebResourceSentRequestCallback =
    Ptr () ->                               -- object
    Ptr WebKit2.URIRequest.URIRequest ->
    Ptr WebKit2.URIResponse.URIResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceSentRequestCallback :: C_WebResourceSentRequestCallback -> IO (FunPtr C_WebResourceSentRequestCallback)

genClosure_WebResourceSentRequest :: WebResourceSentRequestCallback -> IO Closure
genClosure_WebResourceSentRequest cb = do
    let cb' = wrap_WebResourceSentRequestCallback cb
    mk_WebResourceSentRequestCallback cb' >>= newCClosure


wrap_WebResourceSentRequestCallback ::
    WebResourceSentRequestCallback ->
    Ptr () ->
    Ptr WebKit2.URIRequest.URIRequest ->
    Ptr WebKit2.URIResponse.URIResponse ->
    Ptr () ->
    IO ()
wrap_WebResourceSentRequestCallback _cb _ request redirectedResponse _ = do
    request' <- (newObject WebKit2.URIRequest.URIRequest) request
    redirectedResponse' <- (newObject WebKit2.URIResponse.URIResponse) redirectedResponse
    _cb  request' redirectedResponse'


onWebResourceSentRequest :: (IsWebResource a, MonadIO m) => a -> WebResourceSentRequestCallback -> m SignalHandlerId
onWebResourceSentRequest obj cb = liftIO $ do
    let cb' = wrap_WebResourceSentRequestCallback cb
    cb'' <- mk_WebResourceSentRequestCallback cb'
    connectSignalFunPtr obj "sent-request" cb'' SignalConnectBefore

afterWebResourceSentRequest :: (IsWebResource a, MonadIO m) => a -> WebResourceSentRequestCallback -> m SignalHandlerId
afterWebResourceSentRequest obj cb = liftIO $ do
    let cb' = wrap_WebResourceSentRequestCallback cb
    cb'' <- mk_WebResourceSentRequestCallback cb'
    connectSignalFunPtr obj "sent-request" cb'' SignalConnectAfter


-- VVV Prop "response"
   -- Type: TInterface (Name {namespace = "WebKit2", name = "URIResponse"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebResourceResponse :: (MonadIO m, IsWebResource o) => o -> m WebKit2.URIResponse.URIResponse
getWebResourceResponse obj = liftIO $ checkUnexpectedNothing "getWebResourceResponse" $ getObjectPropertyObject obj "response" WebKit2.URIResponse.URIResponse

data WebResourceResponsePropertyInfo
instance AttrInfo WebResourceResponsePropertyInfo where
    type AttrAllowedOps WebResourceResponsePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceResponsePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebResourceResponsePropertyInfo = IsWebResource
    type AttrGetType WebResourceResponsePropertyInfo = WebKit2.URIResponse.URIResponse
    type AttrLabel WebResourceResponsePropertyInfo = "response"
    type AttrOrigin WebResourceResponsePropertyInfo = WebResource
    attrGet _ = getWebResourceResponse
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebResourceUri :: (MonadIO m, IsWebResource o) => o -> m T.Text
getWebResourceUri obj = liftIO $ checkUnexpectedNothing "getWebResourceUri" $ getObjectPropertyString obj "uri"

data WebResourceUriPropertyInfo
instance AttrInfo WebResourceUriPropertyInfo where
    type AttrAllowedOps WebResourceUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebResourceUriPropertyInfo = IsWebResource
    type AttrGetType WebResourceUriPropertyInfo = T.Text
    type AttrLabel WebResourceUriPropertyInfo = "uri"
    type AttrOrigin WebResourceUriPropertyInfo = WebResource
    attrGet _ = getWebResourceUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList WebResource
type instance O.AttributeList WebResource = WebResourceAttributeList
type WebResourceAttributeList = ('[ '("response", WebResourceResponsePropertyInfo), '("uri", WebResourceUriPropertyInfo)] :: [(Symbol, *)])

webResourceResponse :: AttrLabelProxy "response"
webResourceResponse = AttrLabelProxy

webResourceUri :: AttrLabelProxy "uri"
webResourceUri = AttrLabelProxy

data WebResourceFailedSignalInfo
instance SignalInfo WebResourceFailedSignalInfo where
    type HaskellCallbackType WebResourceFailedSignalInfo = WebResourceFailedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceFailedCallback cb
        cb'' <- mk_WebResourceFailedCallback cb'
        connectSignalFunPtr obj "failed" cb'' connectMode

data WebResourceFailedWithTlsErrorsSignalInfo
instance SignalInfo WebResourceFailedWithTlsErrorsSignalInfo where
    type HaskellCallbackType WebResourceFailedWithTlsErrorsSignalInfo = WebResourceFailedWithTlsErrorsCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb
        cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb'
        connectSignalFunPtr obj "failed-with-tls-errors" cb'' connectMode

data WebResourceFinishedSignalInfo
instance SignalInfo WebResourceFinishedSignalInfo where
    type HaskellCallbackType WebResourceFinishedSignalInfo = WebResourceFinishedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceFinishedCallback cb
        cb'' <- mk_WebResourceFinishedCallback cb'
        connectSignalFunPtr obj "finished" cb'' connectMode

data WebResourceReceivedDataSignalInfo
instance SignalInfo WebResourceReceivedDataSignalInfo where
    type HaskellCallbackType WebResourceReceivedDataSignalInfo = WebResourceReceivedDataCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceReceivedDataCallback cb
        cb'' <- mk_WebResourceReceivedDataCallback cb'
        connectSignalFunPtr obj "received-data" cb'' connectMode

data WebResourceSentRequestSignalInfo
instance SignalInfo WebResourceSentRequestSignalInfo where
    type HaskellCallbackType WebResourceSentRequestSignalInfo = WebResourceSentRequestCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceSentRequestCallback cb
        cb'' <- mk_WebResourceSentRequestCallback cb'
        connectSignalFunPtr obj "sent-request" cb'' connectMode

type instance O.SignalList WebResource = WebResourceSignalList
type WebResourceSignalList = ('[ '("failed", WebResourceFailedSignalInfo), '("failedWithTlsErrors", WebResourceFailedWithTlsErrorsSignalInfo), '("finished", WebResourceFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("receivedData", WebResourceReceivedDataSignalInfo), '("sentRequest", WebResourceSentRequestSignalInfo)] :: [(Symbol, *)])

-- method WebResource::get_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_data" webkit_web_resource_get_data :: 
    Ptr WebResource ->                      -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Asynchronously get the raw data for /@resource@/.

When the operation is finished, /@callback@/ will be called. You can then call
'GI.WebKit2.Objects.WebResource.webResourceGetDataFinish' to get the result of the operation.
-}
webResourceGetData ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -}
    -> m ()
webResourceGetData resource cancellable callback = liftIO $ do
    resource' <- unsafeManagedPtrCastPtr resource
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    webkit_web_resource_get_data resource' maybeCancellable maybeCallback userData
    touchManagedPtr resource
    whenJust cancellable touchManagedPtr
    return ()

data WebResourceGetDataMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebResource a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebResourceGetDataMethodInfo a signature where
    overloadedMethod _ = webResourceGetData

-- method WebResource::get_data_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the length of the resource data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the length of the resource data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Just (TCArray False (-1) 2 (TBasicType TUInt8))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_web_resource_get_data_finish" webkit_web_resource_get_data_finish :: 
    Ptr WebResource ->                      -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr Word64 ->                           -- length : TBasicType TUInt64
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Word8)

{- |
Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebResource.webResourceGetData'.
-}
webResourceGetDataFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ByteString
    {- ^ __Returns:__ a
   string with the data of /@resource@/, or 'Nothing' in case of error. if /@length@/
   is not 'Nothing', the size of the data will be assigned to it. /(Can throw 'Data.GI.Base.GError.GError')/ -}
webResourceGetDataFinish resource result_ = liftIO $ do
    resource' <- unsafeManagedPtrCastPtr resource
    result_' <- unsafeManagedPtrCastPtr result_
    length_ <- allocMem :: IO (Ptr Word64)
    onException (do
        result <- propagateGError $ webkit_web_resource_get_data_finish resource' result_' length_
        length_' <- peek length_
        checkUnexpectedReturnNULL "webResourceGetDataFinish" result
        result' <- (unpackByteStringWithLength length_') result
        freeMem result
        touchManagedPtr resource
        touchManagedPtr result_
        freeMem length_
        return result'
     ) (do
        freeMem length_
     )

data WebResourceGetDataFinishMethodInfo
instance (signature ~ (b -> m ByteString), MonadIO m, IsWebResource a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebResourceGetDataFinishMethodInfo a signature where
    overloadedMethod _ = webResourceGetDataFinish

-- method WebResource::get_response
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit2", name = "URIResponse"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_response" webkit_web_resource_get_response :: 
    Ptr WebResource ->                      -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"})
    IO (Ptr WebKit2.URIResponse.URIResponse)

{- |
Retrieves the 'GI.WebKit2.Objects.URIResponse.URIResponse' of the resource load operation.
This method returns 'Nothing' if called before the response
is received from the server. You can connect to notify::response
signal to be notified when the response is received.
-}
webResourceGetResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -}
    -> m WebKit2.URIResponse.URIResponse
    {- ^ __Returns:__ the 'GI.WebKit2.Objects.URIResponse.URIResponse', or 'Nothing' if
    the response hasn\'t been received yet. -}
webResourceGetResponse resource = liftIO $ do
    resource' <- unsafeManagedPtrCastPtr resource
    result <- webkit_web_resource_get_response resource'
    checkUnexpectedReturnNULL "webResourceGetResponse" result
    result' <- (newObject WebKit2.URIResponse.URIResponse) result
    touchManagedPtr resource
    return result'

data WebResourceGetResponseMethodInfo
instance (signature ~ (m WebKit2.URIResponse.URIResponse), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetResponseMethodInfo a signature where
    overloadedMethod _ = webResourceGetResponse

-- method WebResource::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", 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 "webkit_web_resource_get_uri" webkit_web_resource_get_uri :: 
    Ptr WebResource ->                      -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"})
    IO CString

{- |
Returns the current active URI of /@resource@/. The active URI might change during
a load operation:

\<orderedlist>
\<listitem>\<para>
  When the resource load starts, the active URI is the requested URI
\<\/para>\<\/listitem>
\<listitem>\<para>
  When the initial request is sent to the server, 'GI.WebKit2.Objects.WebResource.WebResource'::@/sent-request/@
  signal is emitted without a redirected response, the active URI is the URI of
  the request sent to the server.
\<\/para>\<\/listitem>
\<listitem>\<para>
  In case of a server redirection, 'GI.WebKit2.Objects.WebResource.WebResource'::@/sent-request/@ signal
  is emitted again with a redirected response, the active URI is the URI the request
  was redirected to.
\<\/para>\<\/listitem>
\<listitem>\<para>
  When the response is received from the server, the active URI is the final
  one and it will not change again.
\<\/para>\<\/listitem>
\<\/orderedlist>

You can monitor the active URI by connecting to the notify::uri
signal of /@resource@/.
-}
webResourceGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -}
    -> m T.Text
    {- ^ __Returns:__ the current active URI of /@resource@/ -}
webResourceGetUri resource = liftIO $ do
    resource' <- unsafeManagedPtrCastPtr resource
    result <- webkit_web_resource_get_uri resource'
    checkUnexpectedReturnNULL "webResourceGetUri" result
    result' <- cstringToText result
    touchManagedPtr resource
    return result'

data WebResourceGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetUriMethodInfo a signature where
    overloadedMethod _ = webResourceGetUri