-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.IBus.Flags
    ( 

 -- * Flags
-- ** BusNameFlag #flag:BusNameFlag#

    BusNameFlag(..)                         ,


-- ** Capabilite #flag:Capabilite#

    Capabilite(..)                          ,


-- ** InputHints #flag:InputHints#

    InputHints(..)                          ,


-- ** ModifierType #flag:ModifierType#

    ModifierType(..)                        ,


-- ** ObjectFlags #flag:ObjectFlags#

    ObjectFlags(..)                         ,




    ) 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.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


-- Flags ObjectFlags
-- | The flags are used internally.
data ObjectFlags = 
      ObjectFlagsInDestruction
    -- ^ Used in GObjectClass[dispose](#g:signal:dispose)
    | ObjectFlagsDestroyed
    -- ^ Used during emitting IBusObject[destroy](#g:signal:destroy) signal.
    | ObjectFlagsReserved1
    -- ^ Reserved.
    | ObjectFlagsReserved2
    -- ^ Reserved.
    | AnotherObjectFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ObjectFlags -> ShowS
[ObjectFlags] -> ShowS
ObjectFlags -> String
(Int -> ObjectFlags -> ShowS)
-> (ObjectFlags -> String)
-> ([ObjectFlags] -> ShowS)
-> Show ObjectFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ObjectFlags] -> ShowS
$cshowList :: [ObjectFlags] -> ShowS
show :: ObjectFlags -> String
$cshow :: ObjectFlags -> String
showsPrec :: Int -> ObjectFlags -> ShowS
$cshowsPrec :: Int -> ObjectFlags -> ShowS
Show, ObjectFlags -> ObjectFlags -> Bool
(ObjectFlags -> ObjectFlags -> Bool)
-> (ObjectFlags -> ObjectFlags -> Bool) -> Eq ObjectFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ObjectFlags -> ObjectFlags -> Bool
$c/= :: ObjectFlags -> ObjectFlags -> Bool
== :: ObjectFlags -> ObjectFlags -> Bool
$c== :: ObjectFlags -> ObjectFlags -> Bool
Eq)

instance P.Enum ObjectFlags where
    fromEnum :: ObjectFlags -> Int
fromEnum ObjectFlags
ObjectFlagsInDestruction = Int
1
    fromEnum ObjectFlags
ObjectFlagsDestroyed = Int
2
    fromEnum ObjectFlags
ObjectFlagsReserved1 = Int
4
    fromEnum ObjectFlags
ObjectFlagsReserved2 = Int
8
    fromEnum (AnotherObjectFlags Int
k) = Int
k

    toEnum :: Int -> ObjectFlags
toEnum Int
1 = ObjectFlags
ObjectFlagsInDestruction
    toEnum Int
2 = ObjectFlags
ObjectFlagsDestroyed
    toEnum Int
4 = ObjectFlags
ObjectFlagsReserved1
    toEnum Int
8 = ObjectFlags
ObjectFlagsReserved2
    toEnum Int
k = Int -> ObjectFlags
AnotherObjectFlags Int
k

instance P.Ord ObjectFlags where
    compare :: ObjectFlags -> ObjectFlags -> Ordering
compare ObjectFlags
a ObjectFlags
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
a) (ObjectFlags -> Int
forall a. Enum a => a -> Int
P.fromEnum ObjectFlags
b)

type instance O.ParentTypes ObjectFlags = '[]
instance O.HasParentTypes ObjectFlags

foreign import ccall "ibus_object_flags_get_type" c_ibus_object_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ObjectFlags where
    glibType :: IO GType
glibType = IO GType
c_ibus_object_flags_get_type

instance B.Types.BoxedFlags ObjectFlags

instance IsGFlag ObjectFlags

-- Flags ModifierType
-- | Handles key modifier such as control, shift and alt and release event.
-- Note that nits 15 - 25 are currently unused, while bit 29 is used internally.
data ModifierType = 
      ModifierTypeShiftMask
    -- ^ Shift  is activated.
    | ModifierTypeLockMask
    -- ^ Cap Lock is locked.
    | ModifierTypeControlMask
    -- ^ Control key is activated.
    | ModifierTypeMod1Mask
    -- ^ Modifier 1 (Usually Alt_L (0x40),  Alt_R (0x6c),  Meta_L (0xcd)) activated.
    | ModifierTypeMod2Mask
    -- ^ Modifier 2 (Usually Num_Lock (0x4d)) activated.
    | ModifierTypeMod3Mask
    -- ^ Modifier 3 activated.
    | ModifierTypeMod4Mask
    -- ^ Modifier 4 (Usually Super_L (0xce),  Hyper_L (0xcf)) activated.
    | ModifierTypeMod5Mask
    -- ^ Modifier 5 (ISO_Level3_Shift (0x5c),  Mode_switch (0xcb)) activated.
    | ModifierTypeButton1Mask
    -- ^ Mouse button 1 (left) is activated.
    | ModifierTypeButton2Mask
    -- ^ Mouse button 2 (middle) is activated.
    | ModifierTypeButton3Mask
    -- ^ Mouse button 3 (right) is activated.
    | ModifierTypeButton4Mask
    -- ^ Mouse button 4 (scroll up) is activated.
    | ModifierTypeButton5Mask
    -- ^ Mouse button 5 (scroll down) is activated.
    | ModifierTypeHandledMask
    -- ^ Handled mask indicates the event has been handled by ibus.
    | ModifierTypeForwardMask
    -- ^ Forward mask indicates the event has been forward from ibus.
    | ModifierTypeIgnoredMask
    -- ^ It is an alias of IBUS_FORWARD_MASK.
    | ModifierTypeSuperMask
    -- ^ Super (Usually Win) key is activated.
    | ModifierTypeHyperMask
    -- ^ Hyper key is activated.
    | ModifierTypeMetaMask
    -- ^ Meta key is activated.
    | ModifierTypeReleaseMask
    -- ^ Key is released.
    | ModifierTypeModifierMask
    -- ^ Modifier mask for the all the masks above.
    | AnotherModifierType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ModifierType -> ShowS
[ModifierType] -> ShowS
ModifierType -> String
(Int -> ModifierType -> ShowS)
-> (ModifierType -> String)
-> ([ModifierType] -> ShowS)
-> Show ModifierType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifierType] -> ShowS
$cshowList :: [ModifierType] -> ShowS
show :: ModifierType -> String
$cshow :: ModifierType -> String
showsPrec :: Int -> ModifierType -> ShowS
$cshowsPrec :: Int -> ModifierType -> ShowS
Show, ModifierType -> ModifierType -> Bool
(ModifierType -> ModifierType -> Bool)
-> (ModifierType -> ModifierType -> Bool) -> Eq ModifierType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifierType -> ModifierType -> Bool
$c/= :: ModifierType -> ModifierType -> Bool
== :: ModifierType -> ModifierType -> Bool
$c== :: ModifierType -> ModifierType -> Bool
Eq)

instance P.Enum ModifierType where
    fromEnum :: ModifierType -> Int
fromEnum ModifierType
ModifierTypeShiftMask = Int
1
    fromEnum ModifierType
ModifierTypeLockMask = Int
2
    fromEnum ModifierType
ModifierTypeControlMask = Int
4
    fromEnum ModifierType
ModifierTypeMod1Mask = Int
8
    fromEnum ModifierType
ModifierTypeMod2Mask = Int
16
    fromEnum ModifierType
ModifierTypeMod3Mask = Int
32
    fromEnum ModifierType
ModifierTypeMod4Mask = Int
64
    fromEnum ModifierType
ModifierTypeMod5Mask = Int
128
    fromEnum ModifierType
ModifierTypeButton1Mask = Int
256
    fromEnum ModifierType
ModifierTypeButton2Mask = Int
512
    fromEnum ModifierType
ModifierTypeButton3Mask = Int
1024
    fromEnum ModifierType
ModifierTypeButton4Mask = Int
2048
    fromEnum ModifierType
ModifierTypeButton5Mask = Int
4096
    fromEnum ModifierType
ModifierTypeHandledMask = Int
16777216
    fromEnum ModifierType
ModifierTypeForwardMask = Int
33554432
    fromEnum ModifierType
ModifierTypeIgnoredMask = Int
33554432
    fromEnum ModifierType
ModifierTypeSuperMask = Int
67108864
    fromEnum ModifierType
ModifierTypeHyperMask = Int
134217728
    fromEnum ModifierType
ModifierTypeMetaMask = Int
268435456
    fromEnum ModifierType
ModifierTypeReleaseMask = Int
1073741824
    fromEnum ModifierType
ModifierTypeModifierMask = Int
1593843711
    fromEnum (AnotherModifierType Int
k) = Int
k

    toEnum :: Int -> ModifierType
toEnum Int
1 = ModifierType
ModifierTypeShiftMask
    toEnum Int
2 = ModifierType
ModifierTypeLockMask
    toEnum Int
4 = ModifierType
ModifierTypeControlMask
    toEnum Int
8 = ModifierType
ModifierTypeMod1Mask
    toEnum Int
16 = ModifierType
ModifierTypeMod2Mask
    toEnum Int
32 = ModifierType
ModifierTypeMod3Mask
    toEnum Int
64 = ModifierType
ModifierTypeMod4Mask
    toEnum Int
128 = ModifierType
ModifierTypeMod5Mask
    toEnum Int
256 = ModifierType
ModifierTypeButton1Mask
    toEnum Int
512 = ModifierType
ModifierTypeButton2Mask
    toEnum Int
1024 = ModifierType
ModifierTypeButton3Mask
    toEnum Int
2048 = ModifierType
ModifierTypeButton4Mask
    toEnum Int
4096 = ModifierType
ModifierTypeButton5Mask
    toEnum Int
16777216 = ModifierType
ModifierTypeHandledMask
    toEnum Int
33554432 = ModifierType
ModifierTypeForwardMask
    toEnum Int
67108864 = ModifierType
ModifierTypeSuperMask
    toEnum Int
134217728 = ModifierType
ModifierTypeHyperMask
    toEnum Int
268435456 = ModifierType
ModifierTypeMetaMask
    toEnum Int
1073741824 = ModifierType
ModifierTypeReleaseMask
    toEnum Int
1593843711 = ModifierType
ModifierTypeModifierMask
    toEnum Int
k = Int -> ModifierType
AnotherModifierType Int
k

instance P.Ord ModifierType where
    compare :: ModifierType -> ModifierType -> Ordering
compare ModifierType
a ModifierType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
a) (ModifierType -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierType
b)

type instance O.ParentTypes ModifierType = '[]
instance O.HasParentTypes ModifierType

foreign import ccall "ibus_modifier_type_get_type" c_ibus_modifier_type_get_type :: 
    IO GType

instance B.Types.TypedObject ModifierType where
    glibType :: IO GType
glibType = IO GType
c_ibus_modifier_type_get_type

instance B.Types.BoxedFlags ModifierType

instance IsGFlag ModifierType

-- Flags InputHints
-- | Describes hints that might be taken into account by engines.  Note
-- that engines may already tailor their behaviour according to the
-- t'GI.IBus.Enums.InputPurpose' of the entry.
data InputHints = 
      InputHintsNone
    -- ^ No special behaviour suggested
    | InputHintsSpellcheck
    -- ^ Suggest checking for typos
    | InputHintsNoSpellcheck
    -- ^ Suggest not checking for typos
    | InputHintsWordCompletion
    -- ^ Suggest word completion
    | InputHintsLowercase
    -- ^ Suggest to convert all text to lowercase
    | InputHintsUppercaseChars
    -- ^ Suggest to capitalize all text
    | InputHintsUppercaseWords
    -- ^ Suggest to capitalize the first
    --     character of each word
    | InputHintsUppercaseSentences
    -- ^ Suggest to capitalize the
    --     first word of each sentence
    | InputHintsInhibitOsk
    -- ^ Suggest to not show an onscreen keyboard
    --     (e.g for a calculator that already has all the keys).
    | InputHintsVerticalWriting
    -- ^ The text is vertical.
    | AnotherInputHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputHints -> ShowS
[InputHints] -> ShowS
InputHints -> String
(Int -> InputHints -> ShowS)
-> (InputHints -> String)
-> ([InputHints] -> ShowS)
-> Show InputHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputHints] -> ShowS
$cshowList :: [InputHints] -> ShowS
show :: InputHints -> String
$cshow :: InputHints -> String
showsPrec :: Int -> InputHints -> ShowS
$cshowsPrec :: Int -> InputHints -> ShowS
Show, InputHints -> InputHints -> Bool
(InputHints -> InputHints -> Bool)
-> (InputHints -> InputHints -> Bool) -> Eq InputHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputHints -> InputHints -> Bool
$c/= :: InputHints -> InputHints -> Bool
== :: InputHints -> InputHints -> Bool
$c== :: InputHints -> InputHints -> Bool
Eq)

instance P.Enum InputHints where
    fromEnum :: InputHints -> Int
fromEnum InputHints
InputHintsNone = Int
0
    fromEnum InputHints
InputHintsSpellcheck = Int
1
    fromEnum InputHints
InputHintsNoSpellcheck = Int
2
    fromEnum InputHints
InputHintsWordCompletion = Int
4
    fromEnum InputHints
InputHintsLowercase = Int
8
    fromEnum InputHints
InputHintsUppercaseChars = Int
16
    fromEnum InputHints
InputHintsUppercaseWords = Int
32
    fromEnum InputHints
InputHintsUppercaseSentences = Int
64
    fromEnum InputHints
InputHintsInhibitOsk = Int
128
    fromEnum InputHints
InputHintsVerticalWriting = Int
256
    fromEnum (AnotherInputHints Int
k) = Int
k

    toEnum :: Int -> InputHints
toEnum Int
0 = InputHints
InputHintsNone
    toEnum Int
1 = InputHints
InputHintsSpellcheck
    toEnum Int
2 = InputHints
InputHintsNoSpellcheck
    toEnum Int
4 = InputHints
InputHintsWordCompletion
    toEnum Int
8 = InputHints
InputHintsLowercase
    toEnum Int
16 = InputHints
InputHintsUppercaseChars
    toEnum Int
32 = InputHints
InputHintsUppercaseWords
    toEnum Int
64 = InputHints
InputHintsUppercaseSentences
    toEnum Int
128 = InputHints
InputHintsInhibitOsk
    toEnum Int
256 = InputHints
InputHintsVerticalWriting
    toEnum Int
k = Int -> InputHints
AnotherInputHints Int
k

instance P.Ord InputHints where
    compare :: InputHints -> InputHints -> Ordering
compare InputHints
a InputHints
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputHints -> Int
forall a. Enum a => a -> Int
P.fromEnum InputHints
a) (InputHints -> Int
forall a. Enum a => a -> Int
P.fromEnum InputHints
b)

type instance O.ParentTypes InputHints = '[]
instance O.HasParentTypes InputHints

foreign import ccall "ibus_input_hints_get_type" c_ibus_input_hints_get_type :: 
    IO GType

instance B.Types.TypedObject InputHints where
    glibType :: IO GType
glibType = IO GType
c_ibus_input_hints_get_type

instance B.Types.BoxedFlags InputHints

instance IsGFlag InputHints

-- Flags Capabilite
-- | Capability flags of UI.
data Capabilite = 
      CapabilitePreeditText
    -- ^ UI is capable to show pre-edit text.
    | CapabiliteAuxiliaryText
    -- ^ UI is capable to show auxiliary text.
    | CapabiliteLookupTable
    -- ^ UI is capable to show the lookup table.
    | CapabiliteFocus
    -- ^ UI is capable to get focus.
    | CapabiliteProperty
    -- ^ UI is capable to have property.
    | CapabiliteSurroundingText
    -- ^ Client can provide surround text,
    --  or IME can handle surround text.
    | AnotherCapabilite Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Capabilite -> ShowS
[Capabilite] -> ShowS
Capabilite -> String
(Int -> Capabilite -> ShowS)
-> (Capabilite -> String)
-> ([Capabilite] -> ShowS)
-> Show Capabilite
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Capabilite] -> ShowS
$cshowList :: [Capabilite] -> ShowS
show :: Capabilite -> String
$cshow :: Capabilite -> String
showsPrec :: Int -> Capabilite -> ShowS
$cshowsPrec :: Int -> Capabilite -> ShowS
Show, Capabilite -> Capabilite -> Bool
(Capabilite -> Capabilite -> Bool)
-> (Capabilite -> Capabilite -> Bool) -> Eq Capabilite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Capabilite -> Capabilite -> Bool
$c/= :: Capabilite -> Capabilite -> Bool
== :: Capabilite -> Capabilite -> Bool
$c== :: Capabilite -> Capabilite -> Bool
Eq)

instance P.Enum Capabilite where
    fromEnum :: Capabilite -> Int
fromEnum Capabilite
CapabilitePreeditText = Int
1
    fromEnum Capabilite
CapabiliteAuxiliaryText = Int
2
    fromEnum Capabilite
CapabiliteLookupTable = Int
4
    fromEnum Capabilite
CapabiliteFocus = Int
8
    fromEnum Capabilite
CapabiliteProperty = Int
16
    fromEnum Capabilite
CapabiliteSurroundingText = Int
32
    fromEnum (AnotherCapabilite Int
k) = Int
k

    toEnum :: Int -> Capabilite
toEnum Int
1 = Capabilite
CapabilitePreeditText
    toEnum Int
2 = Capabilite
CapabiliteAuxiliaryText
    toEnum Int
4 = Capabilite
CapabiliteLookupTable
    toEnum Int
8 = Capabilite
CapabiliteFocus
    toEnum Int
16 = Capabilite
CapabiliteProperty
    toEnum Int
32 = Capabilite
CapabiliteSurroundingText
    toEnum Int
k = Int -> Capabilite
AnotherCapabilite Int
k

instance P.Ord Capabilite where
    compare :: Capabilite -> Capabilite -> Ordering
compare Capabilite
a Capabilite
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Capabilite -> Int
forall a. Enum a => a -> Int
P.fromEnum Capabilite
a) (Capabilite -> Int
forall a. Enum a => a -> Int
P.fromEnum Capabilite
b)

type instance O.ParentTypes Capabilite = '[]
instance O.HasParentTypes Capabilite

foreign import ccall "ibus_capabilite_get_type" c_ibus_capabilite_get_type :: 
    IO GType

instance B.Types.TypedObject Capabilite where
    glibType :: IO GType
glibType = IO GType
c_ibus_capabilite_get_type

instance B.Types.BoxedFlags Capabilite

instance IsGFlag Capabilite

-- Flags BusNameFlag
-- | /No description available in the introspection data./
data BusNameFlag = 
      BusNameFlagAllowReplacement
    -- ^ same as DBUS_NAME_FLAG_ALLOW_REPLACEMENT
    | BusNameFlagReplaceExisting
    -- ^ same as DBUS_NAME_FLAG_REPLACE_EXISTING
    | BusNameFlagDoNotQueue
    -- ^ same as DBUS_NAME_FLAG_DO_NOT_QUEUE
    | AnotherBusNameFlag Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BusNameFlag -> ShowS
[BusNameFlag] -> ShowS
BusNameFlag -> String
(Int -> BusNameFlag -> ShowS)
-> (BusNameFlag -> String)
-> ([BusNameFlag] -> ShowS)
-> Show BusNameFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BusNameFlag] -> ShowS
$cshowList :: [BusNameFlag] -> ShowS
show :: BusNameFlag -> String
$cshow :: BusNameFlag -> String
showsPrec :: Int -> BusNameFlag -> ShowS
$cshowsPrec :: Int -> BusNameFlag -> ShowS
Show, BusNameFlag -> BusNameFlag -> Bool
(BusNameFlag -> BusNameFlag -> Bool)
-> (BusNameFlag -> BusNameFlag -> Bool) -> Eq BusNameFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BusNameFlag -> BusNameFlag -> Bool
$c/= :: BusNameFlag -> BusNameFlag -> Bool
== :: BusNameFlag -> BusNameFlag -> Bool
$c== :: BusNameFlag -> BusNameFlag -> Bool
Eq)

instance P.Enum BusNameFlag where
    fromEnum :: BusNameFlag -> Int
fromEnum BusNameFlag
BusNameFlagAllowReplacement = Int
1
    fromEnum BusNameFlag
BusNameFlagReplaceExisting = Int
2
    fromEnum BusNameFlag
BusNameFlagDoNotQueue = Int
4
    fromEnum (AnotherBusNameFlag Int
k) = Int
k

    toEnum :: Int -> BusNameFlag
toEnum Int
1 = BusNameFlag
BusNameFlagAllowReplacement
    toEnum Int
2 = BusNameFlag
BusNameFlagReplaceExisting
    toEnum Int
4 = BusNameFlag
BusNameFlagDoNotQueue
    toEnum Int
k = Int -> BusNameFlag
AnotherBusNameFlag Int
k

instance P.Ord BusNameFlag where
    compare :: BusNameFlag -> BusNameFlag -> Ordering
compare BusNameFlag
a BusNameFlag
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BusNameFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameFlag
a) (BusNameFlag -> Int
forall a. Enum a => a -> Int
P.fromEnum BusNameFlag
b)

type instance O.ParentTypes BusNameFlag = '[]
instance O.HasParentTypes BusNameFlag

foreign import ccall "ibus_bus_name_flag_get_type" c_ibus_bus_name_flag_get_type :: 
    IO GType

instance B.Types.TypedObject BusNameFlag where
    glibType :: IO GType
glibType = IO GType
c_ibus_bus_name_flag_get_type

instance B.Types.BoxedFlags BusNameFlag

instance IsGFlag BusNameFlag