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

    Like 'GI.Gio.Objects.NetworkAddress.NetworkAddress' does with hostnames, 'GI.Gio.Objects.NetworkService.NetworkService'
    provides an easy way to resolve a SRV record, and then attempt to
    connect to one of the hosts that implements that service, handling
    service priority\/weighting, multiple IP addresses, and multiple
    address families.

    See 'GI.Gio.Structs.SrvTarget.SrvTarget' for more information about SRV records, and see
    'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' for an example of using the connectable
    interface.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.NetworkService
        (

    -- * Exported types
        NetworkService(..)                      ,
        IsNetworkService                        ,
        toNetworkService                        ,
        noNetworkService                        ,

     -- * Methods
    -- ** getDomain #method:getDomain#

    #if ENABLE_OVERLOADING
        NetworkServiceGetDomainMethodInfo       ,
    #endif
        networkServiceGetDomain                 ,

    -- ** getProtocol #method:getProtocol#

    #if ENABLE_OVERLOADING
        NetworkServiceGetProtocolMethodInfo     ,
    #endif
        networkServiceGetProtocol               ,

    -- ** getScheme #method:getScheme#

    #if ENABLE_OVERLOADING
        NetworkServiceGetSchemeMethodInfo       ,
    #endif
        networkServiceGetScheme                 ,

    -- ** getService #method:getService#

    #if ENABLE_OVERLOADING
        NetworkServiceGetServiceMethodInfo      ,
    #endif
        networkServiceGetService                ,

    -- ** new #method:new#

        networkServiceNew                       ,

    -- ** setScheme #method:setScheme#

    #if ENABLE_OVERLOADING
        NetworkServiceSetSchemeMethodInfo       ,
    #endif
        networkServiceSetScheme                 ,

     -- * Properties
    -- ** domain #attr:domain#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        NetworkServiceDomainPropertyInfo        ,
    #endif
        constructNetworkServiceDomain           ,
        getNetworkServiceDomain                 ,
    #if ENABLE_OVERLOADING
        networkServiceDomain                    ,
    #endif

    -- ** protocol #attr:protocol#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        NetworkServiceProtocolPropertyInfo      ,
    #endif
        constructNetworkServiceProtocol         ,
        getNetworkServiceProtocol               ,
    #if ENABLE_OVERLOADING
        networkServiceProtocol                  ,
    #endif

    -- ** scheme #attr:scheme#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        NetworkServiceSchemePropertyInfo        ,
    #endif
        constructNetworkServiceScheme           ,
        getNetworkServiceScheme                 ,
    #if ENABLE_OVERLOADING
        networkServiceScheme                    ,
    #endif
        setNetworkServiceScheme                 ,

    -- ** service #attr:service#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        NetworkServiceServicePropertyInfo       ,
    #endif
        constructNetworkServiceService          ,
        getNetworkServiceService                ,
    #if ENABLE_OVERLOADING
        networkServiceService                   ,
    #endif

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable

    -- | Memory-managed wrapper type.
    newtype NetworkService = NetworkService (ManagedPtr NetworkService)
    foreign import ccall "g_network_service_get_type"
        c_g_network_service_get_type :: IO GType

    instance GObject NetworkService where
        gobjectType _ = c_g_network_service_get_type

    -- | Type class for types which can be safely cast to `NetworkService`, for instance with `toNetworkService`.
    class GObject o => IsNetworkService o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError NetworkService a) =>
        IsNetworkService a
    #endif
    instance IsNetworkService NetworkService
    instance GObject.Object.IsObject NetworkService
    instance Gio.SocketConnectable.IsSocketConnectable NetworkService

    -- | Cast to `NetworkService`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toNetworkService :: (MonadIO m, IsNetworkService o) => o -> m NetworkService
    toNetworkService = liftIO . unsafeCastTo NetworkService

    -- | A convenience alias for `Nothing` :: `Maybe` `NetworkService`.
    noNetworkService :: Maybe NetworkService
    noNetworkService = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveNetworkServiceMethod (t :: Symbol) (o :: *) :: * where
        ResolveNetworkServiceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveNetworkServiceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveNetworkServiceMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo
        ResolveNetworkServiceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveNetworkServiceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveNetworkServiceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveNetworkServiceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveNetworkServiceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveNetworkServiceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveNetworkServiceMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo
        ResolveNetworkServiceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveNetworkServiceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveNetworkServiceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveNetworkServiceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveNetworkServiceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveNetworkServiceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveNetworkServiceMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo
        ResolveNetworkServiceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveNetworkServiceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveNetworkServiceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveNetworkServiceMethod "getDomain" o = NetworkServiceGetDomainMethodInfo
        ResolveNetworkServiceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveNetworkServiceMethod "getProtocol" o = NetworkServiceGetProtocolMethodInfo
        ResolveNetworkServiceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveNetworkServiceMethod "getScheme" o = NetworkServiceGetSchemeMethodInfo
        ResolveNetworkServiceMethod "getService" o = NetworkServiceGetServiceMethodInfo
        ResolveNetworkServiceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveNetworkServiceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveNetworkServiceMethod "setScheme" o = NetworkServiceSetSchemeMethodInfo
        ResolveNetworkServiceMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

    -- VVV Prop "domain"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' networkService #domain
    @
    -}
    getNetworkServiceDomain :: (MonadIO m, IsNetworkService o) => o -> m T.Text
    getNetworkServiceDomain obj = liftIO $ checkUnexpectedNothing "getNetworkServiceDomain" $ getObjectPropertyString obj "domain"

    {- |
    Construct a `GValueConstruct` with valid value for the “@domain@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructNetworkServiceDomain :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o)
    constructNetworkServiceDomain val = constructObjectPropertyString "domain" (Just val)

    #if ENABLE_OVERLOADING
    data NetworkServiceDomainPropertyInfo
    instance AttrInfo NetworkServiceDomainPropertyInfo where
        type AttrAllowedOps NetworkServiceDomainPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint NetworkServiceDomainPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint NetworkServiceDomainPropertyInfo = IsNetworkService
        type AttrGetType NetworkServiceDomainPropertyInfo = T.Text
        type AttrLabel NetworkServiceDomainPropertyInfo = "domain"
        type AttrOrigin NetworkServiceDomainPropertyInfo = NetworkService
        attrGet _ = getNetworkServiceDomain
        attrSet _ = undefined
        attrConstruct _ = constructNetworkServiceDomain
        attrClear _ = undefined
    #endif

    -- VVV Prop "protocol"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' networkService #protocol
    @
    -}
    getNetworkServiceProtocol :: (MonadIO m, IsNetworkService o) => o -> m T.Text
    getNetworkServiceProtocol obj = liftIO $ checkUnexpectedNothing "getNetworkServiceProtocol" $ getObjectPropertyString obj "protocol"

    {- |
    Construct a `GValueConstruct` with valid value for the “@protocol@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructNetworkServiceProtocol :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o)
    constructNetworkServiceProtocol val = constructObjectPropertyString "protocol" (Just val)

    #if ENABLE_OVERLOADING
    data NetworkServiceProtocolPropertyInfo
    instance AttrInfo NetworkServiceProtocolPropertyInfo where
        type AttrAllowedOps NetworkServiceProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint NetworkServiceProtocolPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint NetworkServiceProtocolPropertyInfo = IsNetworkService
        type AttrGetType NetworkServiceProtocolPropertyInfo = T.Text
        type AttrLabel NetworkServiceProtocolPropertyInfo = "protocol"
        type AttrOrigin NetworkServiceProtocolPropertyInfo = NetworkService
        attrGet _ = getNetworkServiceProtocol
        attrSet _ = undefined
        attrConstruct _ = constructNetworkServiceProtocol
        attrClear _ = undefined
    #endif

    -- VVV Prop "scheme"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' networkService #scheme
    @
    -}
    getNetworkServiceScheme :: (MonadIO m, IsNetworkService o) => o -> m T.Text
    getNetworkServiceScheme obj = liftIO $ checkUnexpectedNothing "getNetworkServiceScheme" $ getObjectPropertyString obj "scheme"

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

    @
    'Data.GI.Base.Attributes.set' networkService [ #scheme 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setNetworkServiceScheme :: (MonadIO m, IsNetworkService o) => o -> T.Text -> m ()
    setNetworkServiceScheme obj val = liftIO $ setObjectPropertyString obj "scheme" (Just val)

    {- |
    Construct a `GValueConstruct` with valid value for the “@scheme@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructNetworkServiceScheme :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o)
    constructNetworkServiceScheme val = constructObjectPropertyString "scheme" (Just val)

    #if ENABLE_OVERLOADING
    data NetworkServiceSchemePropertyInfo
    instance AttrInfo NetworkServiceSchemePropertyInfo where
        type AttrAllowedOps NetworkServiceSchemePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint NetworkServiceSchemePropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint NetworkServiceSchemePropertyInfo = IsNetworkService
        type AttrGetType NetworkServiceSchemePropertyInfo = T.Text
        type AttrLabel NetworkServiceSchemePropertyInfo = "scheme"
        type AttrOrigin NetworkServiceSchemePropertyInfo = NetworkService
        attrGet _ = getNetworkServiceScheme
        attrSet _ = setNetworkServiceScheme
        attrConstruct _ = constructNetworkServiceScheme
        attrClear _ = undefined
    #endif

    -- VVV Prop "service"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' networkService #service
    @
    -}
    getNetworkServiceService :: (MonadIO m, IsNetworkService o) => o -> m T.Text
    getNetworkServiceService obj = liftIO $ checkUnexpectedNothing "getNetworkServiceService" $ getObjectPropertyString obj "service"

    {- |
    Construct a `GValueConstruct` with valid value for the “@service@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructNetworkServiceService :: (IsNetworkService o) => T.Text -> IO (GValueConstruct o)
    constructNetworkServiceService val = constructObjectPropertyString "service" (Just val)

    #if ENABLE_OVERLOADING
    data NetworkServiceServicePropertyInfo
    instance AttrInfo NetworkServiceServicePropertyInfo where
        type AttrAllowedOps NetworkServiceServicePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint NetworkServiceServicePropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint NetworkServiceServicePropertyInfo = IsNetworkService
        type AttrGetType NetworkServiceServicePropertyInfo = T.Text
        type AttrLabel NetworkServiceServicePropertyInfo = "service"
        type AttrOrigin NetworkServiceServicePropertyInfo = NetworkService
        attrGet _ = getNetworkServiceService
        attrSet _ = undefined
        attrConstruct _ = constructNetworkServiceService
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList NetworkService
    type instance O.AttributeList NetworkService = NetworkServiceAttributeList
    type NetworkServiceAttributeList = ('[ '("domain", NetworkServiceDomainPropertyInfo), '("protocol", NetworkServiceProtocolPropertyInfo), '("scheme", NetworkServiceSchemePropertyInfo), '("service", NetworkServiceServicePropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    networkServiceDomain :: AttrLabelProxy "domain"
    networkServiceDomain = AttrLabelProxy

    networkServiceProtocol :: AttrLabelProxy "protocol"
    networkServiceProtocol = AttrLabelProxy

    networkServiceScheme :: AttrLabelProxy "scheme"
    networkServiceScheme = AttrLabelProxy

    networkServiceService :: AttrLabelProxy "service"
    networkServiceService = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList NetworkService = NetworkServiceSignalList
    type NetworkServiceSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method NetworkService::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the service type to look up (eg, \"ldap\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the networking protocol to use for @service (eg, \"tcp\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS domain to look up the service in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "NetworkService"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_new" g_network_service_new ::
        CString ->                              -- service : TBasicType TUTF8
        CString ->                              -- protocol : TBasicType TUTF8
        CString ->                              -- domain : TBasicType TUTF8
        IO (Ptr NetworkService)

    {- |
    Creates a new 'GI.Gio.Objects.NetworkService.NetworkService' representing the given /@service@/,
    /@protocol@/, and /@domain@/. This will initially be unresolved; use the
    'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' interface to resolve it.

    /Since: 2.22/
    -}
    networkServiceNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        {- ^ /@service@/: the service type to look up (eg, \"ldap\") -}
        -> T.Text
        {- ^ /@protocol@/: the networking protocol to use for /@service@/ (eg, \"tcp\") -}
        -> T.Text
        {- ^ /@domain@/: the DNS domain to look up the service in -}
        -> m NetworkService
        {- ^ __Returns:__ a new 'GI.Gio.Objects.NetworkService.NetworkService' -}
    networkServiceNew service protocol domain = liftIO $ do
        service' <- textToCString service
        protocol' <- textToCString protocol
        domain' <- textToCString domain
        result <- g_network_service_new service' protocol' domain'
        checkUnexpectedReturnNULL "networkServiceNew" result
        result' <- (wrapObject NetworkService) result
        freeMem service'
        freeMem protocol'
        freeMem domain'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method NetworkService::get_domain
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_get_domain" g_network_service_get_domain ::
        Ptr NetworkService ->                   -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"})
        IO CString

    {- |
    Gets the domain that /@srv@/ serves. This might be either UTF-8 or
    ASCII-encoded, depending on what /@srv@/ was created with.

    /Since: 2.22/
    -}
    networkServiceGetDomain ::
        (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) =>
        a
        {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -}
        -> m T.Text
        {- ^ __Returns:__ /@srv@/\'s domain name -}
    networkServiceGetDomain srv = liftIO $ do
        srv' <- unsafeManagedPtrCastPtr srv
        result <- g_network_service_get_domain srv'
        checkUnexpectedReturnNULL "networkServiceGetDomain" result
        result' <- cstringToText result
        touchManagedPtr srv
        return result'

    #if ENABLE_OVERLOADING
    data NetworkServiceGetDomainMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetDomainMethodInfo a signature where
        overloadedMethod _ = networkServiceGetDomain

    #endif

    -- method NetworkService::get_protocol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_get_protocol" g_network_service_get_protocol ::
        Ptr NetworkService ->                   -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"})
        IO CString

    {- |
    Gets /@srv@/\'s protocol name (eg, \"tcp\").

    /Since: 2.22/
    -}
    networkServiceGetProtocol ::
        (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) =>
        a
        {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -}
        -> m T.Text
        {- ^ __Returns:__ /@srv@/\'s protocol name -}
    networkServiceGetProtocol srv = liftIO $ do
        srv' <- unsafeManagedPtrCastPtr srv
        result <- g_network_service_get_protocol srv'
        checkUnexpectedReturnNULL "networkServiceGetProtocol" result
        result' <- cstringToText result
        touchManagedPtr srv
        return result'

    #if ENABLE_OVERLOADING
    data NetworkServiceGetProtocolMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetProtocolMethodInfo a signature where
        overloadedMethod _ = networkServiceGetProtocol

    #endif

    -- method NetworkService::get_scheme
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_get_scheme" g_network_service_get_scheme ::
        Ptr NetworkService ->                   -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"})
        IO CString

    {- |
    Get\'s the URI scheme used to resolve proxies. By default, the service name
    is used as scheme.

    /Since: 2.26/
    -}
    networkServiceGetScheme ::
        (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) =>
        a
        {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -}
        -> m T.Text
        {- ^ __Returns:__ /@srv@/\'s scheme name -}
    networkServiceGetScheme srv = liftIO $ do
        srv' <- unsafeManagedPtrCastPtr srv
        result <- g_network_service_get_scheme srv'
        checkUnexpectedReturnNULL "networkServiceGetScheme" result
        result' <- cstringToText result
        touchManagedPtr srv
        return result'

    #if ENABLE_OVERLOADING
    data NetworkServiceGetSchemeMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetSchemeMethodInfo a signature where
        overloadedMethod _ = networkServiceGetScheme

    #endif

    -- method NetworkService::get_service
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_get_service" g_network_service_get_service ::
        Ptr NetworkService ->                   -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"})
        IO CString

    {- |
    Gets /@srv@/\'s service name (eg, \"ldap\").

    /Since: 2.22/
    -}
    networkServiceGetService ::
        (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) =>
        a
        {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -}
        -> m T.Text
        {- ^ __Returns:__ /@srv@/\'s service name -}
    networkServiceGetService srv = liftIO $ do
        srv' <- unsafeManagedPtrCastPtr srv
        result <- g_network_service_get_service srv'
        checkUnexpectedReturnNULL "networkServiceGetService" result
        result' <- cstringToText result
        touchManagedPtr srv
        return result'

    #if ENABLE_OVERLOADING
    data NetworkServiceGetServiceMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceGetServiceMethodInfo a signature where
        overloadedMethod _ = networkServiceGetService

    #endif

    -- method NetworkService::set_scheme
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "srv", argType = TInterface (Name {namespace = "Gio", name = "NetworkService"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GNetworkService", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a URI scheme", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_network_service_set_scheme" g_network_service_set_scheme ::
        Ptr NetworkService ->                   -- srv : TInterface (Name {namespace = "Gio", name = "NetworkService"})
        CString ->                              -- scheme : TBasicType TUTF8
        IO ()

    {- |
    Set\'s the URI scheme used to resolve proxies. By default, the service name
    is used as scheme.

    /Since: 2.26/
    -}
    networkServiceSetScheme ::
        (B.CallStack.HasCallStack, MonadIO m, IsNetworkService a) =>
        a
        {- ^ /@srv@/: a 'GI.Gio.Objects.NetworkService.NetworkService' -}
        -> T.Text
        {- ^ /@scheme@/: a URI scheme -}
        -> m ()
    networkServiceSetScheme srv scheme = liftIO $ do
        srv' <- unsafeManagedPtrCastPtr srv
        scheme' <- textToCString scheme
        g_network_service_set_scheme srv' scheme'
        touchManagedPtr srv
        freeMem scheme'
        return ()

    #if ENABLE_OVERLOADING
    data NetworkServiceSetSchemeMethodInfo
    instance (signature ~ (T.Text -> m ()), MonadIO m, IsNetworkService a) => O.MethodInfo NetworkServiceSetSchemeMethodInfo a signature where
        overloadedMethod _ = networkServiceSetScheme

    #endif