{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- PopplerCertificateInfo contains detailed info about a signing certificate.
-- 
-- /Since: 23.07.0/

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

module GI.Poppler.Structs.CertificateInfo
    ( 

-- * Exported types
    CertificateInfo(..)                     ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Poppler.Structs.CertificateInfo#g:method:copy"), [free]("GI.Poppler.Structs.CertificateInfo#g:method:free").
-- 
-- ==== Getters
-- [getExpirationTime]("GI.Poppler.Structs.CertificateInfo#g:method:getExpirationTime"), [getId]("GI.Poppler.Structs.CertificateInfo#g:method:getId"), [getIssuanceTime]("GI.Poppler.Structs.CertificateInfo#g:method:getIssuanceTime"), [getIssuerCommonName]("GI.Poppler.Structs.CertificateInfo#g:method:getIssuerCommonName"), [getIssuerEmail]("GI.Poppler.Structs.CertificateInfo#g:method:getIssuerEmail"), [getIssuerOrganization]("GI.Poppler.Structs.CertificateInfo#g:method:getIssuerOrganization"), [getSubjectCommonName]("GI.Poppler.Structs.CertificateInfo#g:method:getSubjectCommonName"), [getSubjectEmail]("GI.Poppler.Structs.CertificateInfo#g:method:getSubjectEmail"), [getSubjectOrganization]("GI.Poppler.Structs.CertificateInfo#g:method:getSubjectOrganization").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveCertificateInfoMethod            ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoCopyMethodInfo           ,
#endif
    certificateInfoCopy                     ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoFreeMethodInfo           ,
#endif
    certificateInfoFree                     ,


-- ** getExpirationTime #method:getExpirationTime#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetExpirationTimeMethodInfo,
#endif
    certificateInfoGetExpirationTime        ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetIdMethodInfo          ,
#endif
    certificateInfoGetId                    ,


-- ** getIssuanceTime #method:getIssuanceTime#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetIssuanceTimeMethodInfo,
#endif
    certificateInfoGetIssuanceTime          ,


-- ** getIssuerCommonName #method:getIssuerCommonName#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetIssuerCommonNameMethodInfo,
#endif
    certificateInfoGetIssuerCommonName      ,


-- ** getIssuerEmail #method:getIssuerEmail#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetIssuerEmailMethodInfo ,
#endif
    certificateInfoGetIssuerEmail           ,


-- ** getIssuerOrganization #method:getIssuerOrganization#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetIssuerOrganizationMethodInfo,
#endif
    certificateInfoGetIssuerOrganization    ,


-- ** getSubjectCommonName #method:getSubjectCommonName#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetSubjectCommonNameMethodInfo,
#endif
    certificateInfoGetSubjectCommonName     ,


-- ** getSubjectEmail #method:getSubjectEmail#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetSubjectEmailMethodInfo,
#endif
    certificateInfoGetSubjectEmail          ,


-- ** getSubjectOrganization #method:getSubjectOrganization#

#if defined(ENABLE_OVERLOADING)
    CertificateInfoGetSubjectOrganizationMethodInfo,
#endif
    certificateInfoGetSubjectOrganization   ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Structs.DateTime as GLib.DateTime

#else
import qualified GI.GLib.Structs.DateTime as GLib.DateTime

#endif

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

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

foreign import ccall "poppler_certificate_info_get_type" c_poppler_certificate_info_get_type :: 
    IO GType

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

instance B.Types.TypedObject CertificateInfo where
    glibType :: IO GType
glibType = IO GType
c_poppler_certificate_info_get_type

instance B.Types.GBoxed CertificateInfo

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


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

-- XXX Could not generate method CertificateInfo::new
-- Bad introspection data: Could not resolve the symbol “poppler_certificate_info_new” in the “Poppler” namespace, ignoring.
-- method CertificateInfo::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "CertificateInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_copy" poppler_certificate_info_copy :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO (Ptr CertificateInfo)

-- | Copies /@certificateInfo@/, creating an identical t'GI.Poppler.Structs.CertificateInfo.CertificateInfo'.
-- 
-- /Since: 23.07.0/
certificateInfoCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m CertificateInfo
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure identical to /@certificateInfo@/
certificateInfoCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m CertificateInfo
certificateInfoCopy CertificateInfo
certificateInfo = IO CertificateInfo -> m CertificateInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CertificateInfo -> m CertificateInfo)
-> IO CertificateInfo -> m CertificateInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    Ptr CertificateInfo
result <- Ptr CertificateInfo -> IO (Ptr CertificateInfo)
poppler_certificate_info_copy Ptr CertificateInfo
certificateInfo'
    Text -> Ptr CertificateInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoCopy" Ptr CertificateInfo
result
    CertificateInfo
result' <- ((ManagedPtr CertificateInfo -> CertificateInfo)
-> Ptr CertificateInfo -> IO CertificateInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr CertificateInfo -> CertificateInfo
CertificateInfo) Ptr CertificateInfo
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    CertificateInfo -> IO CertificateInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CertificateInfo
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoCopyMethodInfo
instance (signature ~ (m CertificateInfo), MonadIO m) => O.OverloadedMethod CertificateInfoCopyMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoCopy

instance O.OverloadedMethodInfo CertificateInfoCopyMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoCopy"
        })


#endif

-- method CertificateInfo::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_free" poppler_certificate_info_free :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO ()

-- | Frees /@certificateInfo@/
-- 
-- /Since: 23.07.0/
certificateInfoFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m ()
certificateInfoFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m ()
certificateInfoFree CertificateInfo
certificateInfo = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    Ptr CertificateInfo -> IO ()
poppler_certificate_info_free Ptr CertificateInfo
certificateInfo'
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CertificateInfoFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod CertificateInfoFreeMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoFree

instance O.OverloadedMethodInfo CertificateInfoFreeMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoFree"
        })


#endif

-- method CertificateInfo::get_expiration_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_expiration_time" poppler_certificate_info_get_expiration_time :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO (Ptr GLib.DateTime.DateTime)

-- | Get certificate expiration time
-- 
-- /Since: 23.08.0/
certificateInfoGetExpirationTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m GLib.DateTime.DateTime
    -- ^ __Returns:__ certificate expiration time
certificateInfoGetExpirationTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m DateTime
certificateInfoGetExpirationTime CertificateInfo
certificateInfo = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
    Ptr CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    Ptr DateTime
result <- Ptr CertificateInfo -> IO (Ptr DateTime)
poppler_certificate_info_get_expiration_time Ptr CertificateInfo
certificateInfo'
    Text -> Ptr DateTime -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetExpirationTime" Ptr DateTime
result
    DateTime
result' <- ((ManagedPtr DateTime -> DateTime) -> Ptr DateTime -> IO DateTime
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DateTime -> DateTime
GLib.DateTime.DateTime) Ptr DateTime
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    DateTime -> IO DateTime
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DateTime
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetExpirationTimeMethodInfo
instance (signature ~ (m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod CertificateInfoGetExpirationTimeMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetExpirationTime

instance O.OverloadedMethodInfo CertificateInfoGetExpirationTimeMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetExpirationTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetExpirationTime"
        })


#endif

-- method CertificateInfo::get_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_id" poppler_certificate_info_get_id :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate nick name
-- 
-- /Since: 23.07.0/
certificateInfoGetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate nick name
certificateInfoGetId :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetId CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_id Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetId" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetIdMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetId

instance O.OverloadedMethodInfo CertificateInfoGetIdMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetId"
        })


#endif

-- method CertificateInfo::get_issuance_time
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_issuance_time" poppler_certificate_info_get_issuance_time :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO (Ptr GLib.DateTime.DateTime)

-- | Get certificate issuance time
-- 
-- /Since: 23.08.0/
certificateInfoGetIssuanceTime ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m GLib.DateTime.DateTime
    -- ^ __Returns:__ certificate issuance time
certificateInfoGetIssuanceTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m DateTime
certificateInfoGetIssuanceTime CertificateInfo
certificateInfo = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
    Ptr CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    Ptr DateTime
result <- Ptr CertificateInfo -> IO (Ptr DateTime)
poppler_certificate_info_get_issuance_time Ptr CertificateInfo
certificateInfo'
    Text -> Ptr DateTime -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetIssuanceTime" Ptr DateTime
result
    DateTime
result' <- ((ManagedPtr DateTime -> DateTime) -> Ptr DateTime -> IO DateTime
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DateTime -> DateTime
GLib.DateTime.DateTime) Ptr DateTime
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    DateTime -> IO DateTime
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DateTime
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetIssuanceTimeMethodInfo
instance (signature ~ (m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod CertificateInfoGetIssuanceTimeMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetIssuanceTime

instance O.OverloadedMethodInfo CertificateInfoGetIssuanceTimeMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetIssuanceTime",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetIssuanceTime"
        })


#endif

-- method CertificateInfo::get_issuer_common_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_issuer_common_name" poppler_certificate_info_get_issuer_common_name :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate issuer common name
-- 
-- /Since: 23.08.0/
certificateInfoGetIssuerCommonName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate issuer common name
certificateInfoGetIssuerCommonName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetIssuerCommonName CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_issuer_common_name Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetIssuerCommonName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetIssuerCommonNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetIssuerCommonNameMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetIssuerCommonName

instance O.OverloadedMethodInfo CertificateInfoGetIssuerCommonNameMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetIssuerCommonName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetIssuerCommonName"
        })


#endif

-- method CertificateInfo::get_issuer_email
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_issuer_email" poppler_certificate_info_get_issuer_email :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate issuer email
-- 
-- /Since: 23.08.0/
certificateInfoGetIssuerEmail ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate issuer email
certificateInfoGetIssuerEmail :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetIssuerEmail CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_issuer_email Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetIssuerEmail" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetIssuerEmailMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetIssuerEmailMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetIssuerEmail

instance O.OverloadedMethodInfo CertificateInfoGetIssuerEmailMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetIssuerEmail",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetIssuerEmail"
        })


#endif

-- method CertificateInfo::get_issuer_organization
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_issuer_organization" poppler_certificate_info_get_issuer_organization :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate issuer organization
-- 
-- /Since: 23.08.0/
certificateInfoGetIssuerOrganization ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate issuer organization
certificateInfoGetIssuerOrganization :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetIssuerOrganization CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_issuer_organization Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetIssuerOrganization" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetIssuerOrganizationMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetIssuerOrganizationMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetIssuerOrganization

instance O.OverloadedMethodInfo CertificateInfoGetIssuerOrganizationMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetIssuerOrganization",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetIssuerOrganization"
        })


#endif

-- method CertificateInfo::get_subject_common_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_subject_common_name" poppler_certificate_info_get_subject_common_name :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate subject common name
-- 
-- /Since: 23.07.0/
certificateInfoGetSubjectCommonName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate subject common name
certificateInfoGetSubjectCommonName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetSubjectCommonName CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_subject_common_name Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetSubjectCommonName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetSubjectCommonNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetSubjectCommonNameMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetSubjectCommonName

instance O.OverloadedMethodInfo CertificateInfoGetSubjectCommonNameMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetSubjectCommonName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetSubjectCommonName"
        })


#endif

-- method CertificateInfo::get_subject_email
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_subject_email" poppler_certificate_info_get_subject_email :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate subject email
-- 
-- /Since: 23.08.0/
certificateInfoGetSubjectEmail ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate subject email
certificateInfoGetSubjectEmail :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetSubjectEmail CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_subject_email Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetSubjectEmail" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetSubjectEmailMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetSubjectEmailMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetSubjectEmail

instance O.OverloadedMethodInfo CertificateInfoGetSubjectEmailMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetSubjectEmail",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetSubjectEmail"
        })


#endif

-- method CertificateInfo::get_subject_organization
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "certificate_info"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "CertificateInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #PopplerCertificateInfo structure containing certificate information"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_certificate_info_get_subject_organization" poppler_certificate_info_get_subject_organization :: 
    Ptr CertificateInfo ->                  -- certificate_info : TInterface (Name {namespace = "Poppler", name = "CertificateInfo"})
    IO CString

-- | Get certificate subject organization
-- 
-- /Since: 23.08.0/
certificateInfoGetSubjectOrganization ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    CertificateInfo
    -- ^ /@certificateInfo@/: a t'GI.Poppler.Structs.CertificateInfo.CertificateInfo' structure containing certificate information
    -> m T.Text
    -- ^ __Returns:__ certificate subject organization
certificateInfoGetSubjectOrganization :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
CertificateInfo -> m Text
certificateInfoGetSubjectOrganization CertificateInfo
certificateInfo = IO Text -> m Text
forall a. IO a -> m a
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 CertificateInfo
certificateInfo' <- CertificateInfo -> IO (Ptr CertificateInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr CertificateInfo
certificateInfo
    CString
result <- Ptr CertificateInfo -> IO CString
poppler_certificate_info_get_subject_organization Ptr CertificateInfo
certificateInfo'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"certificateInfoGetSubjectOrganization" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CertificateInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr CertificateInfo
certificateInfo
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CertificateInfoGetSubjectOrganizationMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod CertificateInfoGetSubjectOrganizationMethodInfo CertificateInfo signature where
    overloadedMethod = certificateInfoGetSubjectOrganization

instance O.OverloadedMethodInfo CertificateInfoGetSubjectOrganizationMethodInfo CertificateInfo where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.CertificateInfo.certificateInfoGetSubjectOrganization",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-CertificateInfo.html#v:certificateInfoGetSubjectOrganization"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCertificateInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveCertificateInfoMethod "copy" o = CertificateInfoCopyMethodInfo
    ResolveCertificateInfoMethod "free" o = CertificateInfoFreeMethodInfo
    ResolveCertificateInfoMethod "getExpirationTime" o = CertificateInfoGetExpirationTimeMethodInfo
    ResolveCertificateInfoMethod "getId" o = CertificateInfoGetIdMethodInfo
    ResolveCertificateInfoMethod "getIssuanceTime" o = CertificateInfoGetIssuanceTimeMethodInfo
    ResolveCertificateInfoMethod "getIssuerCommonName" o = CertificateInfoGetIssuerCommonNameMethodInfo
    ResolveCertificateInfoMethod "getIssuerEmail" o = CertificateInfoGetIssuerEmailMethodInfo
    ResolveCertificateInfoMethod "getIssuerOrganization" o = CertificateInfoGetIssuerOrganizationMethodInfo
    ResolveCertificateInfoMethod "getSubjectCommonName" o = CertificateInfoGetSubjectCommonNameMethodInfo
    ResolveCertificateInfoMethod "getSubjectEmail" o = CertificateInfoGetSubjectEmailMethodInfo
    ResolveCertificateInfoMethod "getSubjectOrganization" o = CertificateInfoGetSubjectOrganizationMethodInfo
    ResolveCertificateInfoMethod l o = O.MethodResolutionFailed l o

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

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

#endif

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

#endif