{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An HTTP Strict Transport Security policy.
-- 
-- /@domain@/ represents the host that this policy applies to. The domain
-- must be IDNA-canonicalized. 'GI.Soup.Structs.HSTSPolicy.hSTSPolicyNew' and related methods
-- will do this for you.
-- 
-- /@maxAge@/ contains the \'max-age\' value from the Strict Transport
-- Security header and indicates the time to live of this policy,
-- in seconds.
-- 
-- /@expires@/ will be non-'P.Nothing' if the policy has been set by the host and
-- hence has an expiry time. If /@expires@/ is 'P.Nothing', it indicates that the
-- policy is a permanent session policy set by the user agent.
-- 
-- If /@includeSubdomains@/ is 'P.True', the Strict Transport Security policy
-- must also be enforced on subdomains of /@domain@/.
-- 
-- /Since: 2.68/

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

module GI.Soup.Structs.HSTSPolicy
    ( 

-- * Exported types
    HSTSPolicy(..)                          ,
    newZeroHSTSPolicy                       ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveHSTSPolicyMethod                 ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyCopyMethodInfo                ,
#endif
    hSTSPolicyCopy                          ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyEqualMethodInfo               ,
#endif
    hSTSPolicyEqual                         ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyFreeMethodInfo                ,
#endif
    hSTSPolicyFree                          ,


-- ** getDomain #method:getDomain#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyGetDomainMethodInfo           ,
#endif
    hSTSPolicyGetDomain                     ,


-- ** includesSubdomains #method:includesSubdomains#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyIncludesSubdomainsMethodInfo  ,
#endif
    hSTSPolicyIncludesSubdomains            ,


-- ** isExpired #method:isExpired#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyIsExpiredMethodInfo           ,
#endif
    hSTSPolicyIsExpired                     ,


-- ** isSessionPolicy #method:isSessionPolicy#

#if defined(ENABLE_OVERLOADING)
    HSTSPolicyIsSessionPolicyMethodInfo     ,
#endif
    hSTSPolicyIsSessionPolicy               ,


-- ** new #method:new#

    hSTSPolicyNew                           ,


-- ** newFromResponse #method:newFromResponse#

    hSTSPolicyNewFromResponse               ,


-- ** newFull #method:newFull#

    hSTSPolicyNewFull                       ,


-- ** newSessionPolicy #method:newSessionPolicy#

    hSTSPolicyNewSessionPolicy              ,




 -- * Properties
-- ** domain #attr:domain#
-- | The domain or hostname that the policy applies to

    clearHSTSPolicyDomain                   ,
    getHSTSPolicyDomain                     ,
#if defined(ENABLE_OVERLOADING)
    hSTSPolicy_domain                       ,
#endif
    setHSTSPolicyDomain                     ,


-- ** expires #attr:expires#
-- | the policy expiration time, or 'P.Nothing' for a permanent session policy

    clearHSTSPolicyExpires                  ,
    getHSTSPolicyExpires                    ,
#if defined(ENABLE_OVERLOADING)
    hSTSPolicy_expires                      ,
#endif
    setHSTSPolicyExpires                    ,


-- ** includeSubdomains #attr:includeSubdomains#
-- | 'P.True' if the policy applies on subdomains

    getHSTSPolicyIncludeSubdomains          ,
#if defined(ENABLE_OVERLOADING)
    hSTSPolicy_includeSubdomains            ,
#endif
    setHSTSPolicyIncludeSubdomains          ,


-- ** maxAge #attr:maxAge#
-- | The maximum age, in seconds, that the policy is valid

    getHSTSPolicyMaxAge                     ,
#if defined(ENABLE_OVERLOADING)
    hSTSPolicy_maxAge                       ,
#endif
    setHSTSPolicyMaxAge                     ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Structs.Date as Soup.Date

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

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

foreign import ccall "soup_hsts_policy_get_type" c_soup_hsts_policy_get_type :: 
    IO GType

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

instance B.Types.TypedObject HSTSPolicy where
    glibType :: IO GType
glibType = IO GType
c_soup_hsts_policy_get_type

instance B.Types.GBoxed HSTSPolicy

-- | Convert 'HSTSPolicy' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue HSTSPolicy where
    toGValue :: HSTSPolicy -> IO GValue
toGValue HSTSPolicy
o = do
        GType
gtype <- IO GType
c_soup_hsts_policy_get_type
        HSTSPolicy -> (Ptr HSTSPolicy -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr HSTSPolicy
o (GType
-> (GValue -> Ptr HSTSPolicy -> IO ())
-> Ptr HSTSPolicy
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr HSTSPolicy -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO HSTSPolicy
fromGValue GValue
gv = do
        Ptr HSTSPolicy
ptr <- GValue -> IO (Ptr HSTSPolicy)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr HSTSPolicy)
        (ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy Ptr HSTSPolicy
ptr
        
    

-- | Construct a `HSTSPolicy` struct initialized to zero.
newZeroHSTSPolicy :: MonadIO m => m HSTSPolicy
newZeroHSTSPolicy :: m HSTSPolicy
newZeroHSTSPolicy = IO HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSPolicy -> m HSTSPolicy) -> IO HSTSPolicy -> m HSTSPolicy
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr HSTSPolicy)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
32 IO (Ptr HSTSPolicy)
-> (Ptr HSTSPolicy -> IO HSTSPolicy) -> IO HSTSPolicy
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy

instance tag ~ 'AttrSet => Constructible HSTSPolicy tag where
    new :: (ManagedPtr HSTSPolicy -> HSTSPolicy)
-> [AttrOp HSTSPolicy tag] -> m HSTSPolicy
new ManagedPtr HSTSPolicy -> HSTSPolicy
_ [AttrOp HSTSPolicy tag]
attrs = do
        HSTSPolicy
o <- m HSTSPolicy
forall (m :: * -> *). MonadIO m => m HSTSPolicy
newZeroHSTSPolicy
        HSTSPolicy -> [AttrOp HSTSPolicy 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set HSTSPolicy
o [AttrOp HSTSPolicy tag]
[AttrOp HSTSPolicy 'AttrSet]
attrs
        HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
o


-- | 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' hSTSPolicy #domain
-- @
getHSTSPolicyDomain :: MonadIO m => HSTSPolicy -> m (Maybe T.Text)
getHSTSPolicyDomain :: HSTSPolicy -> m (Maybe Text)
getHSTSPolicyDomain HSTSPolicy
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ HSTSPolicy
-> (Ptr HSTSPolicy -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr HSTSPolicy -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
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' hSTSPolicy [ #domain 'Data.GI.Base.Attributes.:=' value ]
-- @
setHSTSPolicyDomain :: MonadIO m => HSTSPolicy -> CString -> m ()
setHSTSPolicyDomain :: HSTSPolicy -> CString -> m ()
setHSTSPolicyDomain HSTSPolicy
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
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
-- @
clearHSTSPolicyDomain :: MonadIO m => HSTSPolicy -> m ()
clearHSTSPolicyDomain :: HSTSPolicy -> m ()
clearHSTSPolicyDomain HSTSPolicy
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyDomainFieldInfo
instance AttrInfo HSTSPolicyDomainFieldInfo where
    type AttrBaseTypeConstraint HSTSPolicyDomainFieldInfo = (~) HSTSPolicy
    type AttrAllowedOps HSTSPolicyDomainFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint HSTSPolicyDomainFieldInfo = (~) CString
    type AttrTransferTypeConstraint HSTSPolicyDomainFieldInfo = (~)CString
    type AttrTransferType HSTSPolicyDomainFieldInfo = CString
    type AttrGetType HSTSPolicyDomainFieldInfo = Maybe T.Text
    type AttrLabel HSTSPolicyDomainFieldInfo = "domain"
    type AttrOrigin HSTSPolicyDomainFieldInfo = HSTSPolicy
    attrGet = getHSTSPolicyDomain
    attrSet = setHSTSPolicyDomain
    attrConstruct = undefined
    attrClear = clearHSTSPolicyDomain
    attrTransfer _ v = do
        return v

hSTSPolicy_domain :: AttrLabelProxy "domain"
hSTSPolicy_domain = AttrLabelProxy

#endif


-- | Get the value of the “@max_age@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' hSTSPolicy #maxAge
-- @
getHSTSPolicyMaxAge :: MonadIO m => HSTSPolicy -> m CULong
getHSTSPolicyMaxAge :: HSTSPolicy -> m CULong
getHSTSPolicyMaxAge HSTSPolicy
s = IO CULong -> m CULong
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CULong -> m CULong) -> IO CULong -> m CULong
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO CULong) -> IO CULong
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO CULong) -> IO CULong)
-> (Ptr HSTSPolicy -> IO CULong) -> IO CULong
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    CULong
val <- Ptr CULong -> IO CULong
forall a. Storable a => Ptr a -> IO a
peek (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CULong
    CULong -> IO CULong
forall (m :: * -> *) a. Monad m => a -> m a
return CULong
val

-- | Set the value of the “@max_age@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' hSTSPolicy [ #maxAge 'Data.GI.Base.Attributes.:=' value ]
-- @
setHSTSPolicyMaxAge :: MonadIO m => HSTSPolicy -> CULong -> m ()
setHSTSPolicyMaxAge :: HSTSPolicy -> CULong -> m ()
setHSTSPolicyMaxAge HSTSPolicy
s CULong
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr CULong -> CULong -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CULong
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CULong
val :: CULong)

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyMaxAgeFieldInfo
instance AttrInfo HSTSPolicyMaxAgeFieldInfo where
    type AttrBaseTypeConstraint HSTSPolicyMaxAgeFieldInfo = (~) HSTSPolicy
    type AttrAllowedOps HSTSPolicyMaxAgeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint HSTSPolicyMaxAgeFieldInfo = (~) CULong
    type AttrTransferTypeConstraint HSTSPolicyMaxAgeFieldInfo = (~)CULong
    type AttrTransferType HSTSPolicyMaxAgeFieldInfo = CULong
    type AttrGetType HSTSPolicyMaxAgeFieldInfo = CULong
    type AttrLabel HSTSPolicyMaxAgeFieldInfo = "max_age"
    type AttrOrigin HSTSPolicyMaxAgeFieldInfo = HSTSPolicy
    attrGet = getHSTSPolicyMaxAge
    attrSet = setHSTSPolicyMaxAge
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

hSTSPolicy_maxAge :: AttrLabelProxy "maxAge"
hSTSPolicy_maxAge = 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' hSTSPolicy #expires
-- @
getHSTSPolicyExpires :: MonadIO m => HSTSPolicy -> m (Maybe Soup.Date.Date)
getHSTSPolicyExpires :: HSTSPolicy -> m (Maybe Date)
getHSTSPolicyExpires HSTSPolicy
s = IO (Maybe Date) -> m (Maybe Date)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Date) -> m (Maybe Date))
-> IO (Maybe Date) -> m (Maybe Date)
forall a b. (a -> b) -> a -> b
$ HSTSPolicy
-> (Ptr HSTSPolicy -> IO (Maybe Date)) -> IO (Maybe Date)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO (Maybe Date)) -> IO (Maybe Date))
-> (Ptr HSTSPolicy -> IO (Maybe Date)) -> IO (Maybe Date)
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr Date
val <- Ptr (Ptr Date) -> IO (Ptr Date)
forall a. Storable a => Ptr a -> IO a
peek (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr (Ptr Date)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Soup.Date.Date)
    Maybe Date
