{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

An HTTP cookie.

/@name@/ and /@value@/ will be set for all cookies. If the cookie is
generated from a string that appears to have no name, then /@name@/
will be the empty string.

/@domain@/ and /@path@/ give the host or domain, and path within that
host\/domain, to restrict this cookie to. If /@domain@/ starts with
\".\", that indicates a domain (which matches the string after the
\".\", or any hostname that has /@domain@/ as a suffix). Otherwise, it
is a hostname and must match exactly.

/@expires@/ will be non-'Nothing' if the cookie uses either the original
\"expires\" attribute, or the newer \"max-age\" attribute. If /@expires@/
is 'Nothing', it indicates that neither \"expires\" nor \"max-age\" was
specified, and the cookie expires at the end of the session.

If /@httpOnly@/ is set, the cookie should not be exposed to untrusted
code (eg, javascript), so as to minimize the danger posed by
cross-site scripting attacks.

/Since: 2.24/
-}

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

module GI.Soup.Structs.Cookie
    ( 

-- * Exported types
    Cookie(..)                              ,
    newZeroCookie                           ,
    noCookie                                ,


 -- * Methods
-- ** appliesToUri #method:appliesToUri#

#if ENABLE_OVERLOADING
    CookieAppliesToUriMethodInfo            ,
#endif
    cookieAppliesToUri                      ,


-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    CookieCopyMethodInfo                    ,
#endif
    cookieCopy                              ,


-- ** domainMatches #method:domainMatches#

#if ENABLE_OVERLOADING
    CookieDomainMatchesMethodInfo           ,
#endif
    cookieDomainMatches                     ,


-- ** equal #method:equal#

#if ENABLE_OVERLOADING
    CookieEqualMethodInfo                   ,
#endif
    cookieEqual                             ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    CookieFreeMethodInfo                    ,
#endif
    cookieFree                              ,


-- ** getDomain #method:getDomain#

#if ENABLE_OVERLOADING
    CookieGetDomainMethodInfo               ,
#endif
    cookieGetDomain                         ,


-- ** getExpires #method:getExpires#

#if ENABLE_OVERLOADING
    CookieGetExpiresMethodInfo              ,
#endif
    cookieGetExpires                        ,


-- ** getHttpOnly #method:getHttpOnly#

#if ENABLE_OVERLOADING
    CookieGetHttpOnlyMethodInfo             ,
#endif
    cookieGetHttpOnly                       ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    CookieGetNameMethodInfo                 ,
#endif
    cookieGetName                           ,


-- ** getPath #method:getPath#

#if ENABLE_OVERLOADING
    CookieGetPathMethodInfo                 ,
#endif
    cookieGetPath                           ,


-- ** getSecure #method:getSecure#

#if ENABLE_OVERLOADING
    CookieGetSecureMethodInfo               ,
#endif
    cookieGetSecure                         ,


-- ** getValue #method:getValue#

#if ENABLE_OVERLOADING
    CookieGetValueMethodInfo                ,
#endif
    cookieGetValue                          ,


-- ** new #method:new#

    cookieNew                               ,


-- ** parse #method:parse#

    cookieParse                             ,


-- ** setDomain #method:setDomain#

#if ENABLE_OVERLOADING
    CookieSetDomainMethodInfo               ,
#endif
    cookieSetDomain                         ,


-- ** setExpires #method:setExpires#

#if ENABLE_OVERLOADING
    CookieSetExpiresMethodInfo              ,
#endif
    cookieSetExpires                        ,


-- ** setHttpOnly #method:setHttpOnly#

#if ENABLE_OVERLOADING
    CookieSetHttpOnlyMethodInfo             ,
#endif
    cookieSetHttpOnly                       ,


-- ** setMaxAge #method:setMaxAge#

#if ENABLE_OVERLOADING
    CookieSetMaxAgeMethodInfo               ,
#endif
    cookieSetMaxAge                         ,


-- ** setName #method:setName#

#if ENABLE_OVERLOADING
    CookieSetNameMethodInfo                 ,
#endif
    cookieSetName                           ,


-- ** setPath #method:setPath#

#if ENABLE_OVERLOADING
    CookieSetPathMethodInfo                 ,
#endif
    cookieSetPath                           ,


-- ** setSecure #method:setSecure#

#if ENABLE_OVERLOADING
    CookieSetSecureMethodInfo               ,
#endif
    cookieSetSecure                         ,


-- ** setValue #method:setValue#

#if ENABLE_OVERLOADING
    CookieSetValueMethodInfo                ,
#endif
    cookieSetValue                          ,


-- ** toCookieHeader #method:toCookieHeader#

#if ENABLE_OVERLOADING
    CookieToCookieHeaderMethodInfo          ,
#endif
    cookieToCookieHeader                    ,


-- ** toSetCookieHeader #method:toSetCookieHeader#

#if ENABLE_OVERLOADING
    CookieToSetCookieHeaderMethodInfo       ,
#endif
    cookieToSetCookieHeader                 ,




 -- * Properties
-- ** domain #attr:domain#
{- | the \"domain\" attribute, or else the hostname that the
cookie came from.
-}
    clearCookieDomain                       ,
#if ENABLE_OVERLOADING
    cookie_domain                           ,
#endif
    getCookieDomain                         ,
    setCookieDomain                         ,


-- ** expires #attr:expires#
{- | the cookie expiration time, or 'Nothing' for a session cookie
-}
    clearCookieExpires                      ,
#if ENABLE_OVERLOADING
    cookie_expires                          ,
#endif
    getCookieExpires                        ,
    setCookieExpires                        ,


-- ** httpOnly #attr:httpOnly#
{- | 'True' if the cookie should not be exposed to scripts
-}
#if ENABLE_OVERLOADING
    cookie_httpOnly                         ,
#endif
    getCookieHttpOnly                       ,
    setCookieHttpOnly                       ,


-- ** name #attr:name#
{- | the cookie name
-}
    clearCookieName                         ,
#if ENABLE_OVERLOADING
    cookie_name                             ,
#endif
    getCookieName                           ,
    setCookieName                           ,


-- ** path #attr:path#
{- | the \"path\" attribute, or 'Nothing'
-}
    clearCookiePath                         ,
#if ENABLE_OVERLOADING
    cookie_path                             ,
#endif
    getCookiePath                           ,
    setCookiePath                           ,


-- ** secure #attr:secure#
{- | 'True' if the cookie should only be tranferred over SSL
-}
#if ENABLE_OVERLOADING
    cookie_secure                           ,
#endif
    getCookieSecure                         ,
    setCookieSecure                         ,


-- ** value #attr:value#
{- | the cookie value
-}
    clearCookieValue                        ,
#if ENABLE_OVERLOADING
    cookie_value                            ,
#endif
    getCookieValue                          ,
    setCookieValue                          ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Soup.Structs.Date as Soup.Date
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

-- | Memory-managed wrapper type.
newtype Cookie = Cookie (ManagedPtr Cookie)
foreign import ccall "soup_cookie_get_type" c_soup_cookie_get_type :: 
    IO GType

instance BoxedObject Cookie where
    boxedType _ = c_soup_cookie_get_type

-- | Construct a `Cookie` struct initialized to zero.
newZeroCookie :: MonadIO m => m Cookie
newZeroCookie = liftIO $ callocBoxedBytes 48 >>= wrapBoxed Cookie

instance tag ~ 'AttrSet => Constructible Cookie tag where
    new _ attrs = do
        o <- newZeroCookie
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `Cookie`.
noCookie :: Maybe Cookie
noCookie = Nothing

{- |
Get the value of the “@name@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #name
@
-}
getCookieName :: MonadIO m => Cookie -> m (Maybe T.Text)
getCookieName s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@name@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #name 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieName :: MonadIO m => Cookie -> CString -> m ()
setCookieName s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

{- |
Set the value of the “@name@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #name
@
-}
clearCookieName :: MonadIO m => Cookie -> m ()
clearCookieName s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data CookieNameFieldInfo
instance AttrInfo CookieNameFieldInfo where
    type AttrAllowedOps CookieNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CookieNameFieldInfo = (~) CString
    type AttrBaseTypeConstraint CookieNameFieldInfo = (~) Cookie
    type AttrGetType CookieNameFieldInfo = Maybe T.Text
    type AttrLabel CookieNameFieldInfo = "name"
    type AttrOrigin CookieNameFieldInfo = Cookie
    attrGet _ = getCookieName
    attrSet _ = setCookieName
    attrConstruct = undefined
    attrClear _ = clearCookieName

cookie_name :: AttrLabelProxy "name"
cookie_name = AttrLabelProxy

#endif


{- |
Get the value of the “@value@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #value
@
-}
getCookieValue :: MonadIO m => Cookie -> m (Maybe T.Text)
getCookieValue s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@value@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #value 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieValue :: MonadIO m => Cookie -> CString -> m ()
setCookieValue s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: CString)

