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

module GI.Soup.Objects.Server
    ( 

-- * Exported types
    Server(..)                              ,
    ServerK                                 ,
    toServer                                ,
    noServer                                ,


 -- * Methods
-- ** serverAcceptIostream
    serverAcceptIostream                    ,


-- ** serverAddAuthDomain
    serverAddAuthDomain                     ,


-- ** serverAddEarlyHandler
    serverAddEarlyHandler                   ,


-- ** serverAddHandler
    serverAddHandler                        ,


-- ** serverAddWebsocketHandler
    serverAddWebsocketHandler               ,


-- ** serverDisconnect
    serverDisconnect                        ,


-- ** serverGetAsyncContext
    serverGetAsyncContext                   ,


-- ** serverGetListener
    serverGetListener                       ,


-- ** serverGetListeners
    serverGetListeners                      ,


-- ** serverGetPort
    serverGetPort                           ,


-- ** serverGetUris
    serverGetUris                           ,


-- ** serverIsHttps
    serverIsHttps                           ,


-- ** serverListen
    serverListen                            ,


-- ** serverListenAll
    serverListenAll                         ,


-- ** serverListenFd
    serverListenFd                          ,


-- ** serverListenLocal
    serverListenLocal                       ,


-- ** serverListenSocket
    serverListenSocket                      ,


-- ** serverPauseMessage
    serverPauseMessage                      ,


-- ** serverQuit
    serverQuit                              ,


-- ** serverRemoveAuthDomain
    serverRemoveAuthDomain                  ,


-- ** serverRemoveHandler
    serverRemoveHandler                     ,


-- ** serverRun
    serverRun                               ,


-- ** serverRunAsync
    serverRunAsync                          ,


-- ** serverSetSslCertFile
    serverSetSslCertFile                    ,


-- ** serverUnpauseMessage
    serverUnpauseMessage                    ,




 -- * Properties
-- ** AsyncContext
    ServerAsyncContextPropertyInfo          ,
    constructServerAsyncContext             ,
    getServerAsyncContext                   ,


-- ** HttpAliases
    ServerHttpAliasesPropertyInfo           ,
    constructServerHttpAliases              ,
    getServerHttpAliases                    ,
    setServerHttpAliases                    ,


-- ** HttpsAliases
    ServerHttpsAliasesPropertyInfo          ,
    constructServerHttpsAliases             ,
    getServerHttpsAliases                   ,
    setServerHttpsAliases                   ,


-- ** Interface
    ServerInterfacePropertyInfo             ,
    constructServerInterface                ,
    getServerInterface                      ,


-- ** Port
    ServerPortPropertyInfo                  ,
    constructServerPort                     ,
    getServerPort                           ,


-- ** RawPaths
    ServerRawPathsPropertyInfo              ,
    constructServerRawPaths                 ,
    getServerRawPaths                       ,


-- ** ServerHeader
    ServerServerHeaderPropertyInfo          ,
    constructServerServerHeader             ,
    getServerServerHeader                   ,
    setServerServerHeader                   ,


-- ** SslCertFile
    ServerSslCertFilePropertyInfo           ,
    constructServerSslCertFile              ,
    getServerSslCertFile                    ,


-- ** SslKeyFile
    ServerSslKeyFilePropertyInfo            ,
    constructServerSslKeyFile               ,
    getServerSslKeyFile                     ,


-- ** TlsCertificate
    ServerTlsCertificatePropertyInfo        ,
    constructServerTlsCertificate           ,
    getServerTlsCertificate                 ,




 -- * Signals
-- ** RequestAborted
    ServerRequestAbortedCallback            ,
    ServerRequestAbortedCallbackC           ,
    ServerRequestAbortedSignalInfo          ,
    afterServerRequestAborted               ,
    mkServerRequestAbortedCallback          ,
    noServerRequestAbortedCallback          ,
    onServerRequestAborted                  ,
    serverRequestAbortedCallbackWrapper     ,
    serverRequestAbortedClosure             ,


-- ** RequestFinished
    ServerRequestFinishedCallback           ,
    ServerRequestFinishedCallbackC          ,
    ServerRequestFinishedSignalInfo         ,
    afterServerRequestFinished              ,
    mkServerRequestFinishedCallback         ,
    noServerRequestFinishedCallback         ,
    onServerRequestFinished                 ,
    serverRequestFinishedCallbackWrapper    ,
    serverRequestFinishedClosure            ,


-- ** RequestRead
    ServerRequestReadCallback               ,
    ServerRequestReadCallbackC              ,
    ServerRequestReadSignalInfo             ,
    afterServerRequestRead                  ,
    mkServerRequestReadCallback             ,
    noServerRequestReadCallback             ,
    onServerRequestRead                     ,
    serverRequestReadCallbackWrapper        ,
    serverRequestReadClosure                ,


-- ** RequestStarted
    ServerRequestStartedCallback            ,
    ServerRequestStartedCallbackC           ,
    ServerRequestStartedSignalInfo          ,
    afterServerRequestStarted               ,
    mkServerRequestStartedCallback          ,
    noServerRequestStartedCallback          ,
    onServerRequestStarted                  ,
    serverRequestStartedCallbackWrapper     ,
    serverRequestStartedClosure             ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.Soup.Types
import GI.Soup.Callbacks
import qualified GI.GLib as GLib
import qualified GI.GObject as GObject
import qualified GI.Gio as Gio

newtype Server = Server (ForeignPtr Server)
foreign import ccall "soup_server_get_type"
    c_soup_server_get_type :: IO GType

type instance ParentTypes Server = ServerParentTypes
type ServerParentTypes = '[GObject.Object]

instance GObject Server where
    gobjectIsInitiallyUnowned _ = False
    gobjectType _ = c_soup_server_get_type
    

class GObject o => ServerK o
instance (GObject o, IsDescendantOf Server o) => ServerK o

toServer :: ServerK o => o -> IO Server
toServer = unsafeCastTo Server

noServer :: Maybe Server
noServer = Nothing

-- signal Server::request-aborted
type ServerRequestAbortedCallback =
    Message ->
    ClientContext ->
    IO ()

noServerRequestAbortedCallback :: Maybe ServerRequestAbortedCallback
noServerRequestAbortedCallback = Nothing

type ServerRequestAbortedCallbackC =
    Ptr () ->                               -- object
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkServerRequestAbortedCallback :: ServerRequestAbortedCallbackC -> IO (FunPtr ServerRequestAbortedCallbackC)

serverRequestAbortedClosure :: ServerRequestAbortedCallback -> IO Closure
serverRequestAbortedClosure cb = newCClosure =<< mkServerRequestAbortedCallback wrapped
    where wrapped = serverRequestAbortedCallbackWrapper cb

serverRequestAbortedCallbackWrapper ::
    ServerRequestAbortedCallback ->
    Ptr () ->
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->
    IO ()
serverRequestAbortedCallbackWrapper _cb _ message client _ = do
    message' <- (newObject Message) message
    client' <- (newBoxed ClientContext) client
    _cb  message' client'

onServerRequestAborted :: (GObject a, MonadIO m) => a -> ServerRequestAbortedCallback -> m SignalHandlerId
onServerRequestAborted obj cb = liftIO $ connectServerRequestAborted obj cb SignalConnectBefore
afterServerRequestAborted :: (GObject a, MonadIO m) => a -> ServerRequestAbortedCallback -> m SignalHandlerId
afterServerRequestAborted obj cb = connectServerRequestAborted obj cb SignalConnectAfter

connectServerRequestAborted :: (GObject a, MonadIO m) =>
                               a -> ServerRequestAbortedCallback -> SignalConnectMode -> m SignalHandlerId
connectServerRequestAborted obj cb after = liftIO $ do
    cb' <- mkServerRequestAbortedCallback (serverRequestAbortedCallbackWrapper cb)
    connectSignalFunPtr obj "request-aborted" cb' after

-- signal Server::request-finished
type ServerRequestFinishedCallback =
    Message ->
    ClientContext ->
    IO ()

noServerRequestFinishedCallback :: Maybe ServerRequestFinishedCallback
noServerRequestFinishedCallback = Nothing

type ServerRequestFinishedCallbackC =
    Ptr () ->                               -- object
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkServerRequestFinishedCallback :: ServerRequestFinishedCallbackC -> IO (FunPtr ServerRequestFinishedCallbackC)

serverRequestFinishedClosure :: ServerRequestFinishedCallback -> IO Closure
serverRequestFinishedClosure cb = newCClosure =<< mkServerRequestFinishedCallback wrapped
    where wrapped = serverRequestFinishedCallbackWrapper cb

serverRequestFinishedCallbackWrapper ::
    ServerRequestFinishedCallback ->
    Ptr () ->
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->
    IO ()
serverRequestFinishedCallbackWrapper _cb _ message client _ = do
    message' <- (newObject Message) message
    client' <- (newBoxed ClientContext) client
    _cb  message' client'

onServerRequestFinished :: (GObject a, MonadIO m) => a -> ServerRequestFinishedCallback -> m SignalHandlerId
onServerRequestFinished obj cb = liftIO $ connectServerRequestFinished obj cb SignalConnectBefore
afterServerRequestFinished :: (GObject a, MonadIO m) => a -> ServerRequestFinishedCallback -> m SignalHandlerId
afterServerRequestFinished obj cb = connectServerRequestFinished obj cb SignalConnectAfter

connectServerRequestFinished :: (GObject a, MonadIO m) =>
                                a -> ServerRequestFinishedCallback -> SignalConnectMode -> m SignalHandlerId
connectServerRequestFinished obj cb after = liftIO $ do
    cb' <- mkServerRequestFinishedCallback (serverRequestFinishedCallbackWrapper cb)
    connectSignalFunPtr obj "request-finished" cb' after

-- signal Server::request-read
type ServerRequestReadCallback =
    Message ->
    ClientContext ->
    IO ()

noServerRequestReadCallback :: Maybe ServerRequestReadCallback
noServerRequestReadCallback = Nothing

type ServerRequestReadCallbackC =
    Ptr () ->                               -- object
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkServerRequestReadCallback :: ServerRequestReadCallbackC -> IO (FunPtr ServerRequestReadCallbackC)

serverRequestReadClosure :: ServerRequestReadCallback -> IO Closure
serverRequestReadClosure cb = newCClosure =<< mkServerRequestReadCallback wrapped
    where wrapped = serverRequestReadCallbackWrapper cb

serverRequestReadCallbackWrapper ::
    ServerRequestReadCallback ->
    Ptr () ->
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->
    IO ()
serverRequestReadCallbackWrapper _cb _ message client _ = do
    message' <- (newObject Message) message
    client' <- (newBoxed ClientContext) client
    _cb  message' client'

onServerRequestRead :: (GObject a, MonadIO m) => a -> ServerRequestReadCallback -> m SignalHandlerId
onServerRequestRead obj cb = liftIO $ connectServerRequestRead obj cb SignalConnectBefore
afterServerRequestRead :: (GObject a, MonadIO m) => a -> ServerRequestReadCallback -> m SignalHandlerId
afterServerRequestRead obj cb = connectServerRequestRead obj cb SignalConnectAfter

connectServerRequestRead :: (GObject a, MonadIO m) =>
                            a -> ServerRequestReadCallback -> SignalConnectMode -> m SignalHandlerId
connectServerRequestRead obj cb after = liftIO $ do
    cb' <- mkServerRequestReadCallback (serverRequestReadCallbackWrapper cb)
    connectSignalFunPtr obj "request-read" cb' after

-- signal Server::request-started
type ServerRequestStartedCallback =
    Message ->
    ClientContext ->
    IO ()

noServerRequestStartedCallback :: Maybe ServerRequestStartedCallback
noServerRequestStartedCallback = Nothing

type ServerRequestStartedCallbackC =
    Ptr () ->                               -- object
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mkServerRequestStartedCallback :: ServerRequestStartedCallbackC -> IO (FunPtr ServerRequestStartedCallbackC)

serverRequestStartedClosure :: ServerRequestStartedCallback -> IO Closure
serverRequestStartedClosure cb = newCClosure =<< mkServerRequestStartedCallback wrapped
    where wrapped = serverRequestStartedCallbackWrapper cb

serverRequestStartedCallbackWrapper ::
    ServerRequestStartedCallback ->
    Ptr () ->
    Ptr Message ->
    Ptr ClientContext ->
    Ptr () ->
    IO ()
serverRequestStartedCallbackWrapper _cb _ message client _ = do
    message' <- (newObject Message) message
    client' <- (newBoxed ClientContext) client
    _cb  message' client'

onServerRequestStarted :: (GObject a, MonadIO m) => a -> ServerRequestStartedCallback -> m SignalHandlerId
onServerRequestStarted obj cb = liftIO $ connectServerRequestStarted obj cb SignalConnectBefore
afterServerRequestStarted :: (GObject a, MonadIO m) => a -> ServerRequestStartedCallback -> m SignalHandlerId
afterServerRequestStarted obj cb = connectServerRequestStarted obj cb SignalConnectAfter

connectServerRequestStarted :: (GObject a, MonadIO m) =>
                               a -> ServerRequestStartedCallback -> SignalConnectMode -> m SignalHandlerId
connectServerRequestStarted obj cb after = liftIO $ do
    cb' <- mkServerRequestStartedCallback (serverRequestStartedCallbackWrapper cb)
    connectSignalFunPtr obj "request-started" cb' after

-- VVV Prop "async-context"
   -- Type: TBasicType TVoid
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerAsyncContext :: (MonadIO m, ServerK o) => o -> m (Ptr ())
getServerAsyncContext obj = liftIO $ getObjectPropertyPtr obj "async-context"

constructServerAsyncContext :: (Ptr ()) -> IO ([Char], GValue)
constructServerAsyncContext val = constructObjectPropertyPtr "async-context" val

data ServerAsyncContextPropertyInfo
instance AttrInfo ServerAsyncContextPropertyInfo where
    type AttrAllowedOps ServerAsyncContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerAsyncContextPropertyInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint ServerAsyncContextPropertyInfo = ServerK
    type AttrGetType ServerAsyncContextPropertyInfo = (Ptr ())
    type AttrLabel ServerAsyncContextPropertyInfo = "Server::async-context"
    attrGet _ = getServerAsyncContext
    attrSet _ = undefined
    attrConstruct _ = constructServerAsyncContext

-- VVV Prop "http-aliases"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]

