    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- An object used to store the GType of the
    -- factories used to create an accessible object for an object of a
    -- particular GType.
    --
    -- The AtkRegistry is normally used to create appropriate ATK \"peers\"
    -- for user interface components.  Application developers usually need
    -- only interact with the AtkRegistry by associating appropriate ATK
    -- implementation classes with GObject classes via the
    -- atk_registry_set_factory_type call, passing the appropriate GType
    -- for application custom widget classes.

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

    module GI.Atk.Objects.Registry
        (

    -- * Exported types
        Registry(..)                            ,
        IsRegistry                              ,
        toRegistry                              ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFactory]("GI.Atk.Objects.Registry#g:method:getFactory"), [getFactoryType]("GI.Atk.Objects.Registry#g:method:getFactoryType"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFactoryType]("GI.Atk.Objects.Registry#g:method:setFactoryType"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveRegistryMethod                   ,
    #endif

    -- ** getFactory #method:getFactory#

    #if defined(ENABLE_OVERLOADING)
        RegistryGetFactoryMethodInfo            ,
    #endif
        registryGetFactory                      ,

    -- ** getFactoryType #method:getFactoryType#

    #if defined(ENABLE_OVERLOADING)
        RegistryGetFactoryTypeMethodInfo        ,
    #endif
        registryGetFactoryType                  ,

    -- ** setFactoryType #method:setFactoryType#

    #if defined(ENABLE_OVERLOADING)
        RegistrySetFactoryTypeMethodInfo        ,
    #endif
        registrySetFactoryType                  ,

        ) where

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

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

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import {-# SOURCE #-} qualified GI.Atk.Enums as Atk.Enums
    import {-# SOURCE #-} qualified GI.Atk.Objects.Object as Atk.Object
    import {-# SOURCE #-} qualified GI.Atk.Objects.ObjectFactory as Atk.ObjectFactory
    import {-# SOURCE #-} qualified GI.Atk.Objects.Relation as Atk.Relation
    import {-# SOURCE #-} qualified GI.Atk.Objects.RelationSet as Atk.RelationSet
    import {-# SOURCE #-} qualified GI.Atk.Objects.StateSet as Atk.StateSet
    import {-# SOURCE #-} qualified GI.Atk.Structs.PropertyValues as Atk.PropertyValues
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray

    #else
    import {-# SOURCE #-} qualified GI.Atk.Objects.ObjectFactory as Atk.ObjectFactory
    import qualified GI.GObject.Objects.Object as GObject.Object

    #endif

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

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

    foreign import ccall "atk_registry_get_type"
        c_atk_registry_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Registry where
        glibType :: IO GType
    glibType = IO GType
    c_atk_registry_get_type

    instance B.Types.GObject Registry

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveRegistryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveRegistryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveRegistryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveRegistryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveRegistryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveRegistryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveRegistryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveRegistryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveRegistryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveRegistryMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveRegistryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveRegistryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveRegistryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveRegistryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveRegistryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveRegistryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveRegistryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveRegistryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveRegistryMethod "getFactory" o = RegistryGetFactoryMethodInfo
        ResolveRegistryMethod "getFactoryType" o = RegistryGetFactoryTypeMethodInfo
        ResolveRegistryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveRegistryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveRegistryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveRegistryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveRegistryMethod "setFactoryType" o = RegistrySetFactoryTypeMethodInfo
        ResolveRegistryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveRegistryMethod l o = O.MethodResolutionFailed l o

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

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

    #endif

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

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Registry = RegistrySignalList
    type RegistrySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method Registry::get_factory
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "registry"
    --           , argType =
    --               TInterface Name { namespace = "Atk" , name = "Registry" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an #AtkRegistry" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType = TBasicType TGType
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GType with which to look up the associated #AtkObjectFactory"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Atk" , name = "ObjectFactory" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_registry_get_factory" atk_registry_get_factory ::
        Ptr Registry ->                         -- registry : TInterface (Name {namespace = "Atk", name = "Registry"})
        CGType ->                               -- type : TBasicType TGType
        IO (Ptr Atk.ObjectFactory.ObjectFactory)

    -- | Gets an t'GI.Atk.Objects.ObjectFactory.ObjectFactory' appropriate for creating @/AtkObjects/@
    -- appropriate for /@type@/.
    registryGetFactory ::
        (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
        a
        -- ^ /@registry@/: an t'GI.Atk.Objects.Registry.Registry'
        -> GType
        -- ^ /@type@/: a t'GType' with which to look up the associated t'GI.Atk.Objects.ObjectFactory.ObjectFactory'
        -> m Atk.ObjectFactory.ObjectFactory
        -- ^ __Returns:__ an t'GI.Atk.Objects.ObjectFactory.ObjectFactory' appropriate for creating
        -- @/AtkObjects/@ appropriate for /@type@/.
    registryGetFactory :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsRegistry a) =>
    a -> GType -> m ObjectFactory
    registryGetFactory a
    registry GType
    type_ = IO ObjectFactory -> m ObjectFactory
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ObjectFactory -> m ObjectFactory)
    -> IO ObjectFactory -> m ObjectFactory
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Registry
    registry' <- a -> IO (Ptr Registry)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    registry
        let type_' :: CGType
    type_' = GType -> CGType
    gtypeToCGType GType
    type_
        Ptr ObjectFactory
    result <- Ptr Registry -> CGType -> IO (Ptr ObjectFactory)
    atk_registry_get_factory Ptr Registry
    registry' CGType
    type_'
        Text -> Ptr ObjectFactory -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "registryGetFactory" Ptr ObjectFactory
    result
        ObjectFactory
    result' <- ((ManagedPtr ObjectFactory -> ObjectFactory)
    -> Ptr ObjectFactory -> IO ObjectFactory
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr ObjectFactory -> ObjectFactory
    Atk.ObjectFactory.ObjectFactory) Ptr ObjectFactory
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    registry
        ObjectFactory -> IO ObjectFactory
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ObjectFactory
    result'

    #if defined(ENABLE_OVERLOADING)
    data RegistryGetFactoryMethodInfo
    instance (signature ~ (GType -> m Atk.ObjectFactory.ObjectFactory), MonadIO m, IsRegistry a) => O.OverloadedMethod RegistryGetFactoryMethodInfo a signature where
        overloadedMethod = registryGetFactory

    instance O.OverloadedMethodInfo RegistryGetFactoryMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Registry.registryGetFactory",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Registry.html#v:registryGetFactory"
            })

    #endif

    -- method Registry::get_factory_type
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "registry"
    --           , argType =
    --               TInterface Name { namespace = "Atk" , name = "Registry" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an #AtkRegistry" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType = TBasicType TGType
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GType with which to look up the associated #AtkObjectFactory\nsubclass"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TGType)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_registry_get_factory_type" atk_registry_get_factory_type ::
        Ptr Registry ->                         -- registry : TInterface (Name {namespace = "Atk", name = "Registry"})
        CGType ->                               -- type : TBasicType TGType
        IO CGType

    -- | Provides a t'GType' indicating the t'GI.Atk.Objects.ObjectFactory.ObjectFactory' subclass
    -- associated with /@type@/.
    registryGetFactoryType ::
        (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
        a
        -- ^ /@registry@/: an t'GI.Atk.Objects.Registry.Registry'
        -> GType
        -- ^ /@type@/: a t'GType' with which to look up the associated t'GI.Atk.Objects.ObjectFactory.ObjectFactory'
        -- subclass
        -> m GType
        -- ^ __Returns:__ a t'GType' associated with type /@type@/
    registryGetFactoryType :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsRegistry a) =>
    a -> GType -> m GType
    registryGetFactoryType a
    registry GType
    type_ = IO GType -> m GType
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GType -> m GType) -> IO GType -> m GType
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Registry
    registry' <- a -> IO (Ptr Registry)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    registry
        let type_' :: CGType
    type_' = GType -> CGType
    gtypeToCGType GType
    type_
        CGType
    result <- Ptr Registry -> CGType -> IO CGType
    atk_registry_get_factory_type Ptr Registry
    registry' CGType
    type_'
        let result' :: GType
    result' = CGType -> GType
    GType CGType
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    registry
        GType -> IO GType
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GType
    result'

    #if defined(ENABLE_OVERLOADING)
    data RegistryGetFactoryTypeMethodInfo
    instance (signature ~ (GType -> m GType), MonadIO m, IsRegistry a) => O.OverloadedMethod RegistryGetFactoryTypeMethodInfo a signature where
        overloadedMethod = registryGetFactoryType

    instance O.OverloadedMethodInfo RegistryGetFactoryTypeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Registry.registryGetFactoryType",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Registry.html#v:registryGetFactoryType"
            })

    #endif

    -- method Registry::set_factory_type
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "registry"
    --           , argType =
    --               TInterface Name { namespace = "Atk" , name = "Registry" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "the #AtkRegistry in which to register the type association"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "type"
    --           , argType = TBasicType TGType
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "an #AtkObject type" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "factory_type"
    --           , argType = TBasicType TGType
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "an #AtkObjectFactory type to associate with @type.  Must\nimplement AtkObject appropriate for @type."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_registry_set_factory_type" atk_registry_set_factory_type ::
        Ptr Registry ->                         -- registry : TInterface (Name {namespace = "Atk", name = "Registry"})
        CGType ->                               -- type : TBasicType TGType
        CGType ->                               -- factory_type : TBasicType TGType
        IO ()

    -- | Associate an t'GI.Atk.Objects.ObjectFactory.ObjectFactory' subclass with a t'GType'. Note:
    -- The associated /@factoryType@/ will thereafter be responsible for
    -- the creation of new t'GI.Atk.Objects.Object.Object' implementations for instances
    -- appropriate for /@type@/.
    registrySetFactoryType ::
        (B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
        a
        -- ^ /@registry@/: the t'GI.Atk.Objects.Registry.Registry' in which to register the type association
        -> GType
        -- ^ /@type@/: an t'GI.Atk.Objects.Object.Object' type
        -> GType
        -- ^ /@factoryType@/: an t'GI.Atk.Objects.ObjectFactory.ObjectFactory' type to associate with /@type@/.  Must
        -- implement AtkObject appropriate for /@type@/.
        -> m ()
    registrySetFactoryType :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsRegistry a) =>
    a -> GType -> GType -> m ()
    registrySetFactoryType a
    registry GType
    type_ GType
    factoryType = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Registry
    registry' <- a -> IO (Ptr Registry)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    registry
        let type_' :: CGType
    type_' = GType -> CGType
    gtypeToCGType GType
    type_
        let factoryType' :: CGType
    factoryType' = GType -> CGType
    gtypeToCGType GType
    factoryType
        Ptr Registry -> CGType -> CGType -> IO ()
    atk_registry_set_factory_type Ptr Registry
    registry' CGType
    type_' CGType
    factoryType'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    registry
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data RegistrySetFactoryTypeMethodInfo
    instance (signature ~ (GType -> GType -> m ()), MonadIO m, IsRegistry a) => O.OverloadedMethod RegistrySetFactoryTypeMethodInfo a signature where
        overloadedMethod = registrySetFactoryType

    instance O.OverloadedMethodInfo RegistrySetFactoryTypeMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Objects.Registry.registrySetFactoryType",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Objects-Registry.html#v:registrySetFactoryType"
            })

    #endif