{- |
Set the value of the “@value@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #value
@
-}
clearCookieValue :: MonadIO m => Cookie -> m ()
clearCookieValue s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data CookieValueFieldInfo
instance AttrInfo CookieValueFieldInfo where
    type AttrAllowedOps CookieValueFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CookieValueFieldInfo = (~) CString
    type AttrBaseTypeConstraint CookieValueFieldInfo = (~) Cookie
    type AttrGetType CookieValueFieldInfo = Maybe T.Text
    type AttrLabel CookieValueFieldInfo = "value"
    type AttrOrigin CookieValueFieldInfo = Cookie
    attrGet _ = getCookieValue
    attrSet _ = setCookieValue
    attrConstruct = undefined
    attrClear _ = clearCookieValue

cookie_value :: AttrLabelProxy "value"
cookie_value = AttrLabelProxy

#endif


{- |
Get the value of the “@domain@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #domain
@
-}
getCookieDomain :: MonadIO m => Cookie -> m (Maybe T.Text)
getCookieDomain s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@domain@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #domain 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieDomain :: MonadIO m => Cookie -> CString -> m ()
setCookieDomain s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: CString)

{- |
Set the value of the “@domain@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #domain
@
-}
clearCookieDomain :: MonadIO m => Cookie -> m ()
clearCookieDomain s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data CookieDomainFieldInfo
instance AttrInfo CookieDomainFieldInfo where
    type AttrAllowedOps CookieDomainFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CookieDomainFieldInfo = (~) CString
    type AttrBaseTypeConstraint CookieDomainFieldInfo = (~) Cookie
    type AttrGetType CookieDomainFieldInfo = Maybe T.Text
    type AttrLabel CookieDomainFieldInfo = "domain"
    type AttrOrigin CookieDomainFieldInfo = Cookie
    attrGet _ = getCookieDomain
    attrSet _ = setCookieDomain
    attrConstruct = undefined
    attrClear _ = clearCookieDomain

cookie_domain :: AttrLabelProxy "domain"
cookie_domain = AttrLabelProxy

#endif


{- |
Get the value of the “@path@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #path
@
-}
getCookiePath :: MonadIO m => Cookie -> m (Maybe T.Text)
getCookiePath s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@path@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #path 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookiePath :: MonadIO m => Cookie -> CString -> m ()
setCookiePath s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: CString)

{- |
Set the value of the “@path@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #path
@
-}
clearCookiePath :: MonadIO m => Cookie -> m ()
clearCookiePath s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data CookiePathFieldInfo
instance AttrInfo CookiePathFieldInfo where
    type AttrAllowedOps CookiePathFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CookiePathFieldInfo = (~) CString
    type AttrBaseTypeConstraint CookiePathFieldInfo = (~) Cookie
    type AttrGetType CookiePathFieldInfo = Maybe T.Text
    type AttrLabel CookiePathFieldInfo = "path"
    type AttrOrigin CookiePathFieldInfo = Cookie
    attrGet _ = getCookiePath
    attrSet _ = setCookiePath
    attrConstruct = undefined
    attrClear _ = clearCookiePath

cookie_path :: AttrLabelProxy "path"
cookie_path = AttrLabelProxy

#endif


{- |
Get the value of the “@expires@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #expires
@
-}
getCookieExpires :: MonadIO m => Cookie -> m (Maybe Soup.Date.Date)
getCookieExpires s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Soup.Date.Date)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Soup.Date.Date) val'
        return val''
    return result

{- |
Set the value of the “@expires@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #expires 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieExpires :: MonadIO m => Cookie -> Ptr Soup.Date.Date -> m ()
setCookieExpires s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Ptr Soup.Date.Date)

{- |
Set the value of the “@expires@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #expires
@
-}
clearCookieExpires :: MonadIO m => Cookie -> m ()
clearCookieExpires s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Soup.Date.Date)

#if ENABLE_OVERLOADING
data CookieExpiresFieldInfo
instance AttrInfo CookieExpiresFieldInfo where
    type AttrAllowedOps CookieExpiresFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CookieExpiresFieldInfo = (~) (Ptr Soup.Date.Date)
    type AttrBaseTypeConstraint CookieExpiresFieldInfo = (~) Cookie
    type AttrGetType CookieExpiresFieldInfo = Maybe Soup.Date.Date
    type AttrLabel CookieExpiresFieldInfo = "expires"
    type AttrOrigin CookieExpiresFieldInfo = Cookie
    attrGet _ = getCookieExpires
    attrSet _ = setCookieExpires
    attrConstruct = undefined
    attrClear _ = clearCookieExpires

cookie_expires :: AttrLabelProxy "expires"
cookie_expires = AttrLabelProxy

#endif


{- |
Get the value of the “@secure@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #secure
@
-}
getCookieSecure :: MonadIO m => Cookie -> m Bool
getCookieSecure s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CInt
    let val' = (/= 0) val
    return val'

{- |
Set the value of the “@secure@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #secure 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieSecure :: MonadIO m => Cookie -> Bool -> m ()
setCookieSecure s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 40) (val' :: CInt)

#if ENABLE_OVERLOADING
data CookieSecureFieldInfo
instance AttrInfo CookieSecureFieldInfo where
    type AttrAllowedOps CookieSecureFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CookieSecureFieldInfo = (~) Bool
    type AttrBaseTypeConstraint CookieSecureFieldInfo = (~) Cookie
    type AttrGetType CookieSecureFieldInfo = Bool
    type AttrLabel CookieSecureFieldInfo = "secure"
    type AttrOrigin CookieSecureFieldInfo = Cookie
    attrGet _ = getCookieSecure
    attrSet _ = setCookieSecure
    attrConstruct = undefined
    attrClear _ = undefined

cookie_secure :: AttrLabelProxy "secure"
cookie_secure = AttrLabelProxy

#endif


{- |
Get the value of the “@http_only@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' cookie #httpOnly
@
-}
getCookieHttpOnly :: MonadIO m => Cookie -> m Bool
getCookieHttpOnly s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 44) :: IO CInt
    let val' = (/= 0) val
    return val'

