{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A GParamSpec derived structure that contains the meta data for fractional
-- properties.

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

module GI.Gst.Structs.ParamSpecFraction
    ( 

-- * Exported types
    ParamSpecFraction(..)                   ,
    newZeroParamSpecFraction                ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveParamSpecFractionMethod          ,
#endif



 -- * Properties


-- ** defDen #attr:defDen#
-- | default denominator

    getParamSpecFractionDefDen              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_defDen                ,
#endif
    setParamSpecFractionDefDen              ,


-- ** defNum #attr:defNum#
-- | default numerator

    getParamSpecFractionDefNum              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_defNum                ,
#endif
    setParamSpecFractionDefNum              ,


-- ** maxDen #attr:maxDen#
-- | maximal denominator

    getParamSpecFractionMaxDen              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_maxDen                ,
#endif
    setParamSpecFractionMaxDen              ,


-- ** maxNum #attr:maxNum#
-- | maximal numerator

    getParamSpecFractionMaxNum              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_maxNum                ,
#endif
    setParamSpecFractionMaxNum              ,


-- ** minDen #attr:minDen#
-- | minimal denominator

    getParamSpecFractionMinDen              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_minDen                ,
#endif
    setParamSpecFractionMinDen              ,


-- ** minNum #attr:minNum#
-- | minimal numerator

    getParamSpecFractionMinNum              ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_minNum                ,
#endif
    setParamSpecFractionMinNum              ,


-- ** parentInstance #attr:parentInstance#
-- | super class

    clearParamSpecFractionParentInstance    ,
    getParamSpecFractionParentInstance      ,
#if defined(ENABLE_OVERLOADING)
    paramSpecFraction_parentInstance        ,
#endif
    setParamSpecFractionParentInstance      ,




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


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

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

instance BoxedPtr ParamSpecFraction where
    boxedPtrCopy :: ParamSpecFraction -> IO ParamSpecFraction
boxedPtrCopy = \ParamSpecFraction
p -> ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> IO ParamSpecFraction
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ParamSpecFraction
p (Int -> Ptr ParamSpecFraction -> IO (Ptr ParamSpecFraction)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
96 (Ptr ParamSpecFraction -> IO (Ptr ParamSpecFraction))
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> Ptr ParamSpecFraction
-> IO ParamSpecFraction
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> Ptr ParamSpecFraction -> IO ParamSpecFraction
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr ParamSpecFraction -> ParamSpecFraction
ParamSpecFraction)
    boxedPtrFree :: ParamSpecFraction -> IO ()
boxedPtrFree = \ParamSpecFraction
x -> ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ParamSpecFraction
x Ptr ParamSpecFraction -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ParamSpecFraction where
    boxedPtrCalloc :: IO (Ptr ParamSpecFraction)
boxedPtrCalloc = Int -> IO (Ptr ParamSpecFraction)
forall a. Int -> IO (Ptr a)
callocBytes Int
96


-- | Construct a `ParamSpecFraction` struct initialized to zero.
newZeroParamSpecFraction :: MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction :: forall (m :: * -> *). MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction = IO ParamSpecFraction -> m ParamSpecFraction
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ParamSpecFraction -> m ParamSpecFraction)
-> IO ParamSpecFraction -> m ParamSpecFraction
forall a b. (a -> b) -> a -> b
$ IO (Ptr ParamSpecFraction)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr ParamSpecFraction)
-> (Ptr ParamSpecFraction -> IO ParamSpecFraction)
-> IO ParamSpecFraction
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> Ptr ParamSpecFraction -> IO ParamSpecFraction
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr ParamSpecFraction -> ParamSpecFraction
ParamSpecFraction

instance tag ~ 'AttrSet => Constructible ParamSpecFraction tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ParamSpecFraction -> ParamSpecFraction)
-> [AttrOp ParamSpecFraction tag] -> m ParamSpecFraction
new ManagedPtr ParamSpecFraction -> ParamSpecFraction
_ [AttrOp ParamSpecFraction tag]
attrs = do
        ParamSpecFraction
o <- m ParamSpecFraction
forall (m :: * -> *). MonadIO m => m ParamSpecFraction
newZeroParamSpecFraction
        ParamSpecFraction -> [AttrOp ParamSpecFraction 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ParamSpecFraction
o [AttrOp ParamSpecFraction tag]
[AttrOp ParamSpecFraction 'AttrSet]
attrs
        ParamSpecFraction -> m ParamSpecFraction
forall (m :: * -> *) a. Monad m => a -> m a
return ParamSpecFraction
o


-- | Get the value of the “@parent_instance@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #parentInstance
-- @
getParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> m (Maybe GParamSpec)
getParamSpecFractionParentInstance :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> m (Maybe GParamSpec)
getParamSpecFractionParentInstance ParamSpecFraction
s = IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe GParamSpec) -> m (Maybe GParamSpec))
-> IO (Maybe GParamSpec) -> m (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
-> IO (Maybe GParamSpec)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
 -> IO (Maybe GParamSpec))
