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

    'GI.Gio.Objects.CharsetConverter.CharsetConverter' is an implementation of 'GI.Gio.Interfaces.Converter.Converter' based on
    GIConv.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.CharsetConverter
        (

    -- * Exported types
        CharsetConverter(..)                    ,
        IsCharsetConverter                      ,
        toCharsetConverter                      ,
        noCharsetConverter                      ,

     -- * Methods
    -- ** getNumFallbacks #method:getNumFallbacks#

    #if ENABLE_OVERLOADING
        CharsetConverterGetNumFallbacksMethodInfo,
    #endif
        charsetConverterGetNumFallbacks         ,

    -- ** getUseFallback #method:getUseFallback#

    #if ENABLE_OVERLOADING
        CharsetConverterGetUseFallbackMethodInfo,
    #endif
        charsetConverterGetUseFallback          ,

    -- ** new #method:new#

        charsetConverterNew                     ,

    -- ** setUseFallback #method:setUseFallback#

    #if ENABLE_OVERLOADING
        CharsetConverterSetUseFallbackMethodInfo,
    #endif
        charsetConverterSetUseFallback          ,

     -- * Properties
    -- ** fromCharset #attr:fromCharset#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        CharsetConverterFromCharsetPropertyInfo ,
    #endif
    #if ENABLE_OVERLOADING
        charsetConverterFromCharset             ,
    #endif
        constructCharsetConverterFromCharset    ,
        getCharsetConverterFromCharset          ,

    -- ** toCharset #attr:toCharset#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        CharsetConverterToCharsetPropertyInfo   ,
    #endif
    #if ENABLE_OVERLOADING
        charsetConverterToCharset               ,
    #endif
        constructCharsetConverterToCharset      ,
        getCharsetConverterToCharset            ,

    -- ** useFallback #attr:useFallback#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        CharsetConverterUseFallbackPropertyInfo ,
    #endif
    #if ENABLE_OVERLOADING
        charsetConverterUseFallback             ,
    #endif
        constructCharsetConverterUseFallback    ,
        getCharsetConverterUseFallback          ,
        setCharsetConverterUseFallback          ,

        ) 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.Converter as Gio.Converter
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.Initable as Gio.Initable

    -- | Memory-managed wrapper type.
    newtype CharsetConverter = CharsetConverter (ManagedPtr CharsetConverter)
    foreign import ccall "g_charset_converter_get_type"
        c_g_charset_converter_get_type :: IO GType

    instance GObject CharsetConverter where
        gobjectType _ = c_g_charset_converter_get_type

    -- | Type class for types which can be safely cast to `CharsetConverter`, for instance with `toCharsetConverter`.
    class GObject o => IsCharsetConverter o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CharsetConverter a) =>
        IsCharsetConverter a
    #endif
    instance IsCharsetConverter CharsetConverter
    instance GObject.Object.IsObject CharsetConverter
    instance Gio.Converter.IsConverter CharsetConverter
    instance Gio.Initable.IsInitable CharsetConverter

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

    -- | A convenience alias for `Nothing` :: `Maybe` `CharsetConverter`.
    noCharsetConverter :: Maybe CharsetConverter
    noCharsetConverter = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveCharsetConverterMethod (t :: Symbol) (o :: *) :: * where
        ResolveCharsetConverterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCharsetConverterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCharsetConverterMethod "convert" o = Gio.Converter.ConverterConvertMethodInfo
        ResolveCharsetConverterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCharsetConverterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCharsetConverterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCharsetConverterMethod "init" o = Gio.Initable.InitableInitMethodInfo
        ResolveCharsetConverterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCharsetConverterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCharsetConverterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCharsetConverterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveCharsetConverterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCharsetConverterMethod "reset" o = Gio.Converter.ConverterResetMethodInfo
        ResolveCharsetConverterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCharsetConverterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCharsetConverterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCharsetConverterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCharsetConverterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveCharsetConverterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCharsetConverterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCharsetConverterMethod "getNumFallbacks" o = CharsetConverterGetNumFallbacksMethodInfo
        ResolveCharsetConverterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCharsetConverterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCharsetConverterMethod "getUseFallback" o = CharsetConverterGetUseFallbackMethodInfo
        ResolveCharsetConverterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCharsetConverterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCharsetConverterMethod "setUseFallback" o = CharsetConverterSetUseFallbackMethodInfo
        ResolveCharsetConverterMethod l o = O.MethodResolutionFailed l o

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

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveCharsetConverterMethod t CharsetConverter, O.MethodInfo info CharsetConverter p) => O.IsLabel t (CharsetConverter -> 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 "from-charset"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' charsetConverter #fromCharset
    @
    -}
    getCharsetConverterFromCharset :: (MonadIO m, IsCharsetConverter o) => o -> m (Maybe T.Text)
    getCharsetConverterFromCharset obj = liftIO $ getObjectPropertyString obj "from-charset"

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

    #if ENABLE_OVERLOADING
    data CharsetConverterFromCharsetPropertyInfo
    instance AttrInfo CharsetConverterFromCharsetPropertyInfo where
        type AttrAllowedOps CharsetConverterFromCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CharsetConverterFromCharsetPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint CharsetConverterFromCharsetPropertyInfo = IsCharsetConverter
        type AttrGetType CharsetConverterFromCharsetPropertyInfo = (Maybe T.Text)
        type AttrLabel CharsetConverterFromCharsetPropertyInfo = "from-charset"
        type AttrOrigin CharsetConverterFromCharsetPropertyInfo = CharsetConverter
        attrGet _ = getCharsetConverterFromCharset
        attrSet _ = undefined
        attrConstruct _ = constructCharsetConverterFromCharset
        attrClear _ = undefined
    #endif

    -- VVV Prop "to-charset"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

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

    @
    'Data.GI.Base.Attributes.get' charsetConverter #toCharset
    @
    -}
    getCharsetConverterToCharset :: (MonadIO m, IsCharsetConverter o) => o -> m (Maybe T.Text)
    getCharsetConverterToCharset obj = liftIO $ getObjectPropertyString obj "to-charset"

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

    #if ENABLE_OVERLOADING
    data CharsetConverterToCharsetPropertyInfo
    instance AttrInfo CharsetConverterToCharsetPropertyInfo where
        type AttrAllowedOps CharsetConverterToCharsetPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint CharsetConverterToCharsetPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint CharsetConverterToCharsetPropertyInfo = IsCharsetConverter
        type AttrGetType CharsetConverterToCharsetPropertyInfo = (Maybe T.Text)
        type AttrLabel CharsetConverterToCharsetPropertyInfo = "to-charset"
        type AttrOrigin CharsetConverterToCharsetPropertyInfo = CharsetConverter
        attrGet _ = getCharsetConverterToCharset
        attrSet _ = undefined
        attrConstruct _ = constructCharsetConverterToCharset
        attrClear _ = undefined
    #endif

    -- VVV Prop "use-fallback"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' charsetConverter #useFallback
    @
    -}
    getCharsetConverterUseFallback :: (MonadIO m, IsCharsetConverter o) => o -> m Bool
    getCharsetConverterUseFallback obj = liftIO $ getObjectPropertyBool obj "use-fallback"

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

    @
    'Data.GI.Base.Attributes.set' charsetConverter [ #useFallback 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setCharsetConverterUseFallback :: (MonadIO m, IsCharsetConverter o) => o -> Bool -> m ()
    setCharsetConverterUseFallback obj val = liftIO $ setObjectPropertyBool obj "use-fallback" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@use-fallback@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructCharsetConverterUseFallback :: (IsCharsetConverter o) => Bool -> IO (GValueConstruct o)
    constructCharsetConverterUseFallback val = constructObjectPropertyBool "use-fallback" val

    #if ENABLE_OVERLOADING
    data CharsetConverterUseFallbackPropertyInfo
    instance AttrInfo CharsetConverterUseFallbackPropertyInfo where
        type AttrAllowedOps CharsetConverterUseFallbackPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint CharsetConverterUseFallbackPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint CharsetConverterUseFallbackPropertyInfo = IsCharsetConverter
        type AttrGetType CharsetConverterUseFallbackPropertyInfo = Bool
        type AttrLabel CharsetConverterUseFallbackPropertyInfo = "use-fallback"
        type AttrOrigin CharsetConverterUseFallbackPropertyInfo = CharsetConverter
        attrGet _ = getCharsetConverterUseFallback
        attrSet _ = setCharsetConverterUseFallback
        attrConstruct _ = constructCharsetConverterUseFallback
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList CharsetConverter
    type instance O.AttributeList CharsetConverter = CharsetConverterAttributeList
    type CharsetConverterAttributeList = ('[ '("fromCharset", CharsetConverterFromCharsetPropertyInfo), '("toCharset", CharsetConverterToCharsetPropertyInfo), '("useFallback", CharsetConverterUseFallbackPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    charsetConverterFromCharset :: AttrLabelProxy "fromCharset"
    charsetConverterFromCharset = AttrLabelProxy

    charsetConverterToCharset :: AttrLabelProxy "toCharset"
    charsetConverterToCharset = AttrLabelProxy

    charsetConverterUseFallback :: AttrLabelProxy "useFallback"
    charsetConverterUseFallback = AttrLabelProxy

    #endif

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

    #endif

    -- method CharsetConverter::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "to_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "destination charset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from_charset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "source charset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "CharsetConverter"}))
    -- throws : True
    -- Skip return : False

    foreign import ccall "g_charset_converter_new" g_charset_converter_new ::
        CString ->                              -- to_charset : TBasicType TUTF8
        CString ->                              -- from_charset : TBasicType TUTF8
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr CharsetConverter)

    {- |
    Creates a new 'GI.Gio.Objects.CharsetConverter.CharsetConverter'.

    /Since: 2.24/
    -}
    charsetConverterNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        {- ^ /@toCharset@/: destination charset -}
        -> T.Text
        {- ^ /@fromCharset@/: source charset -}
        -> m CharsetConverter
        {- ^ __Returns:__ a new 'GI.Gio.Objects.CharsetConverter.CharsetConverter' or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
    charsetConverterNew toCharset fromCharset = liftIO $ do
        toCharset' <- textToCString toCharset
        fromCharset' <- textToCString fromCharset
        onException (do
            result <- propagateGError $ g_charset_converter_new toCharset' fromCharset'
            checkUnexpectedReturnNULL "charsetConverterNew" result
            result' <- (wrapObject CharsetConverter) result
            freeMem toCharset'
            freeMem fromCharset'
            return result'
         ) (do
            freeMem toCharset'
            freeMem fromCharset'
         )

    #if ENABLE_OVERLOADING
    #endif

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

    foreign import ccall "g_charset_converter_get_num_fallbacks" g_charset_converter_get_num_fallbacks ::
        Ptr CharsetConverter ->                 -- converter : TInterface (Name {namespace = "Gio", name = "CharsetConverter"})
        IO Word32

    {- |
    Gets the number of fallbacks that /@converter@/ has applied so far.

    /Since: 2.24/
    -}
    charsetConverterGetNumFallbacks ::
        (B.CallStack.HasCallStack, MonadIO m, IsCharsetConverter a) =>
        a
        {- ^ /@converter@/: a 'GI.Gio.Objects.CharsetConverter.CharsetConverter' -}
        -> m Word32
        {- ^ __Returns:__ the number of fallbacks that /@converter@/ has applied -}
    charsetConverterGetNumFallbacks converter = liftIO $ do
        converter' <- unsafeManagedPtrCastPtr converter
        result <- g_charset_converter_get_num_fallbacks converter'
        touchManagedPtr converter
        return result

    #if ENABLE_OVERLOADING
    data CharsetConverterGetNumFallbacksMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsCharsetConverter a) => O.MethodInfo CharsetConverterGetNumFallbacksMethodInfo a signature where
        overloadedMethod _ = charsetConverterGetNumFallbacks

    #endif

    -- method CharsetConverter::get_use_fallback
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "converter", argType = TInterface (Name {namespace = "Gio", name = "CharsetConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCharsetConverter", 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_charset_converter_get_use_fallback" g_charset_converter_get_use_fallback ::
        Ptr CharsetConverter ->                 -- converter : TInterface (Name {namespace = "Gio", name = "CharsetConverter"})
        IO CInt

    {- |
    Gets the 'GI.Gio.Objects.CharsetConverter.CharsetConverter':@/use-fallback/@ property.

    /Since: 2.24/
    -}
    charsetConverterGetUseFallback ::
        (B.CallStack.HasCallStack, MonadIO m, IsCharsetConverter a) =>
        a
        {- ^ /@converter@/: a 'GI.Gio.Objects.CharsetConverter.CharsetConverter' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if fallbacks are used by /@converter@/ -}
    charsetConverterGetUseFallback converter = liftIO $ do
        converter' <- unsafeManagedPtrCastPtr converter
        result <- g_charset_converter_get_use_fallback converter'
        let result' = (/= 0) result
        touchManagedPtr converter
        return result'

    #if ENABLE_OVERLOADING
    data CharsetConverterGetUseFallbackMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsCharsetConverter a) => O.MethodInfo CharsetConverterGetUseFallbackMethodInfo a signature where
        overloadedMethod _ = charsetConverterGetUseFallback

    #endif

    -- method CharsetConverter::set_use_fallback
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "converter", argType = TInterface (Name {namespace = "Gio", name = "CharsetConverter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GCharsetConverter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_fallback", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to use fallbacks", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_charset_converter_set_use_fallback" g_charset_converter_set_use_fallback ::
        Ptr CharsetConverter ->                 -- converter : TInterface (Name {namespace = "Gio", name = "CharsetConverter"})
        CInt ->                                 -- use_fallback : TBasicType TBoolean
        IO ()

    {- |
    Sets the 'GI.Gio.Objects.CharsetConverter.CharsetConverter':@/use-fallback/@ property.

    /Since: 2.24/
    -}
    charsetConverterSetUseFallback ::
        (B.CallStack.HasCallStack, MonadIO m, IsCharsetConverter a) =>
        a
        {- ^ /@converter@/: a 'GI.Gio.Objects.CharsetConverter.CharsetConverter' -}
        -> Bool
        {- ^ /@useFallback@/: 'True' to use fallbacks -}
        -> m ()
    charsetConverterSetUseFallback converter useFallback = liftIO $ do
        converter' <- unsafeManagedPtrCastPtr converter
        let useFallback' = (fromIntegral . fromEnum) useFallback
        g_charset_converter_set_use_fallback converter' useFallback'
        touchManagedPtr converter
        return ()

    #if ENABLE_OVERLOADING
    data CharsetConverterSetUseFallbackMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsCharsetConverter a) => O.MethodInfo CharsetConverterSetUseFallbackMethodInfo a signature where
        overloadedMethod _ = charsetConverterSetUseFallback

    #endif