{- |
Set the value of the “@http_only@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' cookie [ #httpOnly 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCookieHttpOnly :: MonadIO m => Cookie -> Bool -> m ()
setCookieHttpOnly s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 44) (val' :: CInt)

#if ENABLE_OVERLOADING
data CookieHttpOnlyFieldInfo
instance AttrInfo CookieHttpOnlyFieldInfo where
    type AttrAllowedOps CookieHttpOnlyFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint CookieHttpOnlyFieldInfo = (~) Bool
    type AttrBaseTypeConstraint CookieHttpOnlyFieldInfo = (~) Cookie
    type AttrGetType CookieHttpOnlyFieldInfo = Bool
    type AttrLabel CookieHttpOnlyFieldInfo = "http_only"
    type AttrOrigin CookieHttpOnlyFieldInfo = Cookie
    attrGet _ = getCookieHttpOnly
    attrSet _ = setCookieHttpOnly
    attrConstruct = undefined
    attrClear _ = undefined

cookie_httpOnly :: AttrLabelProxy "httpOnly"
cookie_httpOnly = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList Cookie
type instance O.AttributeList Cookie = CookieAttributeList
type CookieAttributeList = ('[ '("name", CookieNameFieldInfo), '("value", CookieValueFieldInfo), '("domain", CookieDomainFieldInfo), '("path", CookiePathFieldInfo), '("expires", CookieExpiresFieldInfo), '("secure", CookieSecureFieldInfo), '("httpOnly", CookieHttpOnlyFieldInfo)] :: [(Symbol, *)])
#endif

-- method Cookie::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cookie name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cookie value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cookie domain or hostname", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cookie path, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_age", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "max age of the cookie, or -1 for a session cookie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Cookie"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_new" soup_cookie_new :: 
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    CString ->                              -- domain : TBasicType TUTF8
    CString ->                              -- path : TBasicType TUTF8
    Int32 ->                                -- max_age : TBasicType TInt
    IO (Ptr Cookie)

{- |
Creates a new 'GI.Soup.Structs.Cookie.Cookie' with the given attributes. (Use
'GI.Soup.Structs.Cookie.cookieSetSecure' and 'GI.Soup.Structs.Cookie.cookieSetHttpOnly' if you
need to set those attributes on the returned cookie.)

If /@domain@/ starts with \".\", that indicates a domain (which matches
the string after the \".\", or any hostname that has /@domain@/ as a
suffix). Otherwise, it is a hostname and must match exactly.

/@maxAge@/ is used to set the \"expires\" attribute on the cookie; pass
-1 to not include the attribute (indicating that the cookie expires
with the current session), 0 for an already-expired cookie, or a
lifetime in seconds. You can use the constants
'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_HOUR', 'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_DAY',
'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_WEEK' and 'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_YEAR' (or
multiples thereof) to calculate this value. (If you really care
about setting the exact time that the cookie will expire, use
'GI.Soup.Structs.Cookie.cookieSetExpires'.)

/Since: 2.24/
-}
cookieNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@name@/: cookie name -}
    -> T.Text
    {- ^ /@value@/: cookie value -}
    -> T.Text
    {- ^ /@domain@/: cookie domain or hostname -}
    -> T.Text
    {- ^ /@path@/: cookie path, or 'Nothing' -}
    -> Int32
    {- ^ /@maxAge@/: max age of the cookie, or -1 for a session cookie -}
    -> m Cookie
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Cookie.Cookie'. -}
cookieNew name value domain path maxAge = liftIO $ do
    name' <- textToCString name
    value' <- textToCString value
    domain' <- textToCString domain
    path' <- textToCString path
    result <- soup_cookie_new name' value' domain' path' maxAge
    checkUnexpectedReturnNULL "cookieNew" result
    result' <- (wrapBoxed Cookie) result
    freeMem name'
    freeMem value'
    freeMem domain'
    freeMem path'
    return result'

#if ENABLE_OVERLOADING
#endif

-- method Cookie::applies_to_uri
-- method type : OrdinaryMethod
-- Args : [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},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}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_applies_to_uri" soup_cookie_applies_to_uri :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO CInt

{- |
Tests if /@cookie@/ should be sent to /@uri@/.

(At the moment, this does not check that /@cookie@/\'s domain matches
/@uri@/, because it assumes that the caller has already done that.
But don\'t rely on that; it may change in the future.)

/Since: 2.24/
-}
cookieAppliesToUri ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Soup.URI.URI
    {- ^ /@uri@/: a 'GI.Soup.Structs.URI.URI' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@cookie@/ should be sent to /@uri@/, 'False' if
not -}
cookieAppliesToUri cookie uri = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    uri' <- unsafeManagedPtrGetPtr uri
    result <- soup_cookie_applies_to_uri cookie' uri'
    let result' = (/= 0) result
    touchManagedPtr cookie
    touchManagedPtr uri
    return result'

#if ENABLE_OVERLOADING
data CookieAppliesToUriMethodInfo
instance (signature ~ (Soup.URI.URI -> m Bool), MonadIO m) => O.MethodInfo CookieAppliesToUriMethodInfo Cookie signature where
    overloadedMethod _ = cookieAppliesToUri

#endif

-- method Cookie::copy
-- method type : OrdinaryMethod
-- Args : [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 : Just (TInterface (Name {namespace = "Soup", name = "Cookie"}))
-- throws : False
-- Skip return : False

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

{- |
Copies /@cookie@/.

/Since: 2.24/
-}
cookieCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m Cookie
    {- ^ __Returns:__ a copy of /@cookie@/ -}
cookieCopy cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_copy cookie'
    checkUnexpectedReturnNULL "cookieCopy" result
    result' <- (wrapBoxed Cookie) result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieCopyMethodInfo
instance (signature ~ (m Cookie), MonadIO m) => O.MethodInfo CookieCopyMethodInfo Cookie signature where
    overloadedMethod _ = cookieCopy

#endif

-- method Cookie::domain_matches
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI", 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_domain_matches" soup_cookie_domain_matches :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CString ->                              -- host : TBasicType TUTF8
    IO CInt

{- |
Checks if the /@cookie@/\'s domain and /@host@/ match in the sense that
/@cookie@/ should be sent when making a request to /@host@/, or that
/@cookie@/ should be accepted when receiving a response from /@host@/.

/Since: 2.30/
-}
cookieDomainMatches ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> T.Text
    {- ^ /@host@/: a URI -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the domains match, 'False' otherwise -}
cookieDomainMatches cookie host = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    host' <- textToCString host
    result <- soup_cookie_domain_matches cookie' host'
    let result' = (/= 0) result
    touchManagedPtr cookie
    freeMem host'
    return result'

#if ENABLE_OVERLOADING
data CookieDomainMatchesMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo CookieDomainMatchesMethodInfo Cookie signature where
    overloadedMethod _ = cookieDomainMatches

#endif

-- method Cookie::equal
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "cookie1", 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},Arg {argCName = "cookie2", 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 : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_equal" soup_cookie_equal :: 
    Ptr Cookie ->                           -- cookie1 : TInterface (Name {namespace = "Soup", name = "Cookie"})
    Ptr Cookie ->                           -- cookie2 : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CInt

{- |
Tests if /@cookie1@/ and /@cookie2@/ are equal.

Note that currently, this does not check that the cookie domains
match. This may change in the future.

/Since: 2.24/
-}
cookieEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie1@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Cookie
    {- ^ /@cookie2@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m Bool
    {- ^ __Returns:__ whether the cookies are equal. -}
cookieEqual cookie1 cookie2 = liftIO $ do
    cookie1' <- unsafeManagedPtrGetPtr cookie1
    cookie2' <- unsafeManagedPtrGetPtr cookie2
    result <- soup_cookie_equal cookie1' cookie2'
    let result' = (/= 0) result
    touchManagedPtr cookie1
    touchManagedPtr cookie2
    return result'

#if ENABLE_OVERLOADING
data CookieEqualMethodInfo
instance (signature ~ (Cookie -> m Bool), MonadIO m) => O.MethodInfo CookieEqualMethodInfo Cookie signature where
    overloadedMethod _ = cookieEqual

#endif

-- method Cookie::free
-- method type : OrdinaryMethod
-- Args : [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_free" soup_cookie_free :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO ()

{- |
Frees /@cookie@/

/Since: 2.24/
-}
cookieFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m ()
cookieFree cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    soup_cookie_free cookie'
    touchManagedPtr cookie
    return ()

#if ENABLE_OVERLOADING
data CookieFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo CookieFreeMethodInfo Cookie signature where
    overloadedMethod _ = cookieFree

#endif

-- method Cookie::get_domain
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_domain" soup_cookie_get_domain :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Gets /@cookie@/\'s domain

/Since: 2.32/
-}
cookieGetDomain ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ /@cookie@/\'s domain -}
cookieGetDomain cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_domain cookie'
    checkUnexpectedReturnNULL "cookieGetDomain" result
    result' <- cstringToText result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetDomainMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieGetDomainMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetDomain

#endif

-- method Cookie::get_expires
-- method type : OrdinaryMethod
-- Args : [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 : Just (TInterface (Name {namespace = "Soup", name = "Date"}))
-- throws : False
-- Skip return : False

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

{- |
Gets /@cookie@/\'s expiration time.

/Since: 2.32/
-}
cookieGetExpires ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m (Maybe Soup.Date.Date)
    {- ^ __Returns:__ /@cookie@/\'s expiration
time, which is owned by /@cookie@/ and should not be modified or
freed. -}
cookieGetExpires cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_expires cookie'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Soup.Date.Date) result'
        return result''
    touchManagedPtr cookie
    return maybeResult

#if ENABLE_OVERLOADING
data CookieGetExpiresMethodInfo
instance (signature ~ (m (Maybe Soup.Date.Date)), MonadIO m) => O.MethodInfo CookieGetExpiresMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetExpires

#endif

-- method Cookie::get_http_only
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_http_only" soup_cookie_get_http_only :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CInt

{- |
Gets /@cookie@/\'s HttpOnly attribute

/Since: 2.32/
-}
cookieGetHttpOnly ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m Bool
    {- ^ __Returns:__ /@cookie@/\'s HttpOnly attribute -}
cookieGetHttpOnly cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_http_only cookie'
    let result' = (/= 0) result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetHttpOnlyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo CookieGetHttpOnlyMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetHttpOnly

#endif

-- method Cookie::get_name
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_name" soup_cookie_get_name :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Gets /@cookie@/\'s name

/Since: 2.32/
-}
cookieGetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ /@cookie@/\'s name -}
cookieGetName cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_name cookie'
    checkUnexpectedReturnNULL "cookieGetName" result
    result' <- cstringToText result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieGetNameMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetName

#endif

-- method Cookie::get_path
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_path" soup_cookie_get_path :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Gets /@cookie@/\'s path

/Since: 2.32/
-}
cookieGetPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ /@cookie@/\'s path -}
cookieGetPath cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_path cookie'
    checkUnexpectedReturnNULL "cookieGetPath" result
    result' <- cstringToText result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetPathMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieGetPathMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetPath

#endif

-- method Cookie::get_secure
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_secure" soup_cookie_get_secure :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CInt

{- |
Gets /@cookie@/\'s secure attribute

/Since: 2.32/
-}
cookieGetSecure ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m Bool
    {- ^ __Returns:__ /@cookie@/\'s secure attribute -}
cookieGetSecure cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_secure cookie'
    let result' = (/= 0) result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetSecureMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo CookieGetSecureMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetSecure

#endif

-- method Cookie::get_value
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_get_value" soup_cookie_get_value :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Gets /@cookie@/\'s value

/Since: 2.32/
-}
cookieGetValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ /@cookie@/\'s value -}
cookieGetValue cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_get_value cookie'
    checkUnexpectedReturnNULL "cookieGetValue" result
    result' <- cstringToText result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieGetValueMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieGetValueMethodInfo Cookie signature where
    overloadedMethod _ = cookieGetValue

#endif

-- method Cookie::set_domain
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new domain", 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_set_domain" soup_cookie_set_domain :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CString ->                              -- domain : TBasicType TUTF8
    IO ()

{- |
Sets /@cookie@/\'s domain to /@domain@/

/Since: 2.24/
-}
cookieSetDomain ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> T.Text
    {- ^ /@domain@/: the new domain -}
    -> m ()
cookieSetDomain cookie domain = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    domain' <- textToCString domain
    soup_cookie_set_domain cookie' domain'
    touchManagedPtr cookie
    freeMem domain'
    return ()

#if ENABLE_OVERLOADING
data CookieSetDomainMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo CookieSetDomainMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetDomain

#endif

-- method Cookie::set_expires
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "expires", argType = TInterface (Name {namespace = "Soup", name = "Date"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new expiration time, or %NULL", 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_set_expires" soup_cookie_set_expires :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    Ptr Soup.Date.Date ->                   -- expires : TInterface (Name {namespace = "Soup", name = "Date"})
    IO ()

{- |
Sets /@cookie@/\'s expiration time to /@expires@/. If /@expires@/ is 'Nothing',
/@cookie@/ will be a session cookie and will expire at the end of the
client\'s session.

(This sets the same property as 'GI.Soup.Structs.Cookie.cookieSetMaxAge'.)

/Since: 2.24/
-}
cookieSetExpires ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Soup.Date.Date
    {- ^ /@expires@/: the new expiration time, or 'Nothing' -}
    -> m ()
cookieSetExpires cookie expires = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    expires' <- unsafeManagedPtrGetPtr expires
    soup_cookie_set_expires cookie' expires'
    touchManagedPtr cookie
    touchManagedPtr expires
    return ()

#if ENABLE_OVERLOADING
data CookieSetExpiresMethodInfo
instance (signature ~ (Soup.Date.Date -> m ()), MonadIO m) => O.MethodInfo CookieSetExpiresMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetExpires

#endif

-- method Cookie::set_http_only
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "http_only", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the HttpOnly attribute", 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_set_http_only" soup_cookie_set_http_only :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CInt ->                                 -- http_only : TBasicType TBoolean
    IO ()

{- |
Sets /@cookie@/\'s HttpOnly attribute to /@httpOnly@/. If 'True', /@cookie@/
will be marked as \"http only\", meaning it should not be exposed to
web page scripts or other untrusted code.

/Since: 2.24/
-}
cookieSetHttpOnly ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Bool
    {- ^ /@httpOnly@/: the new value for the HttpOnly attribute -}
    -> m ()
cookieSetHttpOnly cookie httpOnly = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    let httpOnly' = (fromIntegral . fromEnum) httpOnly
    soup_cookie_set_http_only cookie' httpOnly'
    touchManagedPtr cookie
    return ()

#if ENABLE_OVERLOADING
data CookieSetHttpOnlyMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo CookieSetHttpOnlyMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetHttpOnly

#endif

-- method Cookie::set_max_age
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "max_age", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new max age", 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_set_max_age" soup_cookie_set_max_age :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    Int32 ->                                -- max_age : TBasicType TInt
    IO ()

{- |
Sets /@cookie@/\'s max age to /@maxAge@/. If /@maxAge@/ is -1, the cookie
is a session cookie, and will expire at the end of the client\'s
session. Otherwise, it is the number of seconds until the cookie
expires. You can use the constants 'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_HOUR',
'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_DAY', 'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_WEEK' and
'GI.Soup.Constants.COOKIE_MAX_AGE_ONE_YEAR' (or multiples thereof) to calculate
this value. (A value of 0 indicates that the cookie should be
considered already-expired.)

(This sets the same property as 'GI.Soup.Structs.Cookie.cookieSetExpires'.)

/Since: 2.24/
-}
cookieSetMaxAge ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Int32
    {- ^ /@maxAge@/: the new max age -}
    -> m ()
cookieSetMaxAge cookie maxAge = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    soup_cookie_set_max_age cookie' maxAge
    touchManagedPtr cookie
    return ()

#if ENABLE_OVERLOADING
data CookieSetMaxAgeMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m) => O.MethodInfo CookieSetMaxAgeMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetMaxAge

#endif

-- method Cookie::set_name
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new name", 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_set_name" soup_cookie_set_name :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
Sets /@cookie@/\'s name to /@name@/

/Since: 2.24/
-}
cookieSetName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> T.Text
    {- ^ /@name@/: the new name -}
    -> m ()
cookieSetName cookie name = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    name' <- textToCString name
    soup_cookie_set_name cookie' name'
    touchManagedPtr cookie
    freeMem name'
    return ()

#if ENABLE_OVERLOADING
data CookieSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo CookieSetNameMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetName

#endif

-- method Cookie::set_path
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new path", 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_set_path" soup_cookie_set_path :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CString ->                              -- path : TBasicType TUTF8
    IO ()

{- |
Sets /@cookie@/\'s path to /@path@/

/Since: 2.24/
-}
cookieSetPath ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> T.Text
    {- ^ /@path@/: the new path -}
    -> m ()
cookieSetPath cookie path = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    path' <- textToCString path
    soup_cookie_set_path cookie' path'
    touchManagedPtr cookie
    freeMem path'
    return ()

#if ENABLE_OVERLOADING
data CookieSetPathMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo CookieSetPathMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetPath

#endif

-- method Cookie::set_secure
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "secure", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the secure attribute", 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_set_secure" soup_cookie_set_secure :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CInt ->                                 -- secure : TBasicType TBoolean
    IO ()

{- |
Sets /@cookie@/\'s secure attribute to /@secure@/. If 'True', /@cookie@/ will
only be transmitted from the client to the server over secure
(https) connections.

/Since: 2.24/
-}
cookieSetSecure ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> Bool
    {- ^ /@secure@/: the new value for the secure attribute -}
    -> m ()
cookieSetSecure cookie secure = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    let secure' = (fromIntegral . fromEnum) secure
    soup_cookie_set_secure cookie' secure'
    touchManagedPtr cookie
    return ()

#if ENABLE_OVERLOADING
data CookieSetSecureMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo CookieSetSecureMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetSecure

#endif

-- method Cookie::set_value
-- method type : OrdinaryMethod
-- Args : [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},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value", 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_set_value" soup_cookie_set_value :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
Sets /@cookie@/\'s value to /@value@/

/Since: 2.24/
-}
cookieSetValue ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> T.Text
    {- ^ /@value@/: the new value -}
    -> m ()
cookieSetValue cookie value = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    value' <- textToCString value
    soup_cookie_set_value cookie' value'
    touchManagedPtr cookie
    freeMem value'
    return ()

#if ENABLE_OVERLOADING
data CookieSetValueMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo CookieSetValueMethodInfo Cookie signature where
    overloadedMethod _ = cookieSetValue

#endif

-- method Cookie::to_cookie_header
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_to_cookie_header" soup_cookie_to_cookie_header :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Serializes /@cookie@/ in the format used by the Cookie header (ie, for
returning a cookie from a 'GI.Soup.Objects.Session.Session' to a server).

/Since: 2.24/
-}
cookieToCookieHeader ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ the header -}
cookieToCookieHeader cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_to_cookie_header cookie'
    checkUnexpectedReturnNULL "cookieToCookieHeader" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieToCookieHeaderMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieToCookieHeaderMethodInfo Cookie signature where
    overloadedMethod _ = cookieToCookieHeader

#endif

-- method Cookie::to_set_cookie_header
-- method type : OrdinaryMethod
-- Args : [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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_to_set_cookie_header" soup_cookie_to_set_cookie_header :: 
    Ptr Cookie ->                           -- cookie : TInterface (Name {namespace = "Soup", name = "Cookie"})
    IO CString

{- |
Serializes /@cookie@/ in the format used by the Set-Cookie header
(ie, for sending a cookie from a 'GI.Soup.Objects.Server.Server' to a client).

/Since: 2.24/
-}
cookieToSetCookieHeader ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Cookie
    {- ^ /@cookie@/: a 'GI.Soup.Structs.Cookie.Cookie' -}
    -> m T.Text
    {- ^ __Returns:__ the header -}
cookieToSetCookieHeader cookie = liftIO $ do
    cookie' <- unsafeManagedPtrGetPtr cookie
    result <- soup_cookie_to_set_cookie_header cookie'
    checkUnexpectedReturnNULL "cookieToSetCookieHeader" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr cookie
    return result'

#if ENABLE_OVERLOADING
data CookieToSetCookieHeaderMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo CookieToSetCookieHeaderMethodInfo Cookie signature where
    overloadedMethod _ = cookieToSetCookieHeader

#endif

-- method Cookie::parse
-- method type : MemberFunction
-- Args : [Arg {argCName = "header", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a cookie string (eg, the value of a Set-Cookie header)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "origin of the cookie, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Soup", name = "Cookie"}))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookie_parse" soup_cookie_parse :: 
    CString ->                              -- header : TBasicType TUTF8
    Ptr Soup.URI.URI ->                     -- origin : TInterface (Name {namespace = "Soup", name = "URI"})
    IO (Ptr Cookie)