result <- Ptr Date -> (Ptr Date -> IO Date) -> IO (Maybe Date)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Date
val ((Ptr Date -> IO Date) -> IO (Maybe Date))
-> (Ptr Date -> IO Date) -> IO (Maybe Date)
forall a b. (a -> b) -> a -> b
$ \Ptr Date
val' -> do
        Date
val'' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Date -> Date
Soup.Date.Date) Ptr Date
val'
        Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
val''
    Maybe Date -> IO (Maybe Date)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Date
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' hSTSPolicy [ #expires 'Data.GI.Base.Attributes.:=' value ]
-- @
setHSTSPolicyExpires :: MonadIO m => HSTSPolicy -> Ptr Soup.Date.Date -> m ()
setHSTSPolicyExpires :: HSTSPolicy -> Ptr Date -> m ()
setHSTSPolicyExpires HSTSPolicy
s Ptr Date
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr (Ptr Date) -> Ptr Date -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr (Ptr Date)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Date
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
-- @
clearHSTSPolicyExpires :: MonadIO m => HSTSPolicy -> m ()
clearHSTSPolicyExpires :: HSTSPolicy -> m ()
clearHSTSPolicyExpires HSTSPolicy
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    Ptr (Ptr Date) -> Ptr Date -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr (Ptr Date)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Date
forall a. Ptr a
FP.nullPtr :: Ptr Soup.Date.Date)

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyExpiresFieldInfo
instance AttrInfo HSTSPolicyExpiresFieldInfo where
    type AttrBaseTypeConstraint HSTSPolicyExpiresFieldInfo = (~) HSTSPolicy
    type AttrAllowedOps HSTSPolicyExpiresFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint HSTSPolicyExpiresFieldInfo = (~) (Ptr Soup.Date.Date)
    type AttrTransferTypeConstraint HSTSPolicyExpiresFieldInfo = (~)(Ptr Soup.Date.Date)
    type AttrTransferType HSTSPolicyExpiresFieldInfo = (Ptr Soup.Date.Date)
    type AttrGetType HSTSPolicyExpiresFieldInfo = Maybe Soup.Date.Date
    type AttrLabel HSTSPolicyExpiresFieldInfo = "expires"
    type AttrOrigin HSTSPolicyExpiresFieldInfo = HSTSPolicy
    attrGet = getHSTSPolicyExpires
    attrSet = setHSTSPolicyExpires
    attrConstruct = undefined
    attrClear = clearHSTSPolicyExpires
    attrTransfer _ v = do
        return v

hSTSPolicy_expires :: AttrLabelProxy "expires"
hSTSPolicy_expires = AttrLabelProxy

#endif


-- | Get the value of the “@include_subdomains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' hSTSPolicy #includeSubdomains
-- @
getHSTSPolicyIncludeSubdomains :: MonadIO m => HSTSPolicy -> m Bool
getHSTSPolicyIncludeSubdomains :: HSTSPolicy -> m Bool
getHSTSPolicyIncludeSubdomains HSTSPolicy
s = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO Bool) -> IO Bool)
-> (Ptr HSTSPolicy -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@include_subdomains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' hSTSPolicy [ #includeSubdomains 'Data.GI.Base.Attributes.:=' value ]
-- @
setHSTSPolicyIncludeSubdomains :: MonadIO m => HSTSPolicy -> Bool -> m ()
setHSTSPolicyIncludeSubdomains :: HSTSPolicy -> Bool -> m ()
setHSTSPolicyIncludeSubdomains HSTSPolicy
s Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ HSTSPolicy -> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr HSTSPolicy
s ((Ptr HSTSPolicy -> IO ()) -> IO ())
-> (Ptr HSTSPolicy -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr HSTSPolicy
ptr Ptr HSTSPolicy -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyIncludeSubdomainsFieldInfo
instance AttrInfo HSTSPolicyIncludeSubdomainsFieldInfo where
    type AttrBaseTypeConstraint HSTSPolicyIncludeSubdomainsFieldInfo = (~) HSTSPolicy
    type AttrAllowedOps HSTSPolicyIncludeSubdomainsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint HSTSPolicyIncludeSubdomainsFieldInfo = (~) Bool
    type AttrTransferTypeConstraint HSTSPolicyIncludeSubdomainsFieldInfo = (~)Bool
    type AttrTransferType HSTSPolicyIncludeSubdomainsFieldInfo = Bool
    type AttrGetType HSTSPolicyIncludeSubdomainsFieldInfo = Bool
    type AttrLabel HSTSPolicyIncludeSubdomainsFieldInfo = "include_subdomains"
    type AttrOrigin HSTSPolicyIncludeSubdomainsFieldInfo = HSTSPolicy
    attrGet = getHSTSPolicyIncludeSubdomains
    attrSet = setHSTSPolicyIncludeSubdomains
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

hSTSPolicy_includeSubdomains :: AttrLabelProxy "includeSubdomains"
hSTSPolicy_includeSubdomains = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList HSTSPolicy
type instance O.AttributeList HSTSPolicy = HSTSPolicyAttributeList
type HSTSPolicyAttributeList = ('[ '("domain", HSTSPolicyDomainFieldInfo), '("maxAge", HSTSPolicyMaxAgeFieldInfo), '("expires", HSTSPolicyExpiresFieldInfo), '("includeSubdomains", HSTSPolicyIncludeSubdomainsFieldInfo)] :: [(Symbol, *)])
#endif

-- method HSTSPolicy::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "domain"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "policy domain or hostname"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_age"
--           , argType = TBasicType TULong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "max age of the policy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "include_subdomains"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the policy applies on subdomains"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "HSTSPolicy" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_hsts_policy_new" soup_hsts_policy_new :: 
    CString ->                              -- domain : TBasicType TUTF8
    CULong ->                               -- max_age : TBasicType TULong
    CInt ->                                 -- include_subdomains : TBasicType TBoolean
    IO (Ptr HSTSPolicy)

-- | Creates a new t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy' with the given attributes.
-- 
-- /@domain@/ is a domain on which the strict transport security policy
-- represented by this object must be enforced.
-- 
-- /@maxAge@/ is used to set the \"expires\" attribute on the policy; pass
-- SOUP_HSTS_POLICY_MAX_AGE_PAST for an already-expired policy, or a
-- lifetime in seconds.
-- 
-- If /@includeSubdomains@/ is 'P.True', the strict transport security policy
-- must also be enforced on all subdomains of /@domain@/.
-- 
-- /Since: 2.68/
hSTSPolicyNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@domain@/: policy domain or hostname
    -> CULong
    -- ^ /@maxAge@/: max age of the policy
    -> Bool
    -- ^ /@includeSubdomains@/: 'P.True' if the policy applies on subdomains
    -> m HSTSPolicy
    -- ^ __Returns:__ a new t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'.
hSTSPolicyNew :: Text -> CULong -> Bool -> m HSTSPolicy
hSTSPolicyNew Text
domain CULong
maxAge Bool
includeSubdomains = IO HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSPolicy -> m HSTSPolicy) -> IO HSTSPolicy -> m HSTSPolicy
forall a b. (a -> b) -> a -> b
$ do
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    let includeSubdomains' :: CInt
includeSubdomains' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
includeSubdomains
    Ptr HSTSPolicy
result <- CString -> CULong -> CInt -> IO (Ptr HSTSPolicy)
soup_hsts_policy_new CString
domain' CULong
maxAge CInt
includeSubdomains'
    Text -> Ptr HSTSPolicy -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSPolicyNew" Ptr HSTSPolicy
result
    HSTSPolicy
result' <- ((ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy) Ptr HSTSPolicy
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
domain'
    HSTSPolicy -> IO HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "soup_hsts_policy_new_from_response" soup_hsts_policy_new_from_response :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr HSTSPolicy)

-- | Parses /@msg@/\'s first \"Strict-Transport-Security\" response header and
-- returns a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'.
-- 
-- /Since: 2.68/
hSTSPolicyNewFromResponse ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m (Maybe HSTSPolicy)
    -- ^ __Returns:__ a new t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy', or 'P.Nothing' if no valid
    -- \"Strict-Transport-Security\" response header was found.
hSTSPolicyNewFromResponse :: a -> m (Maybe HSTSPolicy)
hSTSPolicyNewFromResponse a
msg = IO (Maybe HSTSPolicy) -> m (Maybe HSTSPolicy)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe HSTSPolicy) -> m (Maybe HSTSPolicy))
-> IO (Maybe HSTSPolicy) -> m (Maybe HSTSPolicy)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr HSTSPolicy
result <- Ptr Message -> IO (Ptr HSTSPolicy)
soup_hsts_policy_new_from_response Ptr Message
msg'
    Maybe HSTSPolicy
maybeResult <- Ptr HSTSPolicy
-> (Ptr HSTSPolicy -> IO HSTSPolicy) -> IO (Maybe HSTSPolicy)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr HSTSPolicy
result ((Ptr HSTSPolicy -> IO HSTSPolicy) -> IO (Maybe HSTSPolicy))
-> (Ptr HSTSPolicy -> IO HSTSPolicy) -> IO (Maybe HSTSPolicy)
forall a b. (a -> b) -> a -> b
$ \Ptr HSTSPolicy
result' -> do
        HSTSPolicy
result'' <- ((ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy) Ptr HSTSPolicy
result'
        HSTSPolicy -> IO HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe HSTSPolicy -> IO (Maybe HSTSPolicy)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe HSTSPolicy
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method HSTSPolicy::new_full
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "domain"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "policy domain or hostname"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max_age"
--           , argType = TBasicType TULong
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "max age of the policy"
--                 , 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 date of expiration of the policy or %NULL for a permanent policy"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "include_subdomains"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the policy applies on subdomains"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "HSTSPolicy" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_hsts_policy_new_full" soup_hsts_policy_new_full :: 
    CString ->                              -- domain : TBasicType TUTF8
    CULong ->                               -- max_age : TBasicType TULong
    Ptr Soup.Date.Date ->                   -- expires : TInterface (Name {namespace = "Soup", name = "Date"})
    CInt ->                                 -- include_subdomains : TBasicType TBoolean
    IO (Ptr HSTSPolicy)

-- | Full version of @/soup_hsts_policy_new/@(), to use with an existing
-- expiration date. See @/soup_hsts_policy_new/@() for details.
-- 
-- /Since: 2.68/
hSTSPolicyNewFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@domain@/: policy domain or hostname
    -> CULong
    -- ^ /@maxAge@/: max age of the policy
    -> Soup.Date.Date
    -- ^ /@expires@/: the date of expiration of the policy or 'P.Nothing' for a permanent policy
    -> Bool
    -- ^ /@includeSubdomains@/: 'P.True' if the policy applies on subdomains
    -> m HSTSPolicy
    -- ^ __Returns:__ a new t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'.
hSTSPolicyNewFull :: Text -> CULong -> Date -> Bool -> m HSTSPolicy
hSTSPolicyNewFull Text
domain CULong
maxAge Date
expires Bool
includeSubdomains = IO HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSPolicy -> m HSTSPolicy) -> IO HSTSPolicy -> m HSTSPolicy
forall a b. (a -> b) -> a -> b
$ do
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    Ptr Date
expires' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
expires
    let includeSubdomains' :: CInt
includeSubdomains' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
includeSubdomains
    Ptr HSTSPolicy
result <- CString -> CULong -> Ptr Date -> CInt -> IO (Ptr HSTSPolicy)
soup_hsts_policy_new_full CString
domain' CULong
maxAge Ptr Date
expires' CInt
includeSubdomains'
    Text -> Ptr HSTSPolicy -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSPolicyNewFull" Ptr HSTSPolicy
result
    HSTSPolicy
result' <- ((ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy) Ptr HSTSPolicy
result
    Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
expires
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
domain'
    HSTSPolicy -> IO HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method HSTSPolicy::new_session_policy
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "domain"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "policy domain or hostname"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "include_subdomains"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the policy applies on sub domains"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "HSTSPolicy" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_hsts_policy_new_session_policy" soup_hsts_policy_new_session_policy :: 
    CString ->                              -- domain : TBasicType TUTF8
    CInt ->                                 -- include_subdomains : TBasicType TBoolean
    IO (Ptr HSTSPolicy)

-- | Creates a new session t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy' with the given attributes.
-- A session policy is a policy that is valid during the lifetime of
-- the t'GI.Soup.Objects.HSTSEnforcer.HSTSEnforcer' it is added to. Contrary to regular policies,
-- it has no expiration date and is not stored in persistent
-- enforcers. These policies are useful for user-agent to load their
-- own or user-defined rules.
-- 
-- /@domain@/ is a domain on which the strict transport security policy
-- represented by this object must be enforced.
-- 
-- If /@includeSubdomains@/ is 'P.True', the strict transport security policy
-- must also be enforced on all subdomains of /@domain@/.
-- 
-- /Since: 2.68/
hSTSPolicyNewSessionPolicy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@domain@/: policy domain or hostname
    -> Bool
    -- ^ /@includeSubdomains@/: 'P.True' if the policy applies on sub domains
    -> m HSTSPolicy
    -- ^ __Returns:__ a new t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'.
hSTSPolicyNewSessionPolicy :: Text -> Bool -> m HSTSPolicy
hSTSPolicyNewSessionPolicy Text
domain Bool
includeSubdomains = IO HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSPolicy -> m HSTSPolicy) -> IO HSTSPolicy -> m HSTSPolicy
forall a b. (a -> b) -> a -> b
$ do
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    let includeSubdomains' :: CInt
includeSubdomains' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
includeSubdomains
    Ptr HSTSPolicy
result <- CString -> CInt -> IO (Ptr HSTSPolicy)
soup_hsts_policy_new_session_policy CString
domain' CInt
includeSubdomains'
    Text -> Ptr HSTSPolicy -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSPolicyNewSessionPolicy" Ptr HSTSPolicy
result
    HSTSPolicy
result' <- ((ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy) Ptr HSTSPolicy
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
domain'
    HSTSPolicy -> IO HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "soup_hsts_policy_copy" soup_hsts_policy_copy :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO (Ptr HSTSPolicy)

-- | Copies /@policy@/.
-- 
-- /Since: 2.68/
hSTSPolicyCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m HSTSPolicy
    -- ^ __Returns:__ a copy of /@policy@/
hSTSPolicyCopy :: HSTSPolicy -> m HSTSPolicy
hSTSPolicyCopy HSTSPolicy
policy = IO HSTSPolicy -> m HSTSPolicy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HSTSPolicy -> m HSTSPolicy) -> IO HSTSPolicy -> m HSTSPolicy
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy
    Ptr HSTSPolicy
result <- Ptr HSTSPolicy -> IO (Ptr HSTSPolicy)
soup_hsts_policy_copy Ptr HSTSPolicy
policy'
    Text -> Ptr HSTSPolicy -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSPolicyCopy" Ptr HSTSPolicy
result
    HSTSPolicy
result' <- ((ManagedPtr HSTSPolicy -> HSTSPolicy)
-> Ptr HSTSPolicy -> IO HSTSPolicy
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr HSTSPolicy -> HSTSPolicy
HSTSPolicy) Ptr HSTSPolicy
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    HSTSPolicy -> IO HSTSPolicy
forall (m :: * -> *) a. Monad m => a -> m a
return HSTSPolicy
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyCopyMethodInfo
instance (signature ~ (m HSTSPolicy), MonadIO m) => O.MethodInfo HSTSPolicyCopyMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyCopy

#endif

-- method HSTSPolicy::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy1"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "policy2"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , 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_hsts_policy_equal" soup_hsts_policy_equal :: 
    Ptr HSTSPolicy ->                       -- policy1 : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    Ptr HSTSPolicy ->                       -- policy2 : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO CInt

-- | Tests if /@policy1@/ and /@policy2@/ are equal.
-- 
-- /Since: 2.68/
hSTSPolicyEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy1@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> HSTSPolicy
    -- ^ /@policy2@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m Bool
    -- ^ __Returns:__ whether the policies are equal.
hSTSPolicyEqual :: HSTSPolicy -> HSTSPolicy -> m Bool
hSTSPolicyEqual HSTSPolicy
policy1 HSTSPolicy
policy2 = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy1' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy1
    Ptr HSTSPolicy
policy2' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy2
    CInt
result <- Ptr HSTSPolicy -> Ptr HSTSPolicy -> IO CInt
soup_hsts_policy_equal Ptr HSTSPolicy
policy1' Ptr HSTSPolicy
policy2'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy1
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy2
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyEqualMethodInfo
instance (signature ~ (HSTSPolicy -> m Bool), MonadIO m) => O.MethodInfo HSTSPolicyEqualMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyEqual

#endif

-- method HSTSPolicy::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_hsts_policy_free" soup_hsts_policy_free :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO ()

-- | Frees /@policy@/.
-- 
-- /Since: 2.68/
hSTSPolicyFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m ()
hSTSPolicyFree :: HSTSPolicy -> m ()
hSTSPolicyFree HSTSPolicy
policy = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed HSTSPolicy
policy
    Ptr HSTSPolicy -> IO ()
soup_hsts_policy_free Ptr HSTSPolicy
policy'
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo HSTSPolicyFreeMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyFree

#endif

-- method HSTSPolicy::get_domain
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , 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_hsts_policy_get_domain" soup_hsts_policy_get_domain :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO CString

-- | Gets /@policy@/\'s domain.
-- 
-- /Since: 2.68/
hSTSPolicyGetDomain ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m T.Text
    -- ^ __Returns:__ /@policy@/\'s domain.
hSTSPolicyGetDomain :: HSTSPolicy -> m Text
hSTSPolicyGetDomain HSTSPolicy
policy = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy
    CString
result <- Ptr HSTSPolicy -> IO CString
soup_hsts_policy_get_domain Ptr HSTSPolicy
policy'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"hSTSPolicyGetDomain" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyGetDomainMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo HSTSPolicyGetDomainMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyGetDomain

#endif

-- method HSTSPolicy::includes_subdomains
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , 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_hsts_policy_includes_subdomains" soup_hsts_policy_includes_subdomains :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO CInt

-- | Gets whether /@policy@/ include its subdomains.
-- 
-- /Since: 2.68/
hSTSPolicyIncludesSubdomains ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@policy@/ includes subdomains, 'P.False' otherwise.
hSTSPolicyIncludesSubdomains :: HSTSPolicy -> m Bool
hSTSPolicyIncludesSubdomains HSTSPolicy
policy = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy
    CInt
result <- Ptr HSTSPolicy -> IO CInt
soup_hsts_policy_includes_subdomains Ptr HSTSPolicy
policy'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyIncludesSubdomainsMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo HSTSPolicyIncludesSubdomainsMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyIncludesSubdomains

#endif

-- method HSTSPolicy::is_expired
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , 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_hsts_policy_is_expired" soup_hsts_policy_is_expired :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO CInt

-- | Gets whether /@policy@/ is expired. Permanent policies never
-- expire.
-- 
-- /Since: 2.68/
hSTSPolicyIsExpired ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@policy@/ is expired, 'P.False' otherwise.
hSTSPolicyIsExpired :: HSTSPolicy -> m Bool
hSTSPolicyIsExpired HSTSPolicy
policy = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy
    CInt
result <- Ptr HSTSPolicy -> IO CInt
soup_hsts_policy_is_expired Ptr HSTSPolicy
policy'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyIsExpiredMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo HSTSPolicyIsExpiredMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyIsExpired

#endif

-- method HSTSPolicy::is_session_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "policy"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HSTSPolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHSTSPolicy" , 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_hsts_policy_is_session_policy" soup_hsts_policy_is_session_policy :: 
    Ptr HSTSPolicy ->                       -- policy : TInterface (Name {namespace = "Soup", name = "HSTSPolicy"})
    IO CInt

-- | Gets whether /@policy@/ is a non-permanent, non-expirable session policy.
-- see 'GI.Soup.Structs.HSTSPolicy.hSTSPolicyNewSessionPolicy' for details.
-- 
-- /Since: 2.68/
hSTSPolicyIsSessionPolicy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    HSTSPolicy
    -- ^ /@policy@/: a t'GI.Soup.Structs.HSTSPolicy.HSTSPolicy'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@policy@/ is permanent, 'P.False' otherwise
hSTSPolicyIsSessionPolicy :: HSTSPolicy -> m Bool
hSTSPolicyIsSessionPolicy HSTSPolicy
policy = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr HSTSPolicy
policy' <- HSTSPolicy -> IO (Ptr HSTSPolicy)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr HSTSPolicy
policy
    CInt
result <- Ptr HSTSPolicy -> IO CInt
soup_hsts_policy_is_session_policy Ptr HSTSPolicy
policy'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    HSTSPolicy -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr HSTSPolicy
policy
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data HSTSPolicyIsSessionPolicyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo HSTSPolicyIsSessionPolicyMethodInfo HSTSPolicy signature where
    overloadedMethod = hSTSPolicyIsSessionPolicy

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveHSTSPolicyMethod (t :: Symbol) (o :: *) :: * where
    ResolveHSTSPolicyMethod "copy" o = HSTSPolicyCopyMethodInfo
    ResolveHSTSPolicyMethod "equal" o = HSTSPolicyEqualMethodInfo
    ResolveHSTSPolicyMethod "free" o = HSTSPolicyFreeMethodInfo
    ResolveHSTSPolicyMethod "includesSubdomains" o = HSTSPolicyIncludesSubdomainsMethodInfo
    ResolveHSTSPolicyMethod "isExpired" o = HSTSPolicyIsExpiredMethodInfo
    ResolveHSTSPolicyMethod "isSessionPolicy" o = HSTSPolicyIsSessionPolicyMethodInfo
    ResolveHSTSPolicyMethod "getDomain" o = HSTSPolicyGetDomainMethodInfo
    ResolveHSTSPolicyMethod l o = O.MethodResolutionFailed l o

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

#endif