    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A @PangoCoverage@ structure is a map from Unicode characters
    -- to t'GI.Pango.Enums.CoverageLevel' values.
    --
    -- It is often necessary in Pango to determine if a particular
    -- font can represent a particular character, and also how well
    -- it can represent that character. The @PangoCoverage@ is a data
    -- structure that is used to represent that information. It is an
    -- opaque structure with no public fields.

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

    module GI.Pango.Objects.Coverage
        (

    -- * Exported types
        Coverage(..)                            ,
        IsCoverage                              ,
        toCoverage                              ,

     -- * 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"), [copy]("GI.Pango.Objects.Coverage#g:method:copy"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [get]("GI.Pango.Objects.Coverage#g:method:get"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [max]("GI.Pango.Objects.Coverage#g:method:max"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.Pango.Objects.Coverage#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [set]("GI.Pango.Objects.Coverage#g:method:set"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [toBytes]("GI.Pango.Objects.Coverage#g:method:toBytes"), [unref]("GI.Pango.Objects.Coverage#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
    --
    -- ==== Getters
    -- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
    --
    -- ==== Setters
    -- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

    #if defined(ENABLE_OVERLOADING)
        ResolveCoverageMethod                   ,
    #endif

    -- ** copy #method:copy#

    #if defined(ENABLE_OVERLOADING)
        CoverageCopyMethodInfo                  ,
    #endif
        coverageCopy                            ,

    -- ** fromBytes #method:fromBytes#

        coverageFromBytes                       ,

    -- ** get #method:get#

    #if defined(ENABLE_OVERLOADING)
        CoverageGetMethodInfo                   ,
    #endif
        coverageGet                             ,

    -- ** max #method:max#

    #if defined(ENABLE_OVERLOADING)
        CoverageMaxMethodInfo                   ,
    #endif
        coverageMax                             ,

    -- ** new #method:new#

        coverageNew                             ,

    -- ** ref #method:ref#

    #if defined(ENABLE_OVERLOADING)
        CoverageRefMethodInfo                   ,
    #endif
        coverageRef                             ,

    -- ** set #method:set#

    #if defined(ENABLE_OVERLOADING)
        CoverageSetMethodInfo                   ,
    #endif
        coverageSet                             ,

    -- ** toBytes #method:toBytes#

    #if defined(ENABLE_OVERLOADING)
        CoverageToBytesMethodInfo               ,
    #endif
        coverageToBytes                         ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        CoverageUnrefMethodInfo                 ,
    #endif
        coverageUnref                           ,

        ) 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 GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums

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

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

    foreign import ccall "pango_coverage_get_type"
        c_pango_coverage_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Coverage where
        glibType :: IO GType
    glibType = IO GType
    c_pango_coverage_get_type

    instance B.Types.GObject Coverage

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

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

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

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

    #if defined(ENABLE_OVERLOADING)
    type family ResolveCoverageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveCoverageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveCoverageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveCoverageMethod "copy" o = CoverageCopyMethodInfo
        ResolveCoverageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveCoverageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveCoverageMethod "get" o = CoverageGetMethodInfo
        ResolveCoverageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveCoverageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveCoverageMethod "max" o = CoverageMaxMethodInfo
        ResolveCoverageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveCoverageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveCoverageMethod "ref" o = CoverageRefMethodInfo
        ResolveCoverageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveCoverageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveCoverageMethod "set" o = CoverageSetMethodInfo
        ResolveCoverageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveCoverageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveCoverageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveCoverageMethod "toBytes" o = CoverageToBytesMethodInfo
        ResolveCoverageMethod "unref" o = CoverageUnrefMethodInfo
        ResolveCoverageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveCoverageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveCoverageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveCoverageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveCoverageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveCoverageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveCoverageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveCoverageMethod l o = O.MethodResolutionFailed l o

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

    #endif

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

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    #endif

    -- method Coverage::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Coverage" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_new" pango_coverage_new ::
        IO (Ptr Coverage)

    -- | Create a new @PangoCoverage@
    coverageNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Coverage
        -- ^ __Returns:__ the newly allocated @PangoCoverage@, initialized
        --   to 'GI.Pango.Enums.CoverageLevelNone' with a reference count of one, which
        --   should be freed with 'GI.Pango.Objects.Coverage.coverageUnref'.
    coverageNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Coverage
    coverageNew  = IO Coverage -> m Coverage
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Coverage -> m Coverage) -> IO Coverage -> m Coverage
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    result <- IO (Ptr Coverage)
    pango_coverage_new
        Text -> Ptr Coverage -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "coverageNew" Ptr Coverage
    result
        Coverage
    result' <- ((ManagedPtr Coverage -> Coverage) -> Ptr Coverage -> IO Coverage
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Coverage -> Coverage
    Coverage) Ptr Coverage
    result
        Coverage -> IO Coverage
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Coverage
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Coverage::copy
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Coverage" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_copy" pango_coverage_copy ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        IO (Ptr Coverage)

    -- | Copy an existing @PangoCoverage@.
    coverageCopy ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> m Coverage
        -- ^ __Returns:__ the newly allocated @PangoCoverage@,
        --   with a reference count of one, which should be freed with
        --   'GI.Pango.Objects.Coverage.coverageUnref'.
    coverageCopy :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> m Coverage
    coverageCopy a
    coverage = IO Coverage -> m Coverage
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Coverage -> m Coverage) -> IO Coverage -> m Coverage
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        Ptr Coverage
    result <- Ptr Coverage -> IO (Ptr Coverage)
    pango_coverage_copy Ptr Coverage
    coverage'
        Text -> Ptr Coverage -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "coverageCopy" Ptr Coverage
    result
        Coverage
    result' <- ((ManagedPtr Coverage -> Coverage) -> Ptr Coverage -> IO Coverage
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Coverage -> Coverage
    Coverage) Ptr Coverage
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        Coverage -> IO Coverage
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Coverage
    result'

    #if defined(ENABLE_OVERLOADING)
    data CoverageCopyMethodInfo
    instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageCopyMethodInfo a signature where
        overloadedMethod = coverageCopy

    instance O.OverloadedMethodInfo CoverageCopyMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageCopy",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageCopy"
            })

    #endif

    -- method Coverage::get
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the index to check" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "CoverageLevel" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_get" pango_coverage_get ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        Int32 ->                                -- index_ : TBasicType TInt
        IO CUInt

    -- | Determine whether a particular index is covered by /@coverage@/.
    coverageGet ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> Int32
        -- ^ /@index_@/: the index to check
        -> m Pango.Enums.CoverageLevel
        -- ^ __Returns:__ the coverage level of /@coverage@/ for character /@index_@/.
    coverageGet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> Int32 -> m CoverageLevel
    coverageGet a
    coverage Int32
    index_ = IO CoverageLevel -> m CoverageLevel
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO CoverageLevel -> m CoverageLevel)
    -> IO CoverageLevel -> m CoverageLevel
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        CUInt
    result <- Ptr Coverage -> Int32 -> IO CUInt
    pango_coverage_get Ptr Coverage
    coverage' Int32
    index_
        let result' :: CoverageLevel
    result' = (Int -> CoverageLevel
    forall a. Enum a => Int -> a
    toEnum (Int -> CoverageLevel) -> (CUInt -> Int) -> CUInt -> CoverageLevel
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        CoverageLevel -> IO CoverageLevel
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CoverageLevel
    result'

    #if defined(ENABLE_OVERLOADING)
    data CoverageGetMethodInfo
    instance (signature ~ (Int32 -> m Pango.Enums.CoverageLevel), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageGetMethodInfo a signature where
        overloadedMethod = coverageGet

    instance O.OverloadedMethodInfo CoverageGetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageGet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageGet"
            })

    #endif

    -- method Coverage::max
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "other"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "another `PangoCoverage`"
    --                 , 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 "pango_coverage_max" pango_coverage_max ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        Ptr Coverage ->                         -- other : TInterface (Name {namespace = "Pango", name = "Coverage"})
        IO ()

    {-# DEPRECATED coverageMax ["(Since version 1.44)","This function does nothing"] #-}
    -- | Set the coverage for each index in /@coverage@/ to be the max (better)
    -- value of the current coverage for the index and the coverage for
    -- the corresponding index in /@other@/.
    coverageMax ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> b
        -- ^ /@other@/: another @PangoCoverage@
        -> m ()
    coverageMax :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsCoverage a, IsCoverage b) =>
    a -> b -> m ()
    coverageMax a
    coverage b
    other = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        Ptr Coverage
    other' <- b -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    other
        Ptr Coverage -> Ptr Coverage -> IO ()
    pango_coverage_max Ptr Coverage
    coverage' Ptr Coverage
    other'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr b
    other
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data CoverageMaxMethodInfo
    instance (signature ~ (b -> m ()), MonadIO m, IsCoverage a, IsCoverage b) => O.OverloadedMethod CoverageMaxMethodInfo a signature where
        overloadedMethod = coverageMax

    instance O.OverloadedMethodInfo CoverageMaxMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageMax",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageMax"
            })

    #endif

    -- method Coverage::ref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Coverage" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_ref" pango_coverage_ref ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        IO (Ptr Coverage)

    {-# DEPRECATED coverageRef ["(Since version 1.52)","Use g_object_ref instead"] #-}
    -- | Increase the reference count on the @PangoCoverage@ by one.
    coverageRef ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> m Coverage
        -- ^ __Returns:__ /@coverage@/
    coverageRef :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> m Coverage
    coverageRef a
    coverage = IO Coverage -> m Coverage
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Coverage -> m Coverage) -> IO Coverage -> m Coverage
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        Ptr Coverage
    result <- Ptr Coverage -> IO (Ptr Coverage)
    pango_coverage_ref Ptr Coverage
    coverage'
        Text -> Ptr Coverage -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "coverageRef" Ptr Coverage
    result
        Coverage
    result' <- ((ManagedPtr Coverage -> Coverage) -> Ptr Coverage -> IO Coverage
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Coverage -> Coverage
    Coverage) Ptr Coverage
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        Coverage -> IO Coverage
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Coverage
    result'

    #if defined(ENABLE_OVERLOADING)
    data CoverageRefMethodInfo
    instance (signature ~ (m Coverage), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageRefMethodInfo a signature where
        overloadedMethod = coverageRef

    instance O.OverloadedMethodInfo CoverageRefMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageRef",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageRef"
            })

    #endif

    -- method Coverage::set
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "index_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the index to modify"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "level"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "CoverageLevel" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new level for @index_"
    --                 , 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 "pango_coverage_set" pango_coverage_set ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        Int32 ->                                -- index_ : TBasicType TInt
        CUInt ->                                -- level : TInterface (Name {namespace = "Pango", name = "CoverageLevel"})
        IO ()

    -- | Modify a particular index within /@coverage@/
    coverageSet ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> Int32
        -- ^ /@index_@/: the index to modify
        -> Pango.Enums.CoverageLevel
        -- ^ /@level@/: the new level for /@index_@/
        -> m ()
    coverageSet :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> Int32 -> CoverageLevel -> m ()
    coverageSet a
    coverage Int32
    index_ CoverageLevel
    level = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        let level' :: CUInt
    level' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (CoverageLevel -> Int) -> CoverageLevel -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CoverageLevel -> Int
    forall a. Enum a => a -> Int
    fromEnum) CoverageLevel
    level
        Ptr Coverage -> Int32 -> CUInt -> IO ()
    pango_coverage_set Ptr Coverage
    coverage' Int32
    index_ CUInt
    level'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data CoverageSetMethodInfo
    instance (signature ~ (Int32 -> Pango.Enums.CoverageLevel -> m ()), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageSetMethodInfo a signature where
        overloadedMethod = coverageSet

    instance O.OverloadedMethodInfo CoverageSetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageSet",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageSet"
            })

    #endif

    -- method Coverage::to_bytes
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "bytes"
    --           , argType = TCArray False (-1) 2 (TBasicType TUInt8)
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "\n  location to store result (must be freed with g_free())"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "n_bytes"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "location to store size of result"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_bytes"
    --              , argType = TBasicType TInt
    --              , direction = DirectionOut
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "location to store size of result"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferEverything
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_to_bytes" pango_coverage_to_bytes ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        Ptr (Ptr Word8) ->                      -- bytes : TCArray False (-1) 2 (TBasicType TUInt8)
        Ptr Int32 ->                            -- n_bytes : TBasicType TInt
        IO ()

    {-# DEPRECATED coverageToBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
    -- | Convert a @PangoCoverage@ structure into a flat binary format.
    coverageToBytes ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> m (ByteString)
    coverageToBytes :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> m ByteString
    coverageToBytes a
    coverage = IO ByteString -> m ByteString
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    coverage
        Ptr (Ptr Word8)
    bytes <- IO (Ptr (Ptr Word8))
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr (Ptr Word8))
        Ptr Int32
    nBytes <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr Coverage -> Ptr (Ptr Word8) -> Ptr Int32 -> IO ()
    pango_coverage_to_bytes Ptr Coverage
    coverage' Ptr (Ptr Word8)
    bytes Ptr Int32
    nBytes
        Int32
    nBytes' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    nBytes
        Ptr Word8
    bytes' <- Ptr (Ptr Word8) -> IO (Ptr Word8)
    forall a. Storable a => Ptr a -> IO a
    peek Ptr (Ptr Word8)
    bytes
        ByteString
    bytes'' <- (Int32 -> Ptr Word8 -> IO ByteString
    forall a. Integral a => a -> Ptr Word8 -> IO ByteString
    unpackByteStringWithLength Int32
    nBytes') Ptr Word8
    bytes'
        Ptr Word8 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Word8
    bytes'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        Ptr (Ptr Word8) -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr (Ptr Word8)
    bytes
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    nBytes
        ByteString -> IO ByteString
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ByteString
    bytes''

    #if defined(ENABLE_OVERLOADING)
    data CoverageToBytesMethodInfo
    instance (signature ~ (m (ByteString)), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageToBytesMethodInfo a signature where
        overloadedMethod = coverageToBytes

    instance O.OverloadedMethodInfo CoverageToBytesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageToBytes",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageToBytes"
            })

    #endif

    -- method Coverage::unref
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "coverage"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Coverage" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoCoverage`" , 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 "pango_coverage_unref" pango_coverage_unref ::
        Ptr Coverage ->                         -- coverage : TInterface (Name {namespace = "Pango", name = "Coverage"})
        IO ()

    {-# DEPRECATED coverageUnref ["(Since version 1.52)","Use g_object_unref instead"] #-}
    -- | Decrease the reference count on the @PangoCoverage@ by one.
    --
    -- If the result is zero, free the coverage and all associated memory.
    coverageUnref ::
        (B.CallStack.HasCallStack, MonadIO m, IsCoverage a) =>
        a
        -- ^ /@coverage@/: a @PangoCoverage@
        -> m ()
    coverageUnref :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsCoverage a) =>
    a -> m ()
    coverageUnref a
    coverage = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Coverage
    coverage' <- a -> IO (Ptr Coverage)
    forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
    B.ManagedPtr.disownObject a
    coverage
        Ptr Coverage -> IO ()
    pango_coverage_unref Ptr Coverage
    coverage'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    coverage
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data CoverageUnrefMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsCoverage a) => O.OverloadedMethod CoverageUnrefMethodInfo a signature where
        overloadedMethod = coverageUnref

    instance O.OverloadedMethodInfo CoverageUnrefMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Coverage.coverageUnref",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.29/docs/GI-Pango-Objects-Coverage.html#v:coverageUnref"
            })

    #endif

    -- method Coverage::from_bytes
    -- method type : MemberFunction
    -- Args: [ Arg
    --           { argCName = "bytes"
    --           , argType = TCArray False (-1) 1 (TBasicType TUInt8)
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "binary data\n  representing a `PangoCoverage`"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "n_bytes"
    --           , argType = TBasicType TInt
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the size of @bytes in bytes"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_bytes"
    --              , argType = TBasicType TInt
    --              , direction = DirectionIn
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText = Just "the size of @bytes in bytes"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferNothing
    --              }
    --          ]
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Coverage" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_coverage_from_bytes" pango_coverage_from_bytes ::
        Ptr Word8 ->                            -- bytes : TCArray False (-1) 1 (TBasicType TUInt8)
        Int32 ->                                -- n_bytes : TBasicType TInt
        IO (Ptr Coverage)

    {-# DEPRECATED coverageFromBytes ["(Since version 1.44)","This returns 'P.Nothing'"] #-}
    -- | Convert data generated from 'GI.Pango.Objects.Coverage.coverageToBytes'
    -- back to a @PangoCoverage@.
    coverageFromBytes ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        ByteString
        -- ^ /@bytes@/: binary data
        --   representing a @PangoCoverage@
        -> m (Maybe Coverage)
        -- ^ __Returns:__ a newly allocated @PangoCoverage@
    coverageFromBytes :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    ByteString -> m (Maybe Coverage)
    coverageFromBytes ByteString
    bytes = IO (Maybe Coverage) -> m (Maybe Coverage)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Coverage) -> m (Maybe Coverage))
    -> IO (Maybe Coverage) -> m (Maybe Coverage)
    forall a b. (a -> b) -> a -> b
    $ do
        let nBytes :: Int32
    nBytes = Int -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int32) -> Int -> Int32
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Int
    B.length ByteString
    bytes
        Ptr Word8
    bytes' <- ByteString -> IO (Ptr Word8)
    packByteString ByteString
    bytes
        Ptr Coverage
    result <- Ptr Word8 -> Int32 -> IO (Ptr Coverage)
    pango_coverage_from_bytes Ptr Word8
    bytes' Int32
    nBytes
        Maybe Coverage
    maybeResult <- Ptr Coverage
    -> (Ptr Coverage -> IO Coverage) -> IO (Maybe Coverage)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Coverage
    result ((Ptr Coverage -> IO Coverage) -> IO (Maybe Coverage))
    -> (Ptr Coverage -> IO Coverage) -> IO (Maybe Coverage)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Coverage
    result' -> do
            Coverage
    result'' <- ((ManagedPtr Coverage -> Coverage) -> Ptr Coverage -> IO Coverage
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Coverage -> Coverage
    Coverage) Ptr Coverage
    result'
            Coverage -> IO Coverage
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Coverage
    result''
        Ptr Word8 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Word8
    bytes'
        Maybe Coverage -> IO (Maybe Coverage)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Coverage
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    #endif