-> (Ptr ParamSpecFraction -> IO (Maybe GParamSpec))
-> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr GParamSpec
val <- Ptr (Ptr GParamSpec) -> IO (Ptr GParamSpec)
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr GParamSpec)
    Maybe GParamSpec
result <- Ptr GParamSpec
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr GParamSpec
val ((Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec))
-> (Ptr GParamSpec -> IO GParamSpec) -> IO (Maybe GParamSpec)
forall a b. (a -> b) -> a -> b
$ \Ptr GParamSpec
val' -> do
        GParamSpec
val'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
val'
        GParamSpec -> IO GParamSpec
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
val''
    Maybe GParamSpec -> IO (Maybe GParamSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GParamSpec
result

-- | Set the value of the “@parent_instance@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #parentInstance 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> Ptr GParamSpec -> m ()
setParamSpecFractionParentInstance :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Ptr GParamSpec -> m ()
setParamSpecFractionParentInstance ParamSpecFraction
s Ptr GParamSpec
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
val :: Ptr GParamSpec)

-- | Set the value of the “@parent_instance@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #parentInstance
-- @
clearParamSpecFractionParentInstance :: MonadIO m => ParamSpecFraction -> m ()
clearParamSpecFractionParentInstance :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m ()
clearParamSpecFractionParentInstance ParamSpecFraction
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr (Ptr GParamSpec) -> Ptr GParamSpec -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr (Ptr GParamSpec)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr GParamSpec
forall a. Ptr a
FP.nullPtr :: Ptr GParamSpec)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionParentInstanceFieldInfo
instance AttrInfo ParamSpecFractionParentInstanceFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionParentInstanceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~) (Ptr GParamSpec)
    type AttrTransferTypeConstraint ParamSpecFractionParentInstanceFieldInfo = (~)(Ptr GParamSpec)
    type AttrTransferType ParamSpecFractionParentInstanceFieldInfo = (Ptr GParamSpec)
    type AttrGetType ParamSpecFractionParentInstanceFieldInfo = Maybe GParamSpec
    type AttrLabel ParamSpecFractionParentInstanceFieldInfo = "parent_instance"
    type AttrOrigin ParamSpecFractionParentInstanceFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionParentInstance
    attrSet = setParamSpecFractionParentInstance
    attrConstruct = undefined
    attrClear = clearParamSpecFractionParentInstance
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.parentInstance"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:parentInstance"
        })

paramSpecFraction_parentInstance :: AttrLabelProxy "parentInstance"
paramSpecFraction_parentInstance = AttrLabelProxy

#endif


-- | Get the value of the “@min_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #minNum
-- @
getParamSpecFractionMinNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinNum ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@min_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #minNum 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionMinNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinNum ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
72) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMinNumFieldInfo
instance AttrInfo ParamSpecFractionMinNumFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionMinNumFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionMinNumFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionMinNumFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionMinNumFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionMinNumFieldInfo = Int32
    type AttrGetType ParamSpecFractionMinNumFieldInfo = Int32
    type AttrLabel ParamSpecFractionMinNumFieldInfo = "min_num"
    type AttrOrigin ParamSpecFractionMinNumFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionMinNum
    attrSet = setParamSpecFractionMinNum
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.minNum"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:minNum"
        })

paramSpecFraction_minNum :: AttrLabelProxy "minNum"
paramSpecFraction_minNum = AttrLabelProxy

#endif


-- | Get the value of the “@min_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #minDen
-- @
getParamSpecFractionMinDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMinDen ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
76) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@min_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #minDen 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionMinDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMinDen ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
76) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMinDenFieldInfo
instance AttrInfo ParamSpecFractionMinDenFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionMinDenFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionMinDenFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionMinDenFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionMinDenFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionMinDenFieldInfo = Int32
    type AttrGetType ParamSpecFractionMinDenFieldInfo = Int32
    type AttrLabel ParamSpecFractionMinDenFieldInfo = "min_den"
    type AttrOrigin ParamSpecFractionMinDenFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionMinDen
    attrSet = setParamSpecFractionMinDen
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.minDen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:minDen"
        })

paramSpecFraction_minDen :: AttrLabelProxy "minDen"
paramSpecFraction_minDen = AttrLabelProxy

#endif


-- | Get the value of the “@max_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #maxNum
-- @
getParamSpecFractionMaxNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxNum ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@max_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #maxNum 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionMaxNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxNum ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
80) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMaxNumFieldInfo
instance AttrInfo ParamSpecFractionMaxNumFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionMaxNumFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionMaxNumFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionMaxNumFieldInfo = Int32
    type AttrGetType ParamSpecFractionMaxNumFieldInfo = Int32
    type AttrLabel ParamSpecFractionMaxNumFieldInfo = "max_num"
    type AttrOrigin ParamSpecFractionMaxNumFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionMaxNum
    attrSet = setParamSpecFractionMaxNum
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.maxNum"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:maxNum"
        })

paramSpecFraction_maxNum :: AttrLabelProxy "maxNum"
paramSpecFraction_maxNum = AttrLabelProxy

#endif


-- | Get the value of the “@max_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #maxDen
-- @
getParamSpecFractionMaxDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionMaxDen ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
84) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@max_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #maxDen 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionMaxDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionMaxDen ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
84) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionMaxDenFieldInfo
instance AttrInfo ParamSpecFractionMaxDenFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionMaxDenFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionMaxDenFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionMaxDenFieldInfo = Int32
    type AttrGetType ParamSpecFractionMaxDenFieldInfo = Int32
    type AttrLabel ParamSpecFractionMaxDenFieldInfo = "max_den"
    type AttrOrigin ParamSpecFractionMaxDenFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionMaxDen
    attrSet = setParamSpecFractionMaxDen
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.maxDen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:maxDen"
        })

paramSpecFraction_maxDen :: AttrLabelProxy "maxDen"
paramSpecFraction_maxDen = AttrLabelProxy

#endif


-- | Get the value of the “@def_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #defNum
-- @
getParamSpecFractionDefNum :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefNum :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefNum ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@def_num@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #defNum 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionDefNum :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefNum :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefNum ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
88) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionDefNumFieldInfo
instance AttrInfo ParamSpecFractionDefNumFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionDefNumFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionDefNumFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionDefNumFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionDefNumFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionDefNumFieldInfo = Int32
    type AttrGetType ParamSpecFractionDefNumFieldInfo = Int32
    type AttrLabel ParamSpecFractionDefNumFieldInfo = "def_num"
    type AttrOrigin ParamSpecFractionDefNumFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionDefNum
    attrSet = setParamSpecFractionDefNum
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.defNum"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:defNum"
        })

paramSpecFraction_defNum :: AttrLabelProxy "defNum"
paramSpecFraction_defNum = AttrLabelProxy

#endif


-- | Get the value of the “@def_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' paramSpecFraction #defDen
-- @
getParamSpecFractionDefDen :: MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefDen :: forall (m :: * -> *). MonadIO m => ParamSpecFraction -> m Int32
getParamSpecFractionDefDen ParamSpecFraction
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO Int32) -> IO Int32)
-> (Ptr ParamSpecFraction -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
92) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@def_den@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' paramSpecFraction [ #defDen 'Data.GI.Base.Attributes.:=' value ]
-- @
setParamSpecFractionDefDen :: MonadIO m => ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefDen :: forall (m :: * -> *).
MonadIO m =>
ParamSpecFraction -> Int32 -> m ()
setParamSpecFractionDefDen ParamSpecFraction
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ParamSpecFraction -> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ParamSpecFraction
s ((Ptr ParamSpecFraction -> IO ()) -> IO ())
-> (Ptr ParamSpecFraction -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ParamSpecFraction
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ParamSpecFraction
ptr Ptr ParamSpecFraction -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
92) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ParamSpecFractionDefDenFieldInfo
instance AttrInfo ParamSpecFractionDefDenFieldInfo where
    type AttrBaseTypeConstraint ParamSpecFractionDefDenFieldInfo = (~) ParamSpecFraction
    type AttrAllowedOps ParamSpecFractionDefDenFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ParamSpecFractionDefDenFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ParamSpecFractionDefDenFieldInfo = (~)Int32
    type AttrTransferType ParamSpecFractionDefDenFieldInfo = Int32
    type AttrGetType ParamSpecFractionDefDenFieldInfo = Int32
    type AttrLabel ParamSpecFractionDefDenFieldInfo = "def_den"
    type AttrOrigin ParamSpecFractionDefDenFieldInfo = ParamSpecFraction
    attrGet = getParamSpecFractionDefDen
    attrSet = setParamSpecFractionDefDen
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.ParamSpecFraction.defDen"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Structs-ParamSpecFraction.html#g:attr:defDen"
        })

paramSpecFraction_defDen :: AttrLabelProxy "defDen"
paramSpecFraction_defDen = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ParamSpecFraction
type instance O.AttributeList ParamSpecFraction = ParamSpecFractionAttributeList
type ParamSpecFractionAttributeList = ('[ '("parentInstance", ParamSpecFractionParentInstanceFieldInfo), '("minNum", ParamSpecFractionMinNumFieldInfo), '("minDen", ParamSpecFractionMinDenFieldInfo), '("maxNum", ParamSpecFractionMaxNumFieldInfo), '("maxDen", ParamSpecFractionMaxDenFieldInfo), '("defNum", ParamSpecFractionDefNumFieldInfo), '("defDen", ParamSpecFractionDefDenFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveParamSpecFractionMethod (t :: Symbol) (o :: *) :: * where
    ResolveParamSpecFractionMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif