    {-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The ATK interface implemented by valuators and components which display or select a value from a bounded range of values.
    --
    -- t'GI.Atk.Interfaces.Value.Value' should be implemented for components which either display
    -- a value from a bounded range, or which allow the user to specify a
    -- value from a bounded range, or both. For instance, most sliders and
    -- range controls, as well as dials, should have t'GI.Atk.Objects.Object.Object'
    -- representations which implement t'GI.Atk.Interfaces.Value.Value' on the component\'s
    -- behalf. @/AtKValues/@ may be read-only, in which case attempts to
    -- alter the value return would fail.
    --
    -- \<refsect1 id=\"current-value-text\">
    -- \<title>On the subject of current value text\<\/title>
    -- \<para>
    -- In addition to providing the current value, implementors can
    -- optionally provide an end-user-consumable textual description
    -- associated with this value. This description should be included
    -- when the numeric value fails to convey the full, on-screen
    -- representation seen by users.
    -- \<\/para>
    --
    -- \<example>
    -- \<title>Password strength\<\/title>
    -- A password strength meter whose value changes as the user types
    -- their new password. Red is used for values less than 4.0, yellow
    -- for values between 4.0 and 7.0, and green for values greater than
    -- 7.0. In this instance, value text should be provided by the
    -- implementor. Appropriate value text would be \"weak\", \"acceptable,\"
    -- and \"strong\" respectively.
    -- \<\/example>
    --
    -- A level bar whose value changes to reflect the battery charge. The
    -- color remains the same regardless of the charge and there is no
    -- on-screen text reflecting the fullness of the battery. In this
    -- case, because the position within the bar is the only indication
    -- the user has of the current charge, value text should not be
    -- provided by the implementor.
    --
    -- \<refsect2 id=\"implementor-notes\">
    -- \<title>Implementor Notes\<\/title>
    -- \<para>
    -- Implementors should bear in mind that assistive technologies will
    -- likely prefer the value text provided over the numeric value when
    -- presenting a widget\'s value. As a result, strings not intended for
    -- end users should not be exposed in the value text, and strings
    -- which are exposed should be localized. In the case of widgets which
    -- display value text on screen, for instance through a separate label
    -- in close proximity to the value-displaying widget, it is still
    -- expected that implementors will expose the value text using the
    -- above API.
    -- \<\/para>
    --
    -- \<para>
    -- t'GI.Atk.Interfaces.Value.Value' should NOT be implemented for widgets whose displayed
    -- value is not reflective of a meaningful amount. For instance, a
    -- progress pulse indicator whose value alternates between 0.0 and 1.0
    -- to indicate that some process is still taking place should not
    -- implement t'GI.Atk.Interfaces.Value.Value' because the current value does not reflect
    -- progress towards completion.
    -- \<\/para>
    -- \<\/refsect2>
    -- \<\/refsect1>
    --
    -- \<refsect1 id=\"ranges\">
    -- \<title>On the subject of ranges\<\/title>
    -- \<para>
    -- In addition to providing the minimum and maximum values,
    -- implementors can optionally provide details about subranges
    -- associated with the widget. These details should be provided by the
    -- implementor when both of the following are communicated visually to
    -- the end user:
    -- \<\/para>
    -- \<itemizedlist>
    --   \<listitem>The existence of distinct ranges such as \"weak\",
    --   \"acceptable\", and \"strong\" indicated by color, bar tick marks,
    --   and\/or on-screen text.\<\/listitem>
    --   \<listitem>Where the current value stands within a given subrange,
    --   for instance illustrating progression from very \"weak\" towards
    --   nearly \"acceptable\" through changes in shade and\/or position on
    --   the bar within the \"weak\" subrange.\<\/listitem>
    -- \<\/itemizedlist>
    -- \<para>
    -- If both of the above do not apply to the widget, it should be
    -- sufficient to expose the numeric value, along with the value text
    -- if appropriate, to make the widget accessible.
    -- \<\/para>
    --
    -- \<refsect2 id=\"ranges-implementor-notes\">
    -- \<title>Implementor Notes\<\/title>
    -- \<para>
    -- If providing subrange details is deemed necessary, all possible
    -- values of the widget are expected to fall within one of the
    -- subranges defined by the implementor.
    -- \<\/para>
    -- \<\/refsect2>
    -- \<\/refsect1>
    --
    -- \<refsect1 id=\"localization\">
    -- \<title>On the subject of localization of end-user-consumable text
    -- values\<\/title>
    -- \<para>
    -- Because value text and subrange descriptors are human-consumable,
    -- implementors are expected to provide localized strings which can be
    -- directly presented to end users via their assistive technology. In
    -- order to simplify this for implementors, implementors can use
    -- 'GI.Atk.Functions.valueTypeGetLocalizedName' with the following
    -- already-localized constants for commonly-needed values can be used:
    -- \<\/para>
    --
    -- \<itemizedlist>
    --   \<listitem>ATK_VALUE_VERY_WEAK\<\/listitem>
    --   \<listitem>ATK_VALUE_WEAK\<\/listitem>
    --   \<listitem>ATK_VALUE_ACCEPTABLE\<\/listitem>
    --   \<listitem>ATK_VALUE_STRONG\<\/listitem>
    --   \<listitem>ATK_VALUE_VERY_STRONG\<\/listitem>
    --   \<listitem>ATK_VALUE_VERY_LOW\<\/listitem>
    --   \<listitem>ATK_VALUE_LOW\<\/listitem>
    --   \<listitem>ATK_VALUE_MEDIUM\<\/listitem>
    --   \<listitem>ATK_VALUE_HIGH\<\/listitem>
    --   \<listitem>ATK_VALUE_VERY_HIGH\<\/listitem>
    --   \<listitem>ATK_VALUE_VERY_BAD\<\/listitem>
    --   \<listitem>ATK_VALUE_BAD\<\/listitem>
    --   \<listitem>ATK_VALUE_GOOD\<\/listitem>
    --   \<listitem>ATK_VALUE_VERY_GOOD\<\/listitem>
    --   \<listitem>ATK_VALUE_BEST\<\/listitem>
    --   \<listitem>ATK_VALUE_SUBSUBOPTIMAL\<\/listitem>
    --   \<listitem>ATK_VALUE_SUBOPTIMAL\<\/listitem>
    --   \<listitem>ATK_VALUE_OPTIMAL\<\/listitem>
    -- \<\/itemizedlist>
    -- \<para>
    -- Proposals for additional constants, along with their use cases,
    -- should be submitted to the GNOME Accessibility Team.
    -- \<\/para>
    -- \<\/refsect1>
    --
    -- \<refsect1 id=\"changes\">
    -- \<title>On the subject of changes\<\/title>
    -- \<para>
    -- Note that if there is a textual description associated with the new
    -- numeric value, that description should be included regardless of
    -- whether or not it has also changed.
    -- \<\/para>
    -- \<\/refsect1>

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

    module GI.Atk.Interfaces.Value
        (

    -- * Exported types
        Value(..)                               ,
        IsValue                                 ,
        toValue                                 ,

     -- * 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
    -- [getCurrentValue]("GI.Atk.Interfaces.Value#g:method:getCurrentValue"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getIncrement]("GI.Atk.Interfaces.Value#g:method:getIncrement"), [getMaximumValue]("GI.Atk.Interfaces.Value#g:method:getMaximumValue"), [getMinimumIncrement]("GI.Atk.Interfaces.Value#g:method:getMinimumIncrement"), [getMinimumValue]("GI.Atk.Interfaces.Value#g:method:getMinimumValue"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRange]("GI.Atk.Interfaces.Value#g:method:getRange"), [getSubRanges]("GI.Atk.Interfaces.Value#g:method:getSubRanges"), [getValueAndText]("GI.Atk.Interfaces.Value#g:method:getValueAndText").
    --
    -- ==== Setters
    -- [setCurrentValue]("GI.Atk.Interfaces.Value#g:method:setCurrentValue"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setValue]("GI.Atk.Interfaces.Value#g:method:setValue").

    #if defined(ENABLE_OVERLOADING)
        ResolveValueMethod                      ,
    #endif

    -- ** getCurrentValue #method:getCurrentValue#

    #if defined(ENABLE_OVERLOADING)
        ValueGetCurrentValueMethodInfo          ,
    #endif
        valueGetCurrentValue                    ,

    -- ** getIncrement #method:getIncrement#

    #if defined(ENABLE_OVERLOADING)
        ValueGetIncrementMethodInfo             ,
    #endif
        valueGetIncrement                       ,

    -- ** getMaximumValue #method:getMaximumValue#

    #if defined(ENABLE_OVERLOADING)
        ValueGetMaximumValueMethodInfo          ,
    #endif
        valueGetMaximumValue                    ,

    -- ** getMinimumIncrement #method:getMinimumIncrement#

    #if defined(ENABLE_OVERLOADING)
        ValueGetMinimumIncrementMethodInfo      ,
    #endif
        valueGetMinimumIncrement                ,

    -- ** getMinimumValue #method:getMinimumValue#

    #if defined(ENABLE_OVERLOADING)
        ValueGetMinimumValueMethodInfo          ,
    #endif
        valueGetMinimumValue                    ,

    -- ** getRange #method:getRange#

    #if defined(ENABLE_OVERLOADING)
        ValueGetRangeMethodInfo                 ,
    #endif
        valueGetRange                           ,

    -- ** getSubRanges #method:getSubRanges#

    #if defined(ENABLE_OVERLOADING)
        ValueGetSubRangesMethodInfo             ,
    #endif
        valueGetSubRanges                       ,

    -- ** getValueAndText #method:getValueAndText#

    #if defined(ENABLE_OVERLOADING)
        ValueGetValueAndTextMethodInfo          ,
    #endif
        valueGetValueAndText                    ,

    -- ** setCurrentValue #method:setCurrentValue#

    #if defined(ENABLE_OVERLOADING)
        ValueSetCurrentValueMethodInfo          ,
    #endif
        valueSetCurrentValue                    ,

    -- ** setValue #method:setValue#

    #if defined(ENABLE_OVERLOADING)
        ValueSetValueMethodInfo                 ,
    #endif
        valueSetValue                           ,

     -- * Signals

    -- ** valueChanged #signal:valueChanged#

        ValueValueChangedCallback               ,
    #if defined(ENABLE_OVERLOADING)
        ValueValueChangedSignalInfo             ,
    #endif
        afterValueValueChanged                  ,
        onValueValueChanged                     ,

        ) 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.Structs.Range as Atk.Range
    import qualified GI.GObject.Objects.Object as GObject.Object

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

    #endif

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

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

    foreign import ccall "atk_value_get_type"
        c_atk_value_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Value where
        glibType :: IO GType
    glibType = IO GType
    c_atk_value_get_type

    instance B.Types.GObject Value

    -- | Type class for types which can be safely cast to t'Value', for instance with `toValue`.
    class (SP.GObject o, O.IsDescendantOf Value o) => IsValue o
    instance (SP.GObject o, O.IsDescendantOf Value o) => IsValue o

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveValueMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveValueMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveValueMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveValueMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveValueMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveValueMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveValueMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveValueMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveValueMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveValueMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveValueMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveValueMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveValueMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveValueMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveValueMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveValueMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveValueMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveValueMethod "getCurrentValue" o = ValueGetCurrentValueMethodInfo
        ResolveValueMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveValueMethod "getIncrement" o = ValueGetIncrementMethodInfo
        ResolveValueMethod "getMaximumValue" o = ValueGetMaximumValueMethodInfo
        ResolveValueMethod "getMinimumIncrement" o = ValueGetMinimumIncrementMethodInfo
        ResolveValueMethod "getMinimumValue" o = ValueGetMinimumValueMethodInfo
        ResolveValueMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveValueMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveValueMethod "getRange" o = ValueGetRangeMethodInfo
        ResolveValueMethod "getSubRanges" o = ValueGetSubRangesMethodInfo
        ResolveValueMethod "getValueAndText" o = ValueGetValueAndTextMethodInfo
        ResolveValueMethod "setCurrentValue" o = ValueSetCurrentValueMethodInfo
        ResolveValueMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveValueMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveValueMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveValueMethod "setValue" o = ValueSetValueMethodInfo
        ResolveValueMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p) => OL.IsLabel t (Value -> 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 ~ ResolveValueMethod t Value, O.OverloadedMethod info Value p, R.HasField t Value p) => R.HasField t Value p where
        getField = O.overloadedMethod @info

    #endif

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

    #endif

    -- method Value::get_current_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TGValue
    --           , argCType = Just "GValue*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #GValue representing the current accessible value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_current_value" atk_value_get_current_value ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr GValue ->                           -- value : TGValue
        IO ()

    {-# DEPRECATED valueGetCurrentValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetValueAndText'","instead."] #-}
    -- | Gets the value of this object.
    valueGetCurrentValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m (GValue)
    valueGetCurrentValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m GValue
    valueGetCurrentValue a
    obj = IO GValue -> m GValue
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value <- SP.callocBytes 24 :: IO (Ptr GValue)
        atk_value_get_current_value obj' value
        value' <- B.GValue.wrapGValuePtr value
        touchManagedPtr obj
        return value'

    #if defined(ENABLE_OVERLOADING)
    data ValueGetCurrentValueMethodInfo
    instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetCurrentValueMethodInfo a signature where
        overloadedMethod = valueGetCurrentValue

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

    #endif

    -- method Value::get_increment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TDouble)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_increment" atk_value_get_increment ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        IO CDouble

    -- | Gets the minimum increment by which the value of this object may be
    -- changed.  If zero, the minimum increment is undefined, which may
    -- mean that it is limited only by the floating point precision of the
    -- platform.
    --
    -- /Since: 2.12/
    valueGetIncrement ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m Double
        -- ^ __Returns:__ the minimum increment by which the value of this
        -- object may be changed. zero if undefined.
    valueGetIncrement :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m Double
    valueGetIncrement a
    obj = IO Double -> m Double
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Double -> m Double) -> IO Double -> m Double
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        result <- atk_value_get_increment obj'
        let result' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    result
        touchManagedPtr obj
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ValueGetIncrementMethodInfo
    instance (signature ~ (m Double), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetIncrementMethodInfo a signature where
        overloadedMethod = valueGetIncrement

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

    #endif

    -- method Value::get_maximum_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TGValue
    --           , argCType = Just "GValue*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #GValue representing the maximum accessible value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_maximum_value" atk_value_get_maximum_value ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr GValue ->                           -- value : TGValue
        IO ()

    {-# DEPRECATED valueGetMaximumValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetRange' instead."] #-}
    -- | Gets the maximum value of this object.
    valueGetMaximumValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m (GValue)
    valueGetMaximumValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m GValue
    valueGetMaximumValue a
    obj = IO GValue -> m GValue
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value <- SP.callocBytes 24 :: IO (Ptr GValue)
        atk_value_get_maximum_value obj' value
        value' <- B.GValue.wrapGValuePtr value
        touchManagedPtr obj
        return value'

    #if defined(ENABLE_OVERLOADING)
    data ValueGetMaximumValueMethodInfo
    instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMaximumValueMethodInfo a signature where
        overloadedMethod = valueGetMaximumValue

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

    #endif

    -- method Value::get_minimum_increment
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TGValue
    --           , argCType = Just "GValue*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a #GValue representing the minimum increment by which the accessible value may be changed"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_minimum_increment" atk_value_get_minimum_increment ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr GValue ->                           -- value : TGValue
        IO ()

    {-# DEPRECATED valueGetMinimumIncrement ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetIncrement' instead."] #-}
    -- | Gets the minimum increment by which the value of this object may be changed.  If zero,
    -- the minimum increment is undefined, which may mean that it is limited only by the
    -- floating point precision of the platform.
    --
    -- /Since: 1.12/
    valueGetMinimumIncrement ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m (GValue)
    valueGetMinimumIncrement :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m GValue
    valueGetMinimumIncrement a
    obj = IO GValue -> m GValue
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value <- SP.callocBytes 24 :: IO (Ptr GValue)
        atk_value_get_minimum_increment obj' value
        value' <- B.GValue.wrapGValuePtr value
        touchManagedPtr obj
        return value'

    #if defined(ENABLE_OVERLOADING)
    data ValueGetMinimumIncrementMethodInfo
    instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMinimumIncrementMethodInfo a signature where
        overloadedMethod = valueGetMinimumIncrement

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

    #endif

    -- method Value::get_minimum_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TGValue
    --           , argCType = Just "GValue*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #GValue representing the minimum accessible value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = True
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_minimum_value" atk_value_get_minimum_value ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr GValue ->                           -- value : TGValue
        IO ()

    {-# DEPRECATED valueGetMinimumValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueGetRange' instead."] #-}
    -- | Gets the minimum value of this object.
    valueGetMinimumValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m (GValue)
    valueGetMinimumValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m GValue
    valueGetMinimumValue a
    obj = IO GValue -> m GValue
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value <- SP.callocBytes 24 :: IO (Ptr GValue)
        atk_value_get_minimum_value obj' value
        value' <- B.GValue.wrapGValuePtr value
        touchManagedPtr obj
        return value'

    #if defined(ENABLE_OVERLOADING)
    data ValueGetMinimumValueMethodInfo
    instance (signature ~ (m (GValue)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetMinimumValueMethodInfo a signature where
        overloadedMethod = valueGetMinimumValue

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

    #endif

    -- method Value::get_range
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Atk" , name = "Range" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_range" atk_value_get_range ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        IO (Ptr Atk.Range.Range)

    -- | Gets the range of this object.
    --
    -- /Since: 2.12/
    valueGetRange ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m (Maybe Atk.Range.Range)
        -- ^ __Returns:__ a newly allocated t'GI.Atk.Structs.Range.Range'
        -- that represents the minimum, maximum and descriptor (if available)
        -- of /@obj@/. NULL if that range is not defined.
    valueGetRange :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m (Maybe Range)
    valueGetRange a
    obj = IO (Maybe Range) -> m (Maybe Range)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Range) -> m (Maybe Range))
    -> IO (Maybe Range) -> m (Maybe Range)
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        result <- atk_value_get_range obj'
        maybeResult <- convertIfNonNull result $ \Ptr Range
    result' -> do
            result'' <- ((ManagedPtr Range -> Range) -> Ptr Range -> IO Range
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr Range -> Range
    Atk.Range.Range) Ptr Range
    result'
            return result''
        touchManagedPtr obj
        return maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ValueGetRangeMethodInfo
    instance (signature ~ (m (Maybe Atk.Range.Range)), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetRangeMethodInfo a signature where
        overloadedMethod = valueGetRange

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

    #endif

    -- method Value::get_sub_ranges
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TGSList (TInterface Name { namespace = "Atk" , name = "Range" }))
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_sub_ranges" atk_value_get_sub_ranges ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        IO (Ptr (GSList (Ptr Atk.Range.Range)))

    -- | Gets the list of subranges defined for this object. See t'GI.Atk.Interfaces.Value.Value'
    -- introduction for examples of subranges and when to expose them.
    --
    -- /Since: 2.12/
    valueGetSubRanges ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m [Atk.Range.Range]
        -- ^ __Returns:__ an t'GI.GLib.Structs.SList.SList' of
        -- t'GI.Atk.Structs.Range.Range' which each of the subranges defined for this object. Free
        -- the returns list with @/g_slist_free()/@.
    valueGetSubRanges :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m [Range]
    valueGetSubRanges a
    obj = IO [Range] -> m [Range]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [Range] -> m [Range]) -> IO [Range] -> m [Range]
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        result <- atk_value_get_sub_ranges obj'
        result' <- unpackGSList result
        result'' <- mapM (wrapBoxed Atk.Range.Range) result'
        g_slist_free result
        touchManagedPtr obj
        return result''

    #if defined(ENABLE_OVERLOADING)
    data ValueGetSubRangesMethodInfo
    instance (signature ~ (m [Atk.Range.Range]), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetSubRangesMethodInfo a signature where
        overloadedMethod = valueGetSubRanges

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

    #endif

    -- method Value::get_value_and_text
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "gdouble*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "address of #gdouble to put the current value of @obj"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "text"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "gchar**"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "address of #gchar to put the human\nreadable text alternative for @value"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_get_value_and_text" atk_value_get_value_and_text ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr CDouble ->                          -- value : TBasicType TDouble
        Ptr CString ->                          -- text : TBasicType TUTF8
        IO ()

    -- | Gets the current value and the human readable text alternative of
    -- /@obj@/. /@text@/ is a newly created string, that must be freed by the
    -- caller. Can be NULL if no descriptor is available.
    --
    -- /Since: 2.12/
    valueGetValueAndText ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> m ((Double, T.Text))
    valueGetValueAndText :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> m (Double, Text)
    valueGetValueAndText a
    obj = IO (Double, Text) -> m (Double, Text)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Double, Text) -> m (Double, Text))
    -> IO (Double, Text) -> m (Double, Text)
    forall a b. (a -> b) -> a -> b
    $ do
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value <- allocMem :: IO (Ptr CDouble)
        text <- callocMem :: IO (Ptr CString)
        atk_value_get_value_and_text obj' value text
        value' <- peek value
        let value'' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    value'
        text' <- peek text
        text'' <- cstringToText text'
        freeMem text'
        touchManagedPtr obj
        freeMem value
        freeMem text
        return (value'', text'')

    #if defined(ENABLE_OVERLOADING)
    data ValueGetValueAndTextMethodInfo
    instance (signature ~ (m ((Double, T.Text))), MonadIO m, IsValue a) => O.OverloadedMethod ValueGetValueAndTextMethodInfo a signature where
        overloadedMethod = valueGetValueAndText

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

    #endif

    -- method Value::set_current_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "value"
    --           , argType = TGValue
    --           , argCType = Just "const GValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a #GValue which is the desired new accessible value."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "atk_value_set_current_value" atk_value_set_current_value ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        Ptr GValue ->                           -- value : TGValue
        IO CInt

    {-# DEPRECATED valueSetCurrentValue ["Since 2.12. Use 'GI.Atk.Interfaces.Value.valueSetValue' instead."] #-}
    -- | Sets the value of this object.
    valueSetCurrentValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> GValue
        -- ^ /@value@/: a t'GI.GObject.Structs.Value.Value' which is the desired new accessible value.
        -> m Bool
        -- ^ __Returns:__ 'P.True' if new value is successfully set, 'P.False' otherwise.
    valueSetCurrentValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> GValue -> m Bool
    valueSetCurrentValue a
    obj GValue
    value = IO Bool -> m Bool
    forall a. IO a -> m a
    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
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        value' <- unsafeManagedPtrGetPtr value
        result <- atk_value_set_current_value obj' value'
        let result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= CInt
    0) CInt
    result
        touchManagedPtr obj
        touchManagedPtr value
        return result'

    #if defined(ENABLE_OVERLOADING)
    data ValueSetCurrentValueMethodInfo
    instance (signature ~ (GValue -> m Bool), MonadIO m, IsValue a) => O.OverloadedMethod ValueSetCurrentValueMethodInfo a signature where
        overloadedMethod = valueSetCurrentValue

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

    #endif

    -- method Value::set_value
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "obj"
    --           , argType = TInterface Name { namespace = "Atk" , name = "Value" }
    --           , argCType = Just "AtkValue*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a GObject instance that implements AtkValueIface"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "new_value"
    --           , argType = TBasicType TDouble
    --           , argCType = Just "const gdouble"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a double which is the desired new accessible value."
    --                 , 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_value_set_value" atk_value_set_value ::
        Ptr Value ->                            -- obj : TInterface (Name {namespace = "Atk", name = "Value"})
        CDouble ->                              -- new_value : TBasicType TDouble
        IO ()

    -- | Sets the value of this object.
    --
    -- This method is intended to provide a way to change the value of the
    -- object. In any case, it is possible that the value can\'t be
    -- modified (ie: a read-only component). If the value changes due this
    -- call, it is possible that the text could change, and will trigger
    -- an [Value::valueChanged]("GI.Atk.Interfaces.Value#g:signal:valueChanged") signal emission.
    --
    -- Note for implementors: the deprecated 'GI.Atk.Interfaces.Value.valueSetCurrentValue'
    -- method returned TRUE or FALSE depending if the value was assigned
    -- or not. In the practice several implementors were not able to
    -- decide it, and returned TRUE in any case. For that reason it is not
    -- required anymore to return if the value was properly assigned or
    -- not.
    --
    -- /Since: 2.12/
    valueSetValue ::
        (B.CallStack.HasCallStack, MonadIO m, IsValue a) =>
        a
        -- ^ /@obj@/: a GObject instance that implements AtkValueIface
        -> Double
        -- ^ /@newValue@/: a double which is the desired new accessible value.
        -> m ()
    valueSetValue :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsValue a) =>
    a -> Double -> m ()
    valueSetValue a
    obj Double
    newValue = 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
        obj' <- a -> IO (Ptr Value)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    obj
        let newValue' = Double -> CDouble
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac Double
    newValue
        atk_value_set_value obj' newValue'
        touchManagedPtr obj
        return ()

    #if defined(ENABLE_OVERLOADING)
    data ValueSetValueMethodInfo
    instance (signature ~ (Double -> m ()), MonadIO m, IsValue a) => O.OverloadedMethod ValueSetValueMethodInfo a signature where
        overloadedMethod = valueSetValue

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

    #endif

    -- signal Value::value-changed
    -- | The \'value-changed\' signal is emitted when the current value
    -- that represent the object changes. /@value@/ is the numerical
    -- representation of this new value.  /@text@/ is the human
    -- readable text alternative of /@value@/, and can be NULL if it is
    -- not available. Note that if there is a textual description
    -- associated with the new numeric value, that description
    -- should be included regardless of whether or not it has also
    -- changed.
    --
    -- Example: a password meter whose value changes as the user
    -- types their new password. Appropiate value text would be
    -- \"weak\", \"acceptable\" and \"strong\".
    --
    -- /Since: 2.12/
    type ValueValueChangedCallback =
        Double
        -- ^ /@value@/: the new value in a numerical form.
        -> T.Text
        -- ^ /@text@/: human readable text alternative (also called
        -- description) of this object. NULL if not available.
        -> IO ()

    type C_ValueValueChangedCallback =
        Ptr Value ->                            -- object
        CDouble ->
        CString ->
        Ptr () ->                               -- user_data
        IO ()

    -- | Generate a function pointer callable from C code, from a `C_ValueValueChangedCallback`.
    foreign import ccall "wrapper"
        mk_ValueValueChangedCallback :: C_ValueValueChangedCallback -> IO (FunPtr C_ValueValueChangedCallback)

    wrap_ValueValueChangedCallback ::
        GObject a => (a -> ValueValueChangedCallback) ->
        C_ValueValueChangedCallback
    wrap_ValueValueChangedCallback :: forall a.
    GObject a =>
    (a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
    wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
    gi'cb Ptr Value
    gi'selfPtr CDouble
    value CString
    text Ptr ()
    _ = do
        let value' :: Double
    value' = CDouble -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac CDouble
    value
        text' <- HasCallStack => CString -> IO Text
    CString -> IO Text
    cstringToText CString
    text
        B.ManagedPtr.withNewObject gi'selfPtr $ \Value
    gi'self -> a -> ValueValueChangedCallback
    gi'cb (Value -> a
    forall a b. Coercible a b => a -> b
    Coerce.coerce Value
    gi'self)  Double
    value' Text
    text'

    -- | Connect a signal handler for the [valueChanged](#signal:valueChanged) signal, to be run before the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.on' value #valueChanged callback
    -- @
    --
    --
    onValueValueChanged :: (IsValue a, MonadIO m) => a -> ((?self :: a) => ValueValueChangedCallback) -> m SignalHandlerId
    onValueValueChanged :: forall a (m :: * -> *).
    (IsValue a, MonadIO m) =>
    a -> ((?self::a) => ValueValueChangedCallback) -> m SignalHandlerId
    onValueValueChanged a
    obj (?self::a) => ValueValueChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ValueValueChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ValueValueChangedCallback
    ValueValueChangedCallback
    cb
        let wrapped' :: C_ValueValueChangedCallback
    wrapped' = (a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
    forall a.
    GObject a =>
    (a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
    wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
    wrapped
        wrapped'' <- C_ValueValueChangedCallback
    -> IO (FunPtr C_ValueValueChangedCallback)
    mk_ValueValueChangedCallback C_ValueValueChangedCallback
    wrapped'
        connectSignalFunPtr obj "value-changed" wrapped'' SignalConnectBefore Nothing

    -- | Connect a signal handler for the [valueChanged](#signal:valueChanged) signal, to be run after the default handler.
    -- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
    --
    -- @
    -- 'Data.GI.Base.Signals.after' value #valueChanged callback
    -- @
    --
    --
    --
    -- By default the object invoking the signal is not passed to the callback.
    -- If you need to access it, you can use the implit @?self@ parameter.
    -- Note that this requires activating the @ImplicitParams@ GHC extension.
    --
    afterValueValueChanged :: (IsValue a, MonadIO m) => a -> ((?self :: a) => ValueValueChangedCallback) -> m SignalHandlerId
    afterValueValueChanged :: forall a (m :: * -> *).
    (IsValue a, MonadIO m) =>
    a -> ((?self::a) => ValueValueChangedCallback) -> m SignalHandlerId
    afterValueValueChanged a
    obj (?self::a) => ValueValueChangedCallback
    cb = IO SignalHandlerId -> m SignalHandlerId
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO SignalHandlerId -> m SignalHandlerId)
    -> IO SignalHandlerId -> m SignalHandlerId
    forall a b. (a -> b) -> a -> b
    $ do
        let wrapped :: a -> ValueValueChangedCallback
    wrapped a
    self = let ?self = a
    ?self::a
    self in (?self::a) => ValueValueChangedCallback
    ValueValueChangedCallback
    cb
        let wrapped' :: C_ValueValueChangedCallback
    wrapped' = (a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
    forall a.
    GObject a =>
    (a -> ValueValueChangedCallback) -> C_ValueValueChangedCallback
    wrap_ValueValueChangedCallback a -> ValueValueChangedCallback
    wrapped
        wrapped'' <- C_ValueValueChangedCallback
    -> IO (FunPtr C_ValueValueChangedCallback)
    mk_ValueValueChangedCallback C_ValueValueChangedCallback
    wrapped'
        connectSignalFunPtr obj "value-changed" wrapped'' SignalConnectAfter Nothing

    #if defined(ENABLE_OVERLOADING)
    data ValueValueChangedSignalInfo
    instance SignalInfo ValueValueChangedSignalInfo where
        type HaskellCallbackType ValueValueChangedSignalInfo = ValueValueChangedCallback
        connectSignal obj cb connectMode detail = do
            let cb' = wrap_ValueValueChangedCallback cb
            cb'' <- mk_ValueValueChangedCallback cb'
            connectSignalFunPtr obj "value-changed" cb'' connectMode detail
        dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Atk.Interfaces.Value::value-changed"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-atk-2.0.28/docs/GI-Atk-Interfaces-Value.html#g:signal:valueChanged"})

    #endif

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

    #endif