    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Gio.Interfaces.Proxy.Proxy' handles connecting to a remote host via a given type of
    -- proxy server. It is implemented by the \'gio-proxy\' extension point.
    -- The extensions are named after their proxy protocol name. As an
    -- example, a SOCKS5 proxy implementation can be retrieved with the
    -- name \'socks5\' using the function
    -- 'GI.Gio.Structs.IOExtensionPoint.iOExtensionPointGetExtensionByName'.
    --
    -- /Since: 2.26/

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gio.Interfaces.Proxy
        (

    -- * Exported types
        Proxy(..)                               ,
        IsProxy                                 ,
        toProxy                                 ,

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

    #if defined(ENABLE_OVERLOADING)
        ResolveProxyMethod                      ,
    #endif

    -- ** connect #method:connect#

    #if defined(ENABLE_OVERLOADING)
        ProxyConnectMethodInfo                  ,
    #endif
        proxyConnect                            ,

    -- ** connectAsync #method:connectAsync#

    #if defined(ENABLE_OVERLOADING)
        ProxyConnectAsyncMethodInfo             ,
    #endif
        proxyConnectAsync                       ,

    -- ** connectFinish #method:connectFinish#

    #if defined(ENABLE_OVERLOADING)
        ProxyConnectFinishMethodInfo            ,
    #endif
        proxyConnectFinish                      ,

    -- ** getDefaultForProtocol #method:getDefaultForProtocol#

        proxyGetDefaultForProtocol              ,

    -- ** supportsHostname #method:supportsHostname#

    #if defined(ENABLE_OVERLOADING)
        ProxySupportsHostnameMethodInfo         ,
    #endif
        proxySupportsHostname                   ,

        ) where

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

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Callbacks as Gio.Callbacks
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
    import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
    import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.ProxyAddress as Gio.ProxyAddress

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

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

    foreign import ccall "g_proxy_get_type"
        c_g_proxy_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Proxy where
        glibType :: IO GType
    glibType = IO GType
    c_g_proxy_get_type

    instance B.Types.GObject Proxy

    -- | Convert 'Proxy' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue Proxy where
        toGValue :: Proxy -> IO GValue
    toGValue o :: Proxy
    o = do
            GType
    gtype <- IO GType
    c_g_proxy_get_type
            Proxy -> (Ptr Proxy -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Proxy
    o (GType -> (GValue -> Ptr Proxy -> IO ()) -> Ptr Proxy -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr Proxy -> IO ()
    forall a. GObject a => GValue -> Ptr a -> IO ()
    B.GValue.set_object)

        fromGValue :: GValue -> IO Proxy
    fromGValue gv :: GValue
    gv = do
            Ptr Proxy
    ptr <- GValue -> IO (Ptr Proxy)
    forall b. GObject b => GValue -> IO (Ptr b)
    B.GValue.get_object GValue
    gv :: IO (Ptr Proxy)
            (ManagedPtr Proxy -> Proxy) -> Ptr Proxy -> IO Proxy
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr Proxy -> Proxy
    Proxy Ptr Proxy
    ptr

    -- | Type class for types which can be safely cast to `Proxy`, for instance with `toProxy`.
    class (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o
    instance (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o

    instance O.HasParentTypes Proxy
    type instance O.ParentTypes Proxy = '[GObject.Object.Object]

    -- | Cast to `Proxy`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toProxy :: (MonadIO m, IsProxy o) => o -> m Proxy
    toProxy :: o -> m Proxy
    toProxy = IO Proxy -> m Proxy
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Proxy -> m Proxy) -> (o -> IO Proxy) -> o -> m Proxy
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ManagedPtr Proxy -> Proxy) -> o -> IO Proxy
    forall o o'.
    (HasCallStack, ManagedPtrNewtype o, TypedObject o,
     ManagedPtrNewtype o', TypedObject o') =>
    (ManagedPtr o' -> o') -> o -> IO o'
    unsafeCastTo ManagedPtr Proxy -> Proxy
    Proxy

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Proxy
    type instance O.AttributeList Proxy = ProxyAttributeList
    type ProxyAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveProxyMethod (t :: Symbol) (o :: *) :: * where
        ResolveProxyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveProxyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveProxyMethod "connect" o = ProxyConnectMethodInfo
        ResolveProxyMethod "connectAsync" o = ProxyConnectAsyncMethodInfo
        ResolveProxyMethod "connectFinish" o = ProxyConnectFinishMethodInfo
        ResolveProxyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveProxyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveProxyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveProxyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveProxyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveProxyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveProxyMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveProxyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveProxyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveProxyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveProxyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveProxyMethod "supportsHostname" o = ProxySupportsHostnameMethodInfo
        ResolveProxyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveProxyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveProxyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveProxyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveProxyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveProxyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveProxyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveProxyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveProxyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveProxyMethod l o = O.MethodResolutionFailed l o

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

    #endif

    -- method Proxy::connect
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "proxy"
    --           , argType = TInterface Name { namespace = "Gio" , name = "Proxy" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GProxy" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "connection"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "IOStream" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GIOStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "proxy_address"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "ProxyAddress" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GProxyAddress" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GCancellable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "IOStream" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_proxy_connect" g_proxy_connect ::
        Ptr Proxy ->                            -- proxy : TInterface (Name {namespace = "Gio", name = "Proxy"})
        Ptr Gio.IOStream.IOStream ->            -- connection : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr Gio.ProxyAddress.ProxyAddress ->    -- proxy_address : TInterface (Name {namespace = "Gio", name = "ProxyAddress"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.IOStream.IOStream)

    -- | Given /@connection@/ to communicate with a proxy (eg, a
    -- t'GI.Gio.Objects.SocketConnection.SocketConnection' that is connected to the proxy server), this
    -- does the necessary handshake to connect to /@proxyAddress@/, and if
    -- required, wraps the t'GI.Gio.Objects.IOStream.IOStream' to handle proxy payload.
    --
    -- /Since: 2.26/
    proxyConnect ::
        (B.CallStack.HasCallStack, MonadIO m, IsProxy a, Gio.IOStream.IsIOStream b, Gio.ProxyAddress.IsProxyAddress c, Gio.Cancellable.IsCancellable d) =>
        a
        -- ^ /@proxy@/: a t'GI.Gio.Interfaces.Proxy.Proxy'
        -> b
        -- ^ /@connection@/: a t'GI.Gio.Objects.IOStream.IOStream'
        -> c
        -- ^ /@proxyAddress@/: a t'GI.Gio.Objects.ProxyAddress.ProxyAddress'
        -> Maybe (d)
        -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
        -> m Gio.IOStream.IOStream
        -- ^ __Returns:__ a t'GI.Gio.Objects.IOStream.IOStream' that will replace /@connection@/. This might
        --               be the same as /@connection@/, in which case a reference
        --               will be added. /(Can throw 'Data.GI.Base.GError.GError')/
    proxyConnect :: a -> b -> c -> Maybe d -> m IOStream
    proxyConnect proxy :: a
    proxy connection :: b
    connection proxyAddress :: c
    proxyAddress cancellable :: Maybe d
    cancellable = IO IOStream -> m IOStream
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Proxy
    proxy' <- a -> IO (Ptr Proxy)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    proxy
        Ptr IOStream
    connection' <- b -> IO (Ptr IOStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    connection
        Ptr ProxyAddress
    proxyAddress' <- c -> IO (Ptr ProxyAddress)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    proxyAddress
        Ptr Cancellable
    maybeCancellable <- case Maybe d
    cancellable of
            Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just jCancellable :: d
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- d -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr d
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        IO IOStream -> IO () -> IO IOStream
    forall a b. IO a -> IO b -> IO a
    onException (do
            Ptr IOStream
    result <- (Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream)
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream))
    -> (Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream)
    forall a b. (a -> b) -> a -> b
    $ Ptr Proxy
    -> Ptr IOStream
    -> Ptr ProxyAddress
    -> Ptr Cancellable
    -> Ptr (Ptr GError)
    -> IO (Ptr IOStream)
    g_proxy_connect Ptr Proxy
    proxy' Ptr IOStream
    connection' Ptr ProxyAddress
    proxyAddress' Ptr Cancellable
    maybeCancellable
            Text -> Ptr IOStream -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "proxyConnect" Ptr IOStream
    result
            IOStream
    result' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr IOStream -> IOStream
    Gio.IOStream.IOStream) Ptr IOStream
    result
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    proxy
            b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    connection
            c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr c
    proxyAddress
            Maybe d -> (d -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe d
    cancellable d -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
            IOStream -> IO IOStream
    forall (m :: * -> *) a. Monad m => a -> m a
    return IOStream
    result'
         ) (do
            () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data ProxyConnectMethodInfo
    instance (signature ~ (b -> c -> Maybe (d) -> m Gio.IOStream.IOStream), MonadIO m, IsProxy a, Gio.IOStream.IsIOStream b, Gio.ProxyAddress.IsProxyAddress c, Gio.Cancellable.IsCancellable d) => O.MethodInfo ProxyConnectMethodInfo a signature where
        overloadedMethod = proxyConnect

    #endif

    -- method Proxy::connect_async
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "proxy"
    --           , argType = TInterface Name { namespace = "Gio" , name = "Proxy" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GProxy" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "connection"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "IOStream" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GIOStream" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "proxy_address"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "ProxyAddress" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GProxyAddress" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "cancellable"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "Cancellable" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GCancellable" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "callback"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncReadyCallback"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeAsync
    --           , argClosure = 5
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "user_data"
    --           , argType = TBasicType TPtr
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "callback data" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_proxy_connect_async" g_proxy_connect_async ::
        Ptr Proxy ->                            -- proxy : TInterface (Name {namespace = "Gio", name = "Proxy"})
        Ptr Gio.IOStream.IOStream ->            -- connection : TInterface (Name {namespace = "Gio", name = "IOStream"})
        Ptr Gio.ProxyAddress.ProxyAddress ->    -- proxy_address : TInterface (Name {namespace = "Gio", name = "ProxyAddress"})
        Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
        FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
        Ptr () ->                               -- user_data : TBasicType TPtr
        IO ()

    -- | Asynchronous version of 'GI.Gio.Interfaces.Proxy.proxyConnect'.
    --
    -- /Since: 2.26/
    proxyConnectAsync ::
        (B.CallStack.HasCallStack, MonadIO m, IsProxy a, Gio.IOStream.IsIOStream b, Gio.ProxyAddress.IsProxyAddress c, Gio.Cancellable.IsCancellable d) =>
        a
        -- ^ /@proxy@/: a t'GI.Gio.Interfaces.Proxy.Proxy'
        -> b
        -- ^ /@connection@/: a t'GI.Gio.Objects.IOStream.IOStream'
        -> c
        -- ^ /@proxyAddress@/: a t'GI.Gio.Objects.ProxyAddress.ProxyAddress'
        -> Maybe (d)
        -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
        -> Maybe (Gio.Callbacks.AsyncReadyCallback)
        -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback'
        -> m ()
    proxyConnectAsync :: a -> b -> c -> Maybe d -> Maybe AsyncReadyCallback -> m ()
    proxyConnectAsync proxy :: a
    proxy connection :: b
    connection proxyAddress :: c
    proxyAddress cancellable :: Maybe d
    cancellable callback :: Maybe AsyncReadyCallback
    callback = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Proxy
    proxy' <- a -> IO (Ptr Proxy)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    proxy
        Ptr IOStream
    connection' <- b -> IO (Ptr IOStream)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    connection
        Ptr ProxyAddress
    proxyAddress' <- c -> IO (Ptr ProxyAddress)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr c
    proxyAddress
        Ptr Cancellable
    maybeCancellable <- case Maybe d
    cancellable of
            Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    forall a. Ptr a
    nullPtr
            Just jCancellable :: d
    jCancellable -> do
                Ptr Cancellable
    jCancellable' <- d -> IO (Ptr Cancellable)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr d
    jCancellable
                Ptr Cancellable -> IO (Ptr Cancellable)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Cancellable
    jCancellable'
        FunPtr C_AsyncReadyCallback
    maybeCallback <- case Maybe AsyncReadyCallback
    callback of
            Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Ptr Any -> FunPtr C_AsyncReadyCallback
    forall a b. Ptr a -> FunPtr b
    castPtrToFunPtr Ptr Any
    forall a. Ptr a
    nullPtr)
            Just jCallback :: AsyncReadyCallback
    jCallback -> do
                Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
                FunPtr C_AsyncReadyCallback
    jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
    -> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
    Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
    -> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
    forall a. a -> Maybe a
    Just Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
    Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
    jCallback))
                Ptr (FunPtr C_AsyncReadyCallback)
    -> FunPtr C_AsyncReadyCallback -> IO ()
    forall a. Storable a => Ptr a -> a -> IO ()
    poke Ptr (FunPtr C_AsyncReadyCallback)
    ptrcallback FunPtr C_AsyncReadyCallback
    jCallback'
                FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
    forall (m :: * -> *) a. Monad m => a -> m a
    return FunPtr C_AsyncReadyCallback
    jCallback'
        let userData :: Ptr a
    userData = Ptr a
    forall a. Ptr a
    nullPtr
        Ptr Proxy
    -> Ptr IOStream
    -> Ptr ProxyAddress
    -> Ptr Cancellable
    -> FunPtr C_AsyncReadyCallback
    -> Ptr ()
    -> IO ()
    g_proxy_connect_async Ptr Proxy
    proxy' Ptr IOStream
    connection' Ptr ProxyAddress
    proxyAddress' Ptr Cancellable
    maybeCancellable FunPtr C_AsyncReadyCallback
    maybeCallback Ptr ()
    forall a. Ptr a
    userData
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    proxy
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    connection
        c -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr c
    proxyAddress
        Maybe d -> (d -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe d
    cancellable d -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ProxyConnectAsyncMethodInfo
    instance (signature ~ (b -> c -> Maybe (d) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsProxy a, Gio.IOStream.IsIOStream b, Gio.ProxyAddress.IsProxyAddress c, Gio.Cancellable.IsCancellable d) => O.MethodInfo ProxyConnectAsyncMethodInfo a signature where
        overloadedMethod = proxyConnectAsync

    #endif

    -- method Proxy::connect_finish
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "proxy"
    --           , argType = TInterface Name { namespace = "Gio" , name = "Proxy" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GProxy" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "result"
    --           , argType =
    --               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #GAsyncResult" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "IOStream" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_proxy_connect_finish" g_proxy_connect_finish ::
        Ptr Proxy ->                            -- proxy : TInterface (Name {namespace = "Gio", name = "Proxy"})
        Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Gio.IOStream.IOStream)

    -- | See 'GI.Gio.Interfaces.Proxy.proxyConnect'.
    --
    -- /Since: 2.26/
    proxyConnectFinish ::
        (B.CallStack.HasCallStack, MonadIO m, IsProxy a, Gio.AsyncResult.IsAsyncResult b) =>
        a
        -- ^ /@proxy@/: a t'GI.Gio.Interfaces.Proxy.Proxy'
        -> b
        -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'
        -> m Gio.IOStream.IOStream
        -- ^ __Returns:__ a t'GI.Gio.Objects.IOStream.IOStream'. /(Can throw 'Data.GI.Base.GError.GError')/
    proxyConnectFinish :: a -> b -> m IOStream
    proxyConnectFinish proxy :: a
    proxy result_ :: b
    result_ = IO IOStream -> m IOStream
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Proxy
    proxy' <- a -> IO (Ptr Proxy)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    proxy
        Ptr AsyncResult
    result_' <- b -> IO (Ptr AsyncResult)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    result_
        IO IOStream -> IO () -> IO IOStream
    forall a b. IO a -> IO b -> IO a
    onException (do
            Ptr IOStream
    result <- (Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream)
    forall a. (Ptr (Ptr GError) -> IO a) -> IO a
    propagateGError ((Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream))
    -> (Ptr (Ptr GError) -> IO (Ptr IOStream)) -> IO (Ptr IOStream)
    forall a b. (a -> b) -> a -> b
    $ Ptr Proxy
    -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr IOStream)
    g_proxy_connect_finish Ptr Proxy
    proxy' Ptr AsyncResult
    result_'
            Text -> Ptr IOStream -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "proxyConnectFinish" Ptr IOStream
    result
            IOStream
    result' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr IOStream -> IOStream
    Gio.IOStream.IOStream) Ptr IOStream
    result
            a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    proxy
            b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    result_
            IOStream -> IO IOStream
    forall (m :: * -> *) a. Monad m => a -> m a
    return IOStream
    result'
         ) (do
            () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data ProxyConnectFinishMethodInfo
    instance (signature ~ (b -> m Gio.IOStream.IOStream), MonadIO m, IsProxy a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ProxyConnectFinishMethodInfo a signature where
        overloadedMethod = proxyConnectFinish

    #endif

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

    foreign import ccall "g_proxy_supports_hostname" g_proxy_supports_hostname ::
        Ptr Proxy ->                            -- proxy : TInterface (Name {namespace = "Gio", name = "Proxy"})
        IO CInt

    -- | Some proxy protocols expect to be passed a hostname, which they
    -- will resolve to an IP address themselves. Others, like SOCKS4, do
    -- not allow this. This function will return 'P.False' if /@proxy@/ is
    -- implementing such a protocol. When 'P.False' is returned, the caller
    -- should resolve the destination hostname first, and then pass a
    -- t'GI.Gio.Objects.ProxyAddress.ProxyAddress' containing the stringified IP address to
    -- 'GI.Gio.Interfaces.Proxy.proxyConnect' or 'GI.Gio.Interfaces.Proxy.proxyConnectAsync'.
    --
    -- /Since: 2.26/
    proxySupportsHostname ::
        (B.CallStack.HasCallStack, MonadIO m, IsProxy a) =>
        a
        -- ^ /@proxy@/: a t'GI.Gio.Interfaces.Proxy.Proxy'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if hostname resolution is supported.
    proxySupportsHostname :: a -> m Bool
    proxySupportsHostname proxy :: a
    proxy = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Proxy
    proxy' <- a -> IO (Ptr Proxy)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    proxy
        CInt
    result <- Ptr Proxy -> IO CInt
    g_proxy_supports_hostname Ptr Proxy
    proxy'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    proxy
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data ProxySupportsHostnameMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsProxy a) => O.MethodInfo ProxySupportsHostnameMethodInfo a signature where
        overloadedMethod = proxySupportsHostname

    #endif

    -- method Proxy::get_default_for_protocol
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "protocol"
    --           , argType = TBasicType TUTF8
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the proxy protocol name (e.g. http, socks, etc)"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Gio" , name = "Proxy" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_proxy_get_default_for_protocol" g_proxy_get_default_for_protocol ::
        CString ->                              -- protocol : TBasicType TUTF8
        IO (Ptr Proxy)

    -- | Find the @gio-proxy@ extension point for a proxy implementation that supports
    -- the specified protocol.
    --
    -- /Since: 2.26/
    proxyGetDefaultForProtocol ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@protocol@/: the proxy protocol name (e.g. http, socks, etc)
        -> m Proxy
        -- ^ __Returns:__ return a t'GI.Gio.Interfaces.Proxy.Proxy' or NULL if protocol
        --               is not supported.
    proxyGetDefaultForProtocol :: Text -> m Proxy
    proxyGetDefaultForProtocol protocol :: Text
    protocol = IO Proxy -> m Proxy
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Proxy -> m Proxy) -> IO Proxy -> m Proxy
    forall a b. (a -> b) -> a -> b
    $ do
        CString
    protocol' <- Text -> IO CString
    textToCString Text
    protocol
        Ptr Proxy
    result <- CString -> IO (Ptr Proxy)
    g_proxy_get_default_for_protocol CString
    protocol'
        Text -> Ptr Proxy -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "proxyGetDefaultForProtocol" Ptr Proxy
    result
        Proxy
    result' <- ((ManagedPtr Proxy -> Proxy) -> Ptr Proxy -> IO Proxy
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Proxy -> Proxy
    Proxy) Ptr Proxy
    result
        CString -> IO ()
    forall a. Ptr a -> IO ()
    freeMem CString
    protocol'
        Proxy -> IO Proxy
    forall (m :: * -> *) a. Monad m => a -> m a
    return Proxy
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    #endif