{- |
Parses /@header@/ and returns a 'GI.Soup.Structs.Cookie.Cookie'. (If /@header@/ contains
multiple cookies, only the first one will be parsed.)

If /@header@/ does not have \"path\" or \"domain\" attributes, they will
be defaulted from /@origin@/. If /@origin@/ is 'Nothing', path will default
to \"\/\", but domain will be left as 'Nothing'. Note that this is not a
valid state for a 'GI.Soup.Structs.Cookie.Cookie', and you will need to fill in some
appropriate string for the domain if you want to actually make use
of the cookie.

/Since: 2.24/
-}
cookieParse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@header@/: a cookie string (eg, the value of a Set-Cookie header) -}
    -> Soup.URI.URI
    {- ^ /@origin@/: origin of the cookie, or 'Nothing' -}
    -> m (Maybe Cookie)
    {- ^ __Returns:__ a new 'GI.Soup.Structs.Cookie.Cookie', or 'Nothing' if it could
not be parsed, or contained an illegal \"domain\" attribute for a
cookie originating from /@origin@/. -}
cookieParse header origin = liftIO $ do
    header' <- textToCString header
    origin' <- unsafeManagedPtrGetPtr origin
    result <- soup_cookie_parse header' origin'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Cookie) result'
        return result''
    touchManagedPtr origin
    freeMem header'
    return maybeResult

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type family ResolveCookieMethod (t :: Symbol) (o :: *) :: * where
    ResolveCookieMethod "appliesToUri" o = CookieAppliesToUriMethodInfo
    ResolveCookieMethod "copy" o = CookieCopyMethodInfo
    ResolveCookieMethod "domainMatches" o = CookieDomainMatchesMethodInfo
    ResolveCookieMethod "equal" o = CookieEqualMethodInfo
    ResolveCookieMethod "free" o = CookieFreeMethodInfo
    ResolveCookieMethod "toCookieHeader" o = CookieToCookieHeaderMethodInfo
    ResolveCookieMethod "toSetCookieHeader" o = CookieToSetCookieHeaderMethodInfo
    ResolveCookieMethod "getDomain" o = CookieGetDomainMethodInfo
    ResolveCookieMethod "getExpires" o = CookieGetExpiresMethodInfo
    ResolveCookieMethod "getHttpOnly" o = CookieGetHttpOnlyMethodInfo
    ResolveCookieMethod "getName" o = CookieGetNameMethodInfo
    ResolveCookieMethod "getPath" o = CookieGetPathMethodInfo
    ResolveCookieMethod "getSecure" o = CookieGetSecureMethodInfo
    ResolveCookieMethod "getValue" o = CookieGetValueMethodInfo
    ResolveCookieMethod "setDomain" o = CookieSetDomainMethodInfo
    ResolveCookieMethod "setExpires" o = CookieSetExpiresMethodInfo
    ResolveCookieMethod "setHttpOnly" o = CookieSetHttpOnlyMethodInfo
    ResolveCookieMethod "setMaxAge" o = CookieSetMaxAgeMethodInfo
    ResolveCookieMethod "setName" o = CookieSetNameMethodInfo
    ResolveCookieMethod "setPath" o = CookieSetPathMethodInfo
    ResolveCookieMethod "setSecure" o = CookieSetSecureMethodInfo
    ResolveCookieMethod "setValue" o = CookieSetValueMethodInfo
    ResolveCookieMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCookieMethod t Cookie, O.MethodInfo info Cookie p) => OL.IsLabel t (Cookie -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif