{- |
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.Soup.Objects.CookieJar
    ( 

-- * Exported types
    CookieJar(..)                           ,
    IsCookieJar                             ,
    toCookieJar                             ,
    noCookieJar                             ,


 -- * Methods
-- ** addCookie #method:addCookie#
    CookieJarAddCookieMethodInfo            ,
    cookieJarAddCookie                      ,


-- ** addCookieWithFirstParty #method:addCookieWithFirstParty#
    CookieJarAddCookieWithFirstPartyMethodInfo,
    cookieJarAddCookieWithFirstParty        ,


-- ** allCookies #method:allCookies#
    CookieJarAllCookiesMethodInfo           ,
    cookieJarAllCookies                     ,


-- ** deleteCookie #method:deleteCookie#
    CookieJarDeleteCookieMethodInfo         ,
    cookieJarDeleteCookie                   ,


-- ** getAcceptPolicy #method:getAcceptPolicy#
    CookieJarGetAcceptPolicyMethodInfo      ,
    cookieJarGetAcceptPolicy                ,


-- ** getCookieList #method:getCookieList#
    CookieJarGetCookieListMethodInfo        ,
    cookieJarGetCookieList                  ,


-- ** getCookies #method:getCookies#
    CookieJarGetCookiesMethodInfo           ,
    cookieJarGetCookies                     ,


-- ** isPersistent #method:isPersistent#
    CookieJarIsPersistentMethodInfo         ,
    cookieJarIsPersistent                   ,


-- ** new #method:new#
    cookieJarNew                            ,


-- ** save #method:save#
    CookieJarSaveMethodInfo                 ,
    cookieJarSave                           ,


-- ** setAcceptPolicy #method:setAcceptPolicy#
    CookieJarSetAcceptPolicyMethodInfo      ,
    cookieJarSetAcceptPolicy                ,


-- ** setCookie #method:setCookie#
    CookieJarSetCookieMethodInfo            ,
    cookieJarSetCookie                      ,


-- ** setCookieWithFirstParty #method:setCookieWithFirstParty#
    CookieJarSetCookieWithFirstPartyMethodInfo,
    cookieJarSetCookieWithFirstParty        ,




 -- * Properties
-- ** acceptPolicy #attr:acceptPolicy#
    CookieJarAcceptPolicyPropertyInfo       ,
    constructCookieJarAcceptPolicy          ,
    cookieJarAcceptPolicy                   ,
    getCookieJarAcceptPolicy                ,
    setCookieJarAcceptPolicy                ,


-- ** readOnly #attr:readOnly#
    CookieJarReadOnlyPropertyInfo           ,
    constructCookieJarReadOnly              ,
    cookieJarReadOnly                       ,
    getCookieJarReadOnly                    ,




 -- * Signals
-- ** changed #signal:changed#
    C_CookieJarChangedCallback              ,
    CookieJarChangedCallback                ,
    CookieJarChangedSignalInfo              ,
    afterCookieJarChanged                   ,
    genClosure_CookieJarChanged             ,
    mk_CookieJarChangedCallback             ,
    noCookieJarChangedCallback              ,
    onCookieJarChanged                      ,
    wrap_CookieJarChangedCallback           ,




    ) 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 {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Structs.Cookie as Soup.Cookie
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

newtype CookieJar = CookieJar (ManagedPtr CookieJar)
foreign import ccall "soup_cookie_jar_get_type"
    c_soup_cookie_jar_get_type :: IO GType

instance GObject CookieJar where
    gobjectType _ = c_soup_cookie_jar_get_type
    

class GObject o => IsCookieJar o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CookieJar a) =>
    IsCookieJar a
#endif
instance IsCookieJar CookieJar
instance GObject.Object.IsObject CookieJar
instance Soup.SessionFeature.IsSessionFeature CookieJar

toCookieJar :: IsCookieJar o => o -> IO CookieJar
toCookieJar = unsafeCastTo CookieJar

noCookieJar :: Maybe CookieJar
noCookieJar = Nothing

type family ResolveCookieJarMethod (t :: Symbol) (o :: *) :: * where
    ResolveCookieJarMethod "addCookie" o = CookieJarAddCookieMethodInfo
    ResolveCookieJarMethod "addCookieWithFirstParty" o = CookieJarAddCookieWithFirstPartyMethodInfo
    ResolveCookieJarMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
    ResolveCookieJarMethod "allCookies" o = CookieJarAllCookiesMethodInfo
    ResolveCookieJarMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
    ResolveCookieJarMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCookieJarMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCookieJarMethod "deleteCookie" o = CookieJarDeleteCookieMethodInfo
    ResolveCookieJarMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
    ResolveCookieJarMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCookieJarMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCookieJarMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
    ResolveCookieJarMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCookieJarMethod "isPersistent" o = CookieJarIsPersistentMethodInfo
    ResolveCookieJarMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCookieJarMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCookieJarMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCookieJarMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCookieJarMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
    ResolveCookieJarMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCookieJarMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveCookieJarMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCookieJarMethod "save" o = CookieJarSaveMethodInfo
    ResolveCookieJarMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCookieJarMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCookieJarMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCookieJarMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCookieJarMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCookieJarMethod "getAcceptPolicy" o = CookieJarGetAcceptPolicyMethodInfo
    ResolveCookieJarMethod "getCookieList" o = CookieJarGetCookieListMethodInfo
    ResolveCookieJarMethod "getCookies" o = CookieJarGetCookiesMethodInfo
    ResolveCookieJarMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCookieJarMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCookieJarMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCookieJarMethod "setAcceptPolicy" o = CookieJarSetAcceptPolicyMethodInfo
    ResolveCookieJarMethod "setCookie" o = CookieJarSetCookieMethodInfo
    ResolveCookieJarMethod "setCookieWithFirstParty" o = CookieJarSetCookieWithFirstPartyMethodInfo
    ResolveCookieJarMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCookieJarMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCookieJarMethod l o = O.MethodResolutionFailed l o

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

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

-- signal CookieJar::changed
type CookieJarChangedCallback =
    Soup.Cookie.Cookie ->
    Soup.Cookie.Cookie ->
    IO ()

noCookieJarChangedCallback :: Maybe CookieJarChangedCallback
noCookieJarChangedCallback = Nothing

type C_CookieJarChangedCallback =
    Ptr () ->                               -- object
    Ptr Soup.Cookie.Cookie ->
    Ptr Soup.Cookie.Cookie ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CookieJarChangedCallback :: C_CookieJarChangedCallback -> IO (FunPtr C_CookieJarChangedCallback)

genClosure_CookieJarChanged :: CookieJarChangedCallback -> IO Closure
genClosure_CookieJarChanged cb = do
    let cb' = wrap_CookieJarChangedCallback cb
    mk_CookieJarChangedCallback cb' >>= newCClosure


wrap_CookieJarChangedCallback ::
    CookieJarChangedCallback ->
    Ptr () ->
    Ptr Soup.Cookie.Cookie ->
    Ptr Soup.Cookie.Cookie ->
    Ptr () ->
    IO ()
wrap_CookieJarChangedCallback _cb _ oldCookie newCookie _ = do
    oldCookie' <- (newBoxed Soup.Cookie.Cookie) oldCookie
    newCookie' <- (newBoxed Soup.Cookie.Cookie) newCookie
    _cb  oldCookie' newCookie'


onCookieJarChanged :: (GObject a, MonadIO m) => a -> CookieJarChangedCallback -> m SignalHandlerId
onCookieJarChanged obj cb = liftIO $ connectCookieJarChanged obj cb SignalConnectBefore
afterCookieJarChanged :: (GObject a, MonadIO m) => a -> CookieJarChangedCallback -> m SignalHandlerId
afterCookieJarChanged obj cb = connectCookieJarChanged obj cb SignalConnectAfter

connectCookieJarChanged :: (GObject a, MonadIO m) =>
                           a -> CookieJarChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectCookieJarChanged obj cb after = liftIO $ do
    let cb' = wrap_CookieJarChangedCallback cb
    cb'' <- mk_CookieJarChangedCallback cb'
    connectSignalFunPtr obj "changed" cb'' after

-- VVV Prop "accept-policy"
   -- Type: TInterface (Name {namespace = "Soup", name = "CookieJarAcceptPolicy"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getCookieJarAcceptPolicy :: (MonadIO m, IsCookieJar o) => o -> m Soup.Enums.CookieJarAcceptPolicy
getCookieJarAcceptPolicy obj = liftIO $ getObjectPropertyEnum obj "accept-policy"

setCookieJarAcceptPolicy :: (MonadIO m, IsCookieJar o) => o -> Soup.Enums.CookieJarAcceptPolicy -> m ()
setCookieJarAcceptPolicy obj val = liftIO $ setObjectPropertyEnum obj "accept-policy" val

constructCookieJarAcceptPolicy :: (IsCookieJar o) => Soup.Enums.CookieJarAcceptPolicy -> IO (GValueConstruct o)
constructCookieJarAcceptPolicy val = constructObjectPropertyEnum "accept-policy" val

data CookieJarAcceptPolicyPropertyInfo
instance AttrInfo CookieJarAcceptPolicyPropertyInfo where
    type AttrAllowedOps CookieJarAcceptPolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CookieJarAcceptPolicyPropertyInfo = (~) Soup.Enums.CookieJarAcceptPolicy
    type AttrBaseTypeConstraint CookieJarAcceptPolicyPropertyInfo = IsCookieJar
    type AttrGetType CookieJarAcceptPolicyPropertyInfo = Soup.Enums.CookieJarAcceptPolicy
    type AttrLabel CookieJarAcceptPolicyPropertyInfo = "accept-policy"
    type AttrOrigin CookieJarAcceptPolicyPropertyInfo = CookieJar
    attrGet _ = getCookieJarAcceptPolicy
    attrSet _ = setCookieJarAcceptPolicy
    attrConstruct _ = constructCookieJarAcceptPolicy
    attrClear _ = undefined

-- VVV Prop "read-only"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

getCookieJarReadOnly :: (MonadIO m, IsCookieJar o) => o -> m Bool
getCookieJarReadOnly obj = liftIO $ getObjectPropertyBool obj "read-only"

constructCookieJarReadOnly :: (IsCookieJar o) => Bool -> IO (GValueConstruct o)
constructCookieJarReadOnly val = constructObjectPropertyBool "read-only" val

data CookieJarReadOnlyPropertyInfo
instance AttrInfo CookieJarReadOnlyPropertyInfo where
    type AttrAllowedOps CookieJarReadOnlyPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CookieJarReadOnlyPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint CookieJarReadOnlyPropertyInfo = IsCookieJar
    type AttrGetType CookieJarReadOnlyPropertyInfo = Bool
    type AttrLabel CookieJarReadOnlyPropertyInfo = "read-only"
    type AttrOrigin CookieJarReadOnlyPropertyInfo = CookieJar
    attrGet _ = getCookieJarReadOnly
    attrSet _ = undefined
    attrConstruct _ = constructCookieJarReadOnly
    attrClear _ = undefined

instance O.HasAttributeList CookieJar
type instance O.AttributeList CookieJar = CookieJarAttributeList
type CookieJarAttributeList = ('[ '("acceptPolicy", CookieJarAcceptPolicyPropertyInfo), '("readOnly", CookieJarReadOnlyPropertyInfo)] :: [(Symbol, *)])

cookieJarAcceptPolicy :: AttrLabelProxy "acceptPolicy"
cookieJarAcceptPolicy = AttrLabelProxy

cookieJarReadOnly :: AttrLabelProxy "readOnly"
cookieJarReadOnly = AttrLabelProxy

data CookieJarChangedSignalInfo
instance SignalInfo CookieJarChangedSignalInfo where
    type HaskellCallbackType CookieJarChangedSignalInfo = CookieJarChangedCallback
    connectSignal _ = connectCookieJarChanged

type instance O.SignalList CookieJar = CookieJarSignalList
type CookieJarSignalList = ('[ '("changed", CookieJarChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

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

foreign import ccall "soup_cookie_jar_new" soup_cookie_jar_new :: 
    IO (Ptr CookieJar)

{- |
Creates a new 'GI.Soup.Objects.CookieJar.CookieJar'. The base 'GI.Soup.Objects.CookieJar.CookieJar' class does
not support persistent storage of cookies; use a subclass for that.

@since 2.24
-}
cookieJarNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m CookieJar
    {- ^ __Returns:__ a new 'GI.Soup.Objects.CookieJar.CookieJar' -}
cookieJarNew  = liftIO $ do
    result <- soup_cookie_jar_new
    checkUnexpectedReturnNULL "cookieJarNew" result
    result' <- (wrapObject CookieJar) result
    return result'

-- method CookieJar::add_cookie
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TInterface (Name {namespace = "Soup", name = "Cookie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_add_cookie" soup_cookie_jar_add_cookie :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.Cookie.Cookie ->               -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO ()

{- |
Adds /@cookie@/ to /@jar@/, emitting the \'changed\' signal if we are modifying
an existing cookie or adding a valid new cookie (\'valid\' means
that the cookie\'s expire date is not in the past).

/@cookie@/ will be \'stolen\' by the jar, so don\'t free it afterwards.

@since 2.26
-}
cookieJarAddCookie ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.Cookie.Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m ()
cookieJarAddCookie jar cookie = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    cookie' <- B.ManagedPtr.disownBoxed cookie
    soup_cookie_jar_add_cookie jar' cookie'
    touchManagedPtr jar
    touchManagedPtr cookie
    return ()

data CookieJarAddCookieMethodInfo
instance (signature ~ (Soup.Cookie.Cookie -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarAddCookieMethodInfo a signature where
    overloadedMethod _ = cookieJarAddCookie

-- method CookieJar::add_cookie_with_first_party
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first_party", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI for the main document", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TInterface (Name {namespace = "Soup", name = "Cookie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_add_cookie_with_first_party" soup_cookie_jar_add_cookie_with_first_party :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.URI.URI ->                     -- first_party : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr Soup.Cookie.Cookie ->               -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO ()

{- |
Adds /@cookie@/ to /@jar@/, emitting the \'changed\' signal if we are modifying
an existing cookie or adding a valid new cookie (\'valid\' means
that the cookie\'s expire date is not in the past).

/@firstParty@/ will be used to reject cookies coming from third party
resources in case such a security policy is set in the /@jar@/.

/@cookie@/ will be \'stolen\' by the jar, so don\'t free it afterwards.

@since 2.40
-}
cookieJarAddCookieWithFirstParty ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.URI.URI
    {- ^ /@firstParty@/: the URI for the main document -}
    -> Soup.Cookie.Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m ()
cookieJarAddCookieWithFirstParty jar firstParty cookie = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    firstParty' <- unsafeManagedPtrGetPtr firstParty
    cookie' <- B.ManagedPtr.disownBoxed cookie
    soup_cookie_jar_add_cookie_with_first_party jar' firstParty' cookie'
    touchManagedPtr jar
    touchManagedPtr firstParty
    touchManagedPtr cookie
    return ()

data CookieJarAddCookieWithFirstPartyMethodInfo
instance (signature ~ (Soup.URI.URI -> Soup.Cookie.Cookie -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarAddCookieWithFirstPartyMethodInfo a signature where
    overloadedMethod _ = cookieJarAddCookieWithFirstParty

-- method CookieJar::all_cookies
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TInterface (Name {namespace = "Soup", name = "Cookie"})))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_all_cookies" soup_cookie_jar_all_cookies :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))

{- |
Constructs a 'GI.GLib.Structs.SList.SList' with every cookie inside the /@jar@/.
The cookies in the list are a copy of the original, so
you have to free them when you are done with them.

@since 2.26
-}
cookieJarAllCookies ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> m [Soup.Cookie.Cookie]
    {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList'
with all the cookies in the /@jar@/. -}
cookieJarAllCookies jar = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    result <- soup_cookie_jar_all_cookies jar'
    result' <- unpackGSList result
    result'' <- mapM (wrapBoxed Soup.Cookie.Cookie) result'
    g_slist_free result
    touchManagedPtr jar
    return result''

data CookieJarAllCookiesMethodInfo
instance (signature ~ (m [Soup.Cookie.Cookie]), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarAllCookiesMethodInfo a signature where
    overloadedMethod _ = cookieJarAllCookies

-- method CookieJar::delete_cookie
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TInterface (Name {namespace = "Soup", name = "Cookie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_delete_cookie" soup_cookie_jar_delete_cookie :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.Cookie.Cookie ->               -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO ()

{- |
Deletes /@cookie@/ from /@jar@/, emitting the \'changed\' signal.

@since 2.26
-}
cookieJarDeleteCookie ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.Cookie.Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m ()
cookieJarDeleteCookie jar cookie = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    cookie' <- unsafeManagedPtrGetPtr cookie
    soup_cookie_jar_delete_cookie jar' cookie'
    touchManagedPtr jar
    touchManagedPtr cookie
    return ()

data CookieJarDeleteCookieMethodInfo
instance (signature ~ (Soup.Cookie.Cookie -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarDeleteCookieMethodInfo a signature where
    overloadedMethod _ = cookieJarDeleteCookie

-- method CookieJar::get_accept_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "CookieJarAcceptPolicy"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_get_accept_policy" soup_cookie_jar_get_accept_policy :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    IO CUInt

{- |
Gets /@jar@/\'s 'GI.Soup.Enums.CookieJarAcceptPolicy'

@since 2.30
-}
cookieJarGetAcceptPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> m Soup.Enums.CookieJarAcceptPolicy
    {- ^ __Returns:__ the 'GI.Soup.Enums.CookieJarAcceptPolicy' set in the /@jar@/ -}
cookieJarGetAcceptPolicy jar = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    result <- soup_cookie_jar_get_accept_policy jar'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr jar
    return result'

data CookieJarGetAcceptPolicyMethodInfo
instance (signature ~ (m Soup.Enums.CookieJarAcceptPolicy), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarGetAcceptPolicyMethodInfo a signature where
    overloadedMethod _ = cookieJarGetAcceptPolicy

-- method CookieJar::get_cookie_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "for_http", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the return value is being passed directly\nto an HTTP operation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TInterface (Name {namespace = "Soup", name = "Cookie"})))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_get_cookie_list" soup_cookie_jar_get_cookie_list :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CInt ->                                 -- for_http : TBasicType TBoolean
    IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))

{- |
Retrieves the list of cookies that would be sent with a request to /@uri@/
as a 'GI.GLib.Structs.SList.SList' of 'GI.Soup.Structs.Cookie.Cookie' objects.

If /@forHttp@/ is 'True', the return value will include cookies marked
\"HttpOnly\" (that is, cookies that the server wishes to keep hidden
from client-side scripting operations such as the JavaScript
document.cookies property). Since 'GI.Soup.Objects.CookieJar.CookieJar' sets the Cookie
header itself when making the actual HTTP request, you should
almost certainly be setting /@forHttp@/ to 'False' if you are calling
this.

@since 2.40
-}
cookieJarGetCookieList ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Bool
    {- ^ /@forHttp@/: whether or not the return value is being passed directly
to an HTTP operation -}
    -> m [Soup.Cookie.Cookie]
    {- ^ __Returns:__ a 'GI.GLib.Structs.SList.SList'
with the cookies in the /@jar@/ that would be sent with a request to /@uri@/. -}
cookieJarGetCookieList jar uri forHttp = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    uri' <- unsafeManagedPtrGetPtr uri
    let forHttp' = (fromIntegral . fromEnum) forHttp
    result <- soup_cookie_jar_get_cookie_list jar' uri' forHttp'
    result' <- unpackGSList result
    result'' <- mapM (wrapBoxed Soup.Cookie.Cookie) result'
    g_slist_free result
    touchManagedPtr jar
    touchManagedPtr uri
    return result''

data CookieJarGetCookieListMethodInfo
instance (signature ~ (Soup.URI.URI -> Bool -> m [Soup.Cookie.Cookie]), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarGetCookieListMethodInfo a signature where
    overloadedMethod _ = cookieJarGetCookieList

-- method CookieJar::get_cookies
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupURI", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "for_http", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not the return value is being passed directly\nto an HTTP operation", 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 "soup_cookie_jar_get_cookies" soup_cookie_jar_get_cookies :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CInt ->                                 -- for_http : TBasicType TBoolean
    IO CString

{- |
Retrieves (in Cookie-header form) the list of cookies that would
be sent with a request to /@uri@/.

If /@forHttp@/ is 'True', the return value will include cookies marked
\"HttpOnly\" (that is, cookies that the server wishes to keep hidden
from client-side scripting operations such as the JavaScript
document.cookies property). Since 'GI.Soup.Objects.CookieJar.CookieJar' sets the Cookie
header itself when making the actual HTTP request, you should
almost certainly be setting /@forHttp@/ to 'False' if you are calling
this.

@since 2.24
-}
cookieJarGetCookies ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> Bool
    {- ^ /@forHttp@/: whether or not the return value is being passed directly
to an HTTP operation -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the cookies, in string form, or 'Nothing' if
there are no cookies for /@uri@/. -}
cookieJarGetCookies jar uri forHttp = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    uri' <- unsafeManagedPtrGetPtr uri
    let forHttp' = (fromIntegral . fromEnum) forHttp
    result <- soup_cookie_jar_get_cookies jar' uri' forHttp'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        freeMem result'
        return result''
    touchManagedPtr jar
    touchManagedPtr uri
    return maybeResult

data CookieJarGetCookiesMethodInfo
instance (signature ~ (Soup.URI.URI -> Bool -> m (Maybe T.Text)), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarGetCookiesMethodInfo a signature where
    overloadedMethod _ = cookieJarGetCookies

-- method CookieJar::is_persistent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", 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 "soup_cookie_jar_is_persistent" soup_cookie_jar_is_persistent :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    IO CInt

{- |
Gets whether /@jar@/ stores cookies persistenly.

@since 2.40
-}
cookieJarIsPersistent ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@jar@/ storage is persistent or 'False' otherwise. -}
cookieJarIsPersistent jar = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    result <- soup_cookie_jar_is_persistent jar'
    let result' = (/= 0) result
    touchManagedPtr jar
    return result'

data CookieJarIsPersistentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarIsPersistentMethodInfo a signature where
    overloadedMethod _ = cookieJarIsPersistent

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

foreign import ccall "soup_cookie_jar_save" soup_cookie_jar_save :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    IO ()

{-# DEPRECATED cookieJarSave ["This is a no-op."] #-}
{- |
This function exists for backward compatibility, but does not do
anything any more; cookie jars are saved automatically when they
are changed.

@since 2.24
-}
cookieJarSave ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> m ()
cookieJarSave jar = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    soup_cookie_jar_save jar'
    touchManagedPtr jar
    return ()

data CookieJarSaveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarSaveMethodInfo a signature where
    overloadedMethod _ = cookieJarSave

-- method CookieJar::set_accept_policy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "policy", argType = TInterface (Name {namespace = "Soup", name = "CookieJarAcceptPolicy"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJarAcceptPolicy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_jar_set_accept_policy" soup_cookie_jar_set_accept_policy :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "Soup", name = "CookieJarAcceptPolicy"})
    IO ()

{- |
Sets /@policy@/ as the cookie acceptance policy for /@jar@/.

@since 2.30
-}
cookieJarSetAcceptPolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.Enums.CookieJarAcceptPolicy
    {- ^ /@policy@/: a 'GI.Soup.Enums.CookieJarAcceptPolicy' -}
    -> m ()
cookieJarSetAcceptPolicy jar policy = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    let policy' = (fromIntegral . fromEnum) policy
    soup_cookie_jar_set_accept_policy jar' policy'
    touchManagedPtr jar
    return ()

data CookieJarSetAcceptPolicyMethodInfo
instance (signature ~ (Soup.Enums.CookieJarAcceptPolicy -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarSetAcceptPolicyMethodInfo a signature where
    overloadedMethod _ = cookieJarSetAcceptPolicy

-- method CookieJar::set_cookie
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI setting the cookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stringified cookie 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 "soup_cookie_jar_set_cookie" soup_cookie_jar_set_cookie :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- cookie : TBasicType TUTF8
    IO ()

{- |
Adds /@cookie@/ to /@jar@/, exactly as though it had appeared in a
Set-Cookie header returned from a request to /@uri@/.

Keep in mind that if the 'GI.Soup.Enums.CookieJarAcceptPolicy'
'GI.Soup.Enums.CookieJarAcceptPolicyNoThirdParty' is set you\'ll need to use
'GI.Soup.Objects.CookieJar.cookieJarSetCookieWithFirstParty', otherwise the jar
will have no way of knowing if the cookie is being set by a third
party or not.

@since 2.24
-}
cookieJarSetCookie ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: the URI setting the cookie -}
    -> T.Text
    {- ^ /@cookie@/: the stringified cookie to set -}
    -> m ()
cookieJarSetCookie jar uri cookie = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    uri' <- unsafeManagedPtrGetPtr uri
    cookie' <- textToCString cookie
    soup_cookie_jar_set_cookie jar' uri' cookie'
    touchManagedPtr jar
    touchManagedPtr uri
    freeMem cookie'
    return ()

data CookieJarSetCookieMethodInfo
instance (signature ~ (Soup.URI.URI -> T.Text -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarSetCookieMethodInfo a signature where
    overloadedMethod _ = cookieJarSetCookie

-- method CookieJar::set_cookie_with_first_party
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "jar", argType = TInterface (Name {namespace = "Soup", name = "CookieJar"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupCookieJar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI setting the cookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first_party", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI for the main document", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cookie", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stringified cookie 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 "soup_cookie_jar_set_cookie_with_first_party" soup_cookie_jar_set_cookie_with_first_party :: 
    Ptr CookieJar ->                        -- jar : TInterface (Name {namespace = "Soup", name = "CookieJar"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr Soup.URI.URI ->                     -- first_party : TInterface (Name {namespace = "Soup", name = "URI"})
    CString ->                              -- cookie : TBasicType TUTF8
    IO ()

{- |
Adds /@cookie@/ to /@jar@/, exactly as though it had appeared in a
Set-Cookie header returned from a request to /@uri@/. /@firstParty@/
will be used to reject cookies coming from third party resources in
case such a security policy is set in the /@jar@/.

@since 2.30
-}
cookieJarSetCookieWithFirstParty ::
    (B.CallStack.HasCallStack, MonadIO m, IsCookieJar a) =>
    a
    {- ^ /@jar@/: a 'GI.Soup.Objects.CookieJar.CookieJar' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: the URI setting the cookie -}
    -> Soup.URI.URI
    {- ^ /@firstParty@/: the URI for the main document -}
    -> T.Text
    {- ^ /@cookie@/: the stringified cookie to set -}
    -> m ()
cookieJarSetCookieWithFirstParty jar uri firstParty cookie = liftIO $ do
    jar' <- unsafeManagedPtrCastPtr jar
    uri' <- unsafeManagedPtrGetPtr uri
    firstParty' <- unsafeManagedPtrGetPtr firstParty
    cookie' <- textToCString cookie
    soup_cookie_jar_set_cookie_with_first_party jar' uri' firstParty' cookie'
    touchManagedPtr jar
    touchManagedPtr uri
    touchManagedPtr firstParty
    freeMem cookie'
    return ()

data CookieJarSetCookieWithFirstPartyMethodInfo
instance (signature ~ (Soup.URI.URI -> Soup.URI.URI -> T.Text -> m ()), MonadIO m, IsCookieJar a) => O.MethodInfo CookieJarSetCookieWithFirstPartyMethodInfo a signature where
    overloadedMethod _ = cookieJarSetCookieWithFirstParty