getServerHttpAliases :: (MonadIO m, ServerK o) => o -> m [T.Text]
getServerHttpAliases obj = liftIO $ getObjectPropertyStringArray obj "http-aliases"

setServerHttpAliases :: (MonadIO m, ServerK o) => o -> [T.Text] -> m ()
setServerHttpAliases obj val = liftIO $ setObjectPropertyStringArray obj "http-aliases" val

constructServerHttpAliases :: [T.Text] -> IO ([Char], GValue)
constructServerHttpAliases val = constructObjectPropertyStringArray "http-aliases" val

data ServerHttpAliasesPropertyInfo
instance AttrInfo ServerHttpAliasesPropertyInfo where
    type AttrAllowedOps ServerHttpAliasesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerHttpAliasesPropertyInfo = (~) [T.Text]
    type AttrBaseTypeConstraint ServerHttpAliasesPropertyInfo = ServerK
    type AttrGetType ServerHttpAliasesPropertyInfo = [T.Text]
    type AttrLabel ServerHttpAliasesPropertyInfo = "Server::http-aliases"
    attrGet _ = getServerHttpAliases
    attrSet _ = setServerHttpAliases
    attrConstruct _ = constructServerHttpAliases

-- VVV Prop "https-aliases"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]

getServerHttpsAliases :: (MonadIO m, ServerK o) => o -> m [T.Text]
getServerHttpsAliases obj = liftIO $ getObjectPropertyStringArray obj "https-aliases"

setServerHttpsAliases :: (MonadIO m, ServerK o) => o -> [T.Text] -> m ()
setServerHttpsAliases obj val = liftIO $ setObjectPropertyStringArray obj "https-aliases" val

constructServerHttpsAliases :: [T.Text] -> IO ([Char], GValue)
constructServerHttpsAliases val = constructObjectPropertyStringArray "https-aliases" val

data ServerHttpsAliasesPropertyInfo
instance AttrInfo ServerHttpsAliasesPropertyInfo where
    type AttrAllowedOps ServerHttpsAliasesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerHttpsAliasesPropertyInfo = (~) [T.Text]
    type AttrBaseTypeConstraint ServerHttpsAliasesPropertyInfo = ServerK
    type AttrGetType ServerHttpsAliasesPropertyInfo = [T.Text]
    type AttrLabel ServerHttpsAliasesPropertyInfo = "Server::https-aliases"
    attrGet _ = getServerHttpsAliases
    attrSet _ = setServerHttpsAliases
    attrConstruct _ = constructServerHttpsAliases

-- VVV Prop "interface"
   -- Type: TInterface "Soup" "Address"
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerInterface :: (MonadIO m, ServerK o) => o -> m Address
getServerInterface obj = liftIO $ getObjectPropertyObject obj "interface" Address

constructServerInterface :: (AddressK a) => a -> IO ([Char], GValue)
constructServerInterface val = constructObjectPropertyObject "interface" val

data ServerInterfacePropertyInfo
instance AttrInfo ServerInterfacePropertyInfo where
    type AttrAllowedOps ServerInterfacePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerInterfacePropertyInfo = AddressK
    type AttrBaseTypeConstraint ServerInterfacePropertyInfo = ServerK
    type AttrGetType ServerInterfacePropertyInfo = Address
    type AttrLabel ServerInterfacePropertyInfo = "Server::interface"
    attrGet _ = getServerInterface
    attrSet _ = undefined
    attrConstruct _ = constructServerInterface

-- VVV Prop "port"
   -- Type: TBasicType TUInt32
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerPort :: (MonadIO m, ServerK o) => o -> m Word32
getServerPort obj = liftIO $ getObjectPropertyCUInt obj "port"

constructServerPort :: Word32 -> IO ([Char], GValue)
constructServerPort val = constructObjectPropertyCUInt "port" val

data ServerPortPropertyInfo
instance AttrInfo ServerPortPropertyInfo where
    type AttrAllowedOps ServerPortPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerPortPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint ServerPortPropertyInfo = ServerK
    type AttrGetType ServerPortPropertyInfo = Word32
    type AttrLabel ServerPortPropertyInfo = "Server::port"
    attrGet _ = getServerPort
    attrSet _ = undefined
    attrConstruct _ = constructServerPort

-- VVV Prop "raw-paths"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerRawPaths :: (MonadIO m, ServerK o) => o -> m Bool
getServerRawPaths obj = liftIO $ getObjectPropertyBool obj "raw-paths"

constructServerRawPaths :: Bool -> IO ([Char], GValue)
constructServerRawPaths val = constructObjectPropertyBool "raw-paths" val

data ServerRawPathsPropertyInfo
instance AttrInfo ServerRawPathsPropertyInfo where
    type AttrAllowedOps ServerRawPathsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerRawPathsPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint ServerRawPathsPropertyInfo = ServerK
    type AttrGetType ServerRawPathsPropertyInfo = Bool
    type AttrLabel ServerRawPathsPropertyInfo = "Server::raw-paths"
    attrGet _ = getServerRawPaths
    attrSet _ = undefined
    attrConstruct _ = constructServerRawPaths

-- VVV Prop "server-header"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]

getServerServerHeader :: (MonadIO m, ServerK o) => o -> m T.Text
getServerServerHeader obj = liftIO $ getObjectPropertyString obj "server-header"

setServerServerHeader :: (MonadIO m, ServerK o) => o -> T.Text -> m ()
setServerServerHeader obj val = liftIO $ setObjectPropertyString obj "server-header" val

constructServerServerHeader :: T.Text -> IO ([Char], GValue)
constructServerServerHeader val = constructObjectPropertyString "server-header" val

data ServerServerHeaderPropertyInfo
instance AttrInfo ServerServerHeaderPropertyInfo where
    type AttrAllowedOps ServerServerHeaderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerServerHeaderPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ServerServerHeaderPropertyInfo = ServerK
    type AttrGetType ServerServerHeaderPropertyInfo = T.Text
    type AttrLabel ServerServerHeaderPropertyInfo = "Server::server-header"
    attrGet _ = getServerServerHeader
    attrSet _ = setServerServerHeader
    attrConstruct _ = constructServerServerHeader

-- VVV Prop "ssl-cert-file"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerSslCertFile :: (MonadIO m, ServerK o) => o -> m T.Text
getServerSslCertFile obj = liftIO $ getObjectPropertyString obj "ssl-cert-file"

constructServerSslCertFile :: T.Text -> IO ([Char], GValue)
constructServerSslCertFile val = constructObjectPropertyString "ssl-cert-file" val

data ServerSslCertFilePropertyInfo
instance AttrInfo ServerSslCertFilePropertyInfo where
    type AttrAllowedOps ServerSslCertFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerSslCertFilePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ServerSslCertFilePropertyInfo = ServerK
    type AttrGetType ServerSslCertFilePropertyInfo = T.Text
    type AttrLabel ServerSslCertFilePropertyInfo = "Server::ssl-cert-file"
    attrGet _ = getServerSslCertFile
    attrSet _ = undefined
    attrConstruct _ = constructServerSslCertFile

-- VVV Prop "ssl-key-file"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerSslKeyFile :: (MonadIO m, ServerK o) => o -> m T.Text
getServerSslKeyFile obj = liftIO $ getObjectPropertyString obj "ssl-key-file"

constructServerSslKeyFile :: T.Text -> IO ([Char], GValue)
constructServerSslKeyFile val = constructObjectPropertyString "ssl-key-file" val

data ServerSslKeyFilePropertyInfo
instance AttrInfo ServerSslKeyFilePropertyInfo where
    type AttrAllowedOps ServerSslKeyFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerSslKeyFilePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint ServerSslKeyFilePropertyInfo = ServerK
    type AttrGetType ServerSslKeyFilePropertyInfo = T.Text
    type AttrLabel ServerSslKeyFilePropertyInfo = "Server::ssl-key-file"
    attrGet _ = getServerSslKeyFile
    attrSet _ = undefined
    attrConstruct _ = constructServerSslKeyFile

-- VVV Prop "tls-certificate"
   -- Type: TInterface "Gio" "TlsCertificate"
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]

getServerTlsCertificate :: (MonadIO m, ServerK o) => o -> m Gio.TlsCertificate
getServerTlsCertificate obj = liftIO $ getObjectPropertyObject obj "tls-certificate" Gio.TlsCertificate

constructServerTlsCertificate :: (Gio.TlsCertificateK a) => a -> IO ([Char], GValue)
constructServerTlsCertificate val = constructObjectPropertyObject "tls-certificate" val

data ServerTlsCertificatePropertyInfo
instance AttrInfo ServerTlsCertificatePropertyInfo where
    type AttrAllowedOps ServerTlsCertificatePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint ServerTlsCertificatePropertyInfo = Gio.TlsCertificateK
    type AttrBaseTypeConstraint ServerTlsCertificatePropertyInfo = ServerK
    type AttrGetType ServerTlsCertificatePropertyInfo = Gio.TlsCertificate
    type AttrLabel ServerTlsCertificatePropertyInfo = "Server::tls-certificate"
    attrGet _ = getServerTlsCertificate
    attrSet _ = undefined
    attrConstruct _ = constructServerTlsCertificate

type instance AttributeList Server = ServerAttributeList
type ServerAttributeList = ('[ '("async-context", ServerAsyncContextPropertyInfo), '("http-aliases", ServerHttpAliasesPropertyInfo), '("https-aliases", ServerHttpsAliasesPropertyInfo), '("interface", ServerInterfacePropertyInfo), '("port", ServerPortPropertyInfo), '("raw-paths", ServerRawPathsPropertyInfo), '("server-header", ServerServerHeaderPropertyInfo), '("ssl-cert-file", ServerSslCertFilePropertyInfo), '("ssl-key-file", ServerSslKeyFilePropertyInfo), '("tls-certificate", ServerTlsCertificatePropertyInfo)] :: [(Symbol, *)])

data ServerRequestAbortedSignalInfo
instance SignalInfo ServerRequestAbortedSignalInfo where
    type HaskellCallbackType ServerRequestAbortedSignalInfo = ServerRequestAbortedCallback
    connectSignal _ = connectServerRequestAborted

data ServerRequestFinishedSignalInfo
instance SignalInfo ServerRequestFinishedSignalInfo where
    type HaskellCallbackType ServerRequestFinishedSignalInfo = ServerRequestFinishedCallback
    connectSignal _ = connectServerRequestFinished

data ServerRequestReadSignalInfo
instance SignalInfo ServerRequestReadSignalInfo where
    type HaskellCallbackType ServerRequestReadSignalInfo = ServerRequestReadCallback
    connectSignal _ = connectServerRequestRead

data ServerRequestStartedSignalInfo
instance SignalInfo ServerRequestStartedSignalInfo where
    type HaskellCallbackType ServerRequestStartedSignalInfo = ServerRequestStartedCallback
    connectSignal _ = connectServerRequestStarted

type instance SignalList Server = ServerSignalList
type ServerSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("request-aborted", ServerRequestAbortedSignalInfo), '("request-finished", ServerRequestFinishedSignalInfo), '("request-read", ServerRequestReadSignalInfo), '("request-started", ServerRequestStartedSignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method Server::accept_iostream
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_addr", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "remote_addr", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "stream", argType = TInterface "Gio" "IOStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "local_addr", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "remote_addr", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_accept_iostream" soup_server_accept_iostream :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr Gio.IOStream ->                     -- stream : TInterface "Gio" "IOStream"
    Ptr Gio.SocketAddress ->                -- local_addr : TInterface "Gio" "SocketAddress"
    Ptr Gio.SocketAddress ->                -- remote_addr : TInterface "Gio" "SocketAddress"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverAcceptIostream ::
    (MonadIO m, ServerK a, Gio.IOStreamK b, Gio.SocketAddressK c, Gio.SocketAddressK d) =>
    a ->                                    -- _obj
    b ->                                    -- stream
    Maybe (c) ->                            -- local_addr
    Maybe (d) ->                            -- remote_addr
    m ()
serverAcceptIostream _obj stream local_addr remote_addr = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let stream' = unsafeManagedPtrCastPtr stream
    maybeLocal_addr <- case local_addr of
        Nothing -> return nullPtr
        Just jLocal_addr -> do
            let jLocal_addr' = unsafeManagedPtrCastPtr jLocal_addr
            return jLocal_addr'
    maybeRemote_addr <- case remote_addr of
        Nothing -> return nullPtr
        Just jRemote_addr -> do
            let jRemote_addr' = unsafeManagedPtrCastPtr jRemote_addr
            return jRemote_addr'
    onException (do
        _ <- propagateGError $ soup_server_accept_iostream _obj' stream' maybeLocal_addr maybeRemote_addr
        touchManagedPtr _obj
        touchManagedPtr stream
        whenJust local_addr touchManagedPtr
        whenJust remote_addr touchManagedPtr
        return ()
     ) (do
        return ()
     )

-- method Server::add_auth_domain
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auth_domain", argType = TInterface "Soup" "AuthDomain", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auth_domain", argType = TInterface "Soup" "AuthDomain", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_add_auth_domain" soup_server_add_auth_domain :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr AuthDomain ->                       -- auth_domain : TInterface "Soup" "AuthDomain"
    IO ()


serverAddAuthDomain ::
    (MonadIO m, ServerK a, AuthDomainK b) =>
    a ->                                    -- _obj
    b ->                                    -- auth_domain
    m ()
serverAddAuthDomain _obj auth_domain = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let auth_domain' = unsafeManagedPtrCastPtr auth_domain
    soup_server_add_auth_domain _obj' auth_domain'
    touchManagedPtr _obj
    touchManagedPtr auth_domain
    return ()

-- method Server::add_early_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_add_early_handler" soup_server_add_early_handler :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    CString ->                              -- path : TBasicType TUTF8
    FunPtr ServerCallbackC ->               -- callback : TInterface "Soup" "ServerCallback"
    Ptr () ->                               -- user_data : TBasicType TVoid
    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"
    IO ()


serverAddEarlyHandler ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Maybe (T.Text) ->                       -- path
    ServerCallback ->                       -- callback
    m ()
serverAddEarlyHandler _obj path callback = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- textToCString jPath
            return jPath'
    callback' <- mkServerCallback (serverCallbackWrapper Nothing callback)
    let user_data = castFunPtrToPtr callback'
    let destroy = safeFreeFunPtrPtr
    soup_server_add_early_handler _obj' maybePath callback' user_data destroy
    touchManagedPtr _obj
    freeMem maybePath
    return ()

-- method Server::add_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_add_handler" soup_server_add_handler :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    CString ->                              -- path : TBasicType TUTF8
    FunPtr ServerCallbackC ->               -- callback : TInterface "Soup" "ServerCallback"
    Ptr () ->                               -- user_data : TBasicType TVoid
    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"
    IO ()


serverAddHandler ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Maybe (T.Text) ->                       -- path
    ServerCallback ->                       -- callback
    m ()
serverAddHandler _obj path callback = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- textToCString jPath
            return jPath'
    callback' <- mkServerCallback (serverCallbackWrapper Nothing callback)
    let user_data = castFunPtrToPtr callback'
    let destroy = safeFreeFunPtrPtr
    soup_server_add_handler _obj' maybePath callback' user_data destroy
    touchManagedPtr _obj
    freeMem maybePath
    return ()

-- method Server::add_websocket_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocols", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerWebsocketCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "protocols", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "callback", argType = TInterface "Soup" "ServerWebsocketCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 5, argDestroy = 6, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_add_websocket_handler" soup_server_add_websocket_handler :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    CString ->                              -- path : TBasicType TUTF8
    CString ->                              -- origin : TBasicType TUTF8
    Ptr CString ->                          -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
    FunPtr ServerWebsocketCallbackC ->      -- callback : TInterface "Soup" "ServerWebsocketCallback"
    Ptr () ->                               -- user_data : TBasicType TVoid
    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"
    IO ()


serverAddWebsocketHandler ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Maybe (T.Text) ->                       -- path
    Maybe (T.Text) ->                       -- origin
    Maybe ([T.Text]) ->                     -- protocols
    ServerWebsocketCallback ->              -- callback
    m ()
serverAddWebsocketHandler _obj path origin protocols callback = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    maybePath <- case path of
        Nothing -> return nullPtr
        Just jPath -> do
            jPath' <- textToCString jPath
            return jPath'
    maybeOrigin <- case origin of
        Nothing -> return nullPtr
        Just jOrigin -> do
            jOrigin' <- textToCString jOrigin
            return jOrigin'
    maybeProtocols <- case protocols of
        Nothing -> return nullPtr
        Just jProtocols -> do
            jProtocols' <- packZeroTerminatedUTF8CArray jProtocols
            return jProtocols'
    callback' <- mkServerWebsocketCallback (serverWebsocketCallbackWrapper Nothing callback)
    let user_data = castFunPtrToPtr callback'
    let destroy = safeFreeFunPtrPtr
    soup_server_add_websocket_handler _obj' maybePath maybeOrigin maybeProtocols callback' user_data destroy
    touchManagedPtr _obj
    freeMem maybePath
    freeMem maybeOrigin
    mapZeroTerminatedCArray freeMem maybeProtocols
    freeMem maybeProtocols
    return ()

-- method Server::disconnect
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_disconnect" soup_server_disconnect :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO ()


serverDisconnect ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m ()
serverDisconnect _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    soup_server_disconnect _obj'
    touchManagedPtr _obj
    return ()

-- method Server::get_async_context
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "GLib" "MainContext"
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_get_async_context" soup_server_get_async_context :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO (Ptr GLib.MainContext)

{-# DEPRECATED serverGetAsyncContext ["If you are using soup_server_listen(), etc, then","the server listens on the thread-default #GMainContext, and this","property is ignored."]#-}
serverGetAsyncContext ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m GLib.MainContext
serverGetAsyncContext _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_get_async_context _obj'
    checkUnexpectedReturnNULL "soup_server_get_async_context" result
    result' <- (newBoxed GLib.MainContext) result
    touchManagedPtr _obj
    return result'

-- method Server::get_listener
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TInterface "Soup" "Socket"
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_get_listener" soup_server_get_listener :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO (Ptr Socket)

{-# DEPRECATED serverGetListener ["If you are using soup_server_listen(), etc, then use","soup_server_get_listeners() to get a list of all listening sockets,","but note that that function returns #GSockets, not #SoupSockets."]#-}
serverGetListener ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m Socket
serverGetListener _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_get_listener _obj'
    checkUnexpectedReturnNULL "soup_server_get_listener" result
    result' <- (newObject Socket) result
    touchManagedPtr _obj
    return result'

-- method Server::get_listeners
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TGSList (TInterface "Gio" "Socket")
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_get_listeners" soup_server_get_listeners :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO (Ptr (GSList (Ptr Gio.Socket)))


serverGetListeners ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m [Gio.Socket]
serverGetListeners _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_get_listeners _obj'
    checkUnexpectedReturnNULL "soup_server_get_listeners" result
    result' <- unpackGSList result
    result'' <- mapM (newObject Gio.Socket) result'
    g_slist_free result
    touchManagedPtr _obj
    return result''

-- method Server::get_port
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TUInt32
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_get_port" soup_server_get_port :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO Word32

{-# DEPRECATED serverGetPort ["If you are using soup_server_listen(), etc, then use","soup_server_get_uris() to get a list of all listening addresses."]#-}
serverGetPort ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m Word32
serverGetPort _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_get_port _obj'
    touchManagedPtr _obj
    return result

-- method Server::get_uris
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TGSList (TInterface "Soup" "URI")
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_get_uris" soup_server_get_uris :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO (Ptr (GSList (Ptr URI)))


serverGetUris ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m [URI]
serverGetUris _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_get_uris _obj'
    checkUnexpectedReturnNULL "soup_server_get_uris" result
    result' <- unpackGSList result
    result'' <- mapM (wrapBoxed URI) result'
    g_slist_free result
    touchManagedPtr _obj
    return result''

-- method Server::is_https
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_is_https" soup_server_is_https :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO CInt


serverIsHttps ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m Bool
serverIsHttps _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    result <- soup_server_is_https _obj'
    let result' = (/= 0) result
    touchManagedPtr _obj
    return result'

-- method Server::listen
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "address", argType = TInterface "Gio" "SocketAddress", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_listen" soup_server_listen :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr Gio.SocketAddress ->                -- address : TInterface "Gio" "SocketAddress"
    CUInt ->                                -- options : TInterface "Soup" "ServerListenOptions"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverListen ::
    (MonadIO m, ServerK a, Gio.SocketAddressK b) =>
    a ->                                    -- _obj
    b ->                                    -- address
    [ServerListenOptions] ->                -- options
    m ()
serverListen _obj address options = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let address' = unsafeManagedPtrCastPtr address
    let options' = gflagsToWord options
    onException (do
        _ <- propagateGError $ soup_server_listen _obj' address' options'
        touchManagedPtr _obj
        touchManagedPtr address
        return ()
     ) (do
        return ()
     )

-- method Server::listen_all
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_listen_all" soup_server_listen_all :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Word32 ->                               -- port : TBasicType TUInt32
    CUInt ->                                -- options : TInterface "Soup" "ServerListenOptions"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverListenAll ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Word32 ->                               -- port
    [ServerListenOptions] ->                -- options
    m ()
serverListenAll _obj port options = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let options' = gflagsToWord options
    onException (do
        _ <- propagateGError $ soup_server_listen_all _obj' port options'
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- method Server::listen_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "fd", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_listen_fd" soup_server_listen_fd :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Int32 ->                                -- fd : TBasicType TInt32
    CUInt ->                                -- options : TInterface "Soup" "ServerListenOptions"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverListenFd ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Int32 ->                                -- fd
    [ServerListenOptions] ->                -- options
    m ()
serverListenFd _obj fd options = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let options' = gflagsToWord options
    onException (do
        _ <- propagateGError $ soup_server_listen_fd _obj' fd options'
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- method Server::listen_local
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_listen_local" soup_server_listen_local :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Word32 ->                               -- port : TBasicType TUInt32
    CUInt ->                                -- options : TInterface "Soup" "ServerListenOptions"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverListenLocal ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    Word32 ->                               -- port
    [ServerListenOptions] ->                -- options
    m ()
serverListenLocal _obj port options = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let options' = gflagsToWord options
    onException (do
        _ <- propagateGError $ soup_server_listen_local _obj' port options'
        touchManagedPtr _obj
        return ()
     ) (do
        return ()
     )

-- method Server::listen_socket
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "socket", argType = TInterface "Gio" "Socket", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Soup" "ServerListenOptions", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_listen_socket" soup_server_listen_socket :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr Gio.Socket ->                       -- socket : TInterface "Gio" "Socket"
    CUInt ->                                -- options : TInterface "Soup" "ServerListenOptions"
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverListenSocket ::
    (MonadIO m, ServerK a, Gio.SocketK b) =>
    a ->                                    -- _obj
    b ->                                    -- socket
    [ServerListenOptions] ->                -- options
    m ()
serverListenSocket _obj socket options = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let socket' = unsafeManagedPtrCastPtr socket
    let options' = gflagsToWord options
    onException (do
        _ <- propagateGError $ soup_server_listen_socket _obj' socket' options'
        touchManagedPtr _obj
        touchManagedPtr socket
        return ()
     ) (do
        return ()
     )

-- method Server::pause_message
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "msg", argType = TInterface "Soup" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "msg", argType = TInterface "Soup" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_pause_message" soup_server_pause_message :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr Message ->                          -- msg : TInterface "Soup" "Message"
    IO ()


serverPauseMessage ::
    (MonadIO m, ServerK a, MessageK b) =>
    a ->                                    -- _obj
    b ->                                    -- msg
    m ()
serverPauseMessage _obj msg = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let msg' = unsafeManagedPtrCastPtr msg
    soup_server_pause_message _obj' msg'
    touchManagedPtr _obj
    touchManagedPtr msg
    return ()

-- method Server::quit
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_quit" soup_server_quit :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO ()

{-# DEPRECATED serverQuit ["When using soup_server_listen(), etc, the server will","always listen for connections, and will process them whenever the","thread-default #GMainContext is running."]#-}
serverQuit ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m ()
serverQuit _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    soup_server_quit _obj'
    touchManagedPtr _obj
    return ()

-- method Server::remove_auth_domain
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auth_domain", argType = TInterface "Soup" "AuthDomain", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "auth_domain", argType = TInterface "Soup" "AuthDomain", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_remove_auth_domain" soup_server_remove_auth_domain :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr AuthDomain ->                       -- auth_domain : TInterface "Soup" "AuthDomain"
    IO ()


serverRemoveAuthDomain ::
    (MonadIO m, ServerK a, AuthDomainK b) =>
    a ->                                    -- _obj
    b ->                                    -- auth_domain
    m ()
serverRemoveAuthDomain _obj auth_domain = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let auth_domain' = unsafeManagedPtrCastPtr auth_domain
    soup_server_remove_auth_domain _obj' auth_domain'
    touchManagedPtr _obj
    touchManagedPtr auth_domain
    return ()

-- method Server::remove_handler
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_remove_handler" soup_server_remove_handler :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    CString ->                              -- path : TBasicType TUTF8
    IO ()


serverRemoveHandler ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- path
    m ()
serverRemoveHandler _obj path = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    path' <- textToCString path
    soup_server_remove_handler _obj' path'
    touchManagedPtr _obj
    freeMem path'
    return ()

-- method Server::run
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_run" soup_server_run :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO ()

{-# DEPRECATED serverRun ["When using soup_server_listen(), etc, the server will","always listen for connections, and will process them whenever the","thread-default #GMainContext is running."]#-}
serverRun ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m ()
serverRun _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    soup_server_run _obj'
    touchManagedPtr _obj
    return ()

-- method Server::run_async
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_run_async" soup_server_run_async :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    IO ()

{-# DEPRECATED serverRunAsync ["When using soup_server_listen(), etc, the server will","always listen for connections, and will process them whenever the","thread-default #GMainContext is running."]#-}
serverRunAsync ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    m ()
serverRunAsync _obj = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    soup_server_run_async _obj'
    touchManagedPtr _obj
    return ()

-- method Server::set_ssl_cert_file
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ssl_cert_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ssl_key_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ssl_cert_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ssl_key_file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TBoolean
-- throws : True
-- Skip return : False

foreign import ccall "soup_server_set_ssl_cert_file" soup_server_set_ssl_cert_file :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    CString ->                              -- ssl_cert_file : TBasicType TUTF8
    CString ->                              -- ssl_key_file : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt


serverSetSslCertFile ::
    (MonadIO m, ServerK a) =>
    a ->                                    -- _obj
    T.Text ->                               -- ssl_cert_file
    T.Text ->                               -- ssl_key_file
    m ()
serverSetSslCertFile _obj ssl_cert_file ssl_key_file = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    ssl_cert_file' <- textToCString ssl_cert_file
    ssl_key_file' <- textToCString ssl_key_file
    onException (do
        _ <- propagateGError $ soup_server_set_ssl_cert_file _obj' ssl_cert_file' ssl_key_file'
        touchManagedPtr _obj
        freeMem ssl_cert_file'
        freeMem ssl_key_file'
        return ()
     ) (do
        freeMem ssl_cert_file'
        freeMem ssl_key_file'
     )

-- method Server::unpause_message
-- method type : OrdinaryMethod
-- Args : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "msg", argType = TInterface "Soup" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- Lengths : []
-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Soup" "Server", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "msg", argType = TInterface "Soup" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]
-- returnType : TBasicType TVoid
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_unpause_message" soup_server_unpause_message :: 
    Ptr Server ->                           -- _obj : TInterface "Soup" "Server"
    Ptr Message ->                          -- msg : TInterface "Soup" "Message"
    IO ()


serverUnpauseMessage ::
    (MonadIO m, ServerK a, MessageK b) =>
    a ->                                    -- _obj
    b ->                                    -- msg
    m ()
serverUnpauseMessage _obj msg = liftIO $ do
    let _obj' = unsafeManagedPtrCastPtr _obj
    let msg' = unsafeManagedPtrCastPtr msg
    soup_server_unpause_message _obj' msg'
    touchManagedPtr _obj
    touchManagedPtr msg
    return ()