{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Wp.Structs.SpaPod
    ( 

-- * Exported types
    SpaPod(..)                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Wp.Structs.SpaPod#g:method:copy"), [ensureUniqueOwner]("GI.Wp.Structs.SpaPod#g:method:ensureUniqueOwner"), [equal]("GI.Wp.Structs.SpaPod#g:method:equal"), [filter]("GI.Wp.Structs.SpaPod#g:method:filter"), [fixate]("GI.Wp.Structs.SpaPod#g:method:fixate"), [isArray]("GI.Wp.Structs.SpaPod#g:method:isArray"), [isBoolean]("GI.Wp.Structs.SpaPod#g:method:isBoolean"), [isBytes]("GI.Wp.Structs.SpaPod#g:method:isBytes"), [isChoice]("GI.Wp.Structs.SpaPod#g:method:isChoice"), [isControl]("GI.Wp.Structs.SpaPod#g:method:isControl"), [isDouble]("GI.Wp.Structs.SpaPod#g:method:isDouble"), [isFd]("GI.Wp.Structs.SpaPod#g:method:isFd"), [isFloat]("GI.Wp.Structs.SpaPod#g:method:isFloat"), [isFraction]("GI.Wp.Structs.SpaPod#g:method:isFraction"), [isId]("GI.Wp.Structs.SpaPod#g:method:isId"), [isInt]("GI.Wp.Structs.SpaPod#g:method:isInt"), [isLong]("GI.Wp.Structs.SpaPod#g:method:isLong"), [isNone]("GI.Wp.Structs.SpaPod#g:method:isNone"), [isObject]("GI.Wp.Structs.SpaPod#g:method:isObject"), [isPointer]("GI.Wp.Structs.SpaPod#g:method:isPointer"), [isProperty]("GI.Wp.Structs.SpaPod#g:method:isProperty"), [isRectangle]("GI.Wp.Structs.SpaPod#g:method:isRectangle"), [isSequence]("GI.Wp.Structs.SpaPod#g:method:isSequence"), [isString]("GI.Wp.Structs.SpaPod#g:method:isString"), [isStruct]("GI.Wp.Structs.SpaPod#g:method:isStruct"), [isUniqueOwner]("GI.Wp.Structs.SpaPod#g:method:isUniqueOwner"), [newIterator]("GI.Wp.Structs.SpaPod#g:method:newIterator"), [ref]("GI.Wp.Structs.SpaPod#g:method:ref"), [unref]("GI.Wp.Structs.SpaPod#g:method:unref").
-- 
-- ==== Getters
-- [getArrayChild]("GI.Wp.Structs.SpaPod#g:method:getArrayChild"), [getBoolean]("GI.Wp.Structs.SpaPod#g:method:getBoolean"), [getBytes]("GI.Wp.Structs.SpaPod#g:method:getBytes"), [getChoiceChild]("GI.Wp.Structs.SpaPod#g:method:getChoiceChild"), [getChoiceType]("GI.Wp.Structs.SpaPod#g:method:getChoiceType"), [getControl]("GI.Wp.Structs.SpaPod#g:method:getControl"), [getDouble]("GI.Wp.Structs.SpaPod#g:method:getDouble"), [getFd]("GI.Wp.Structs.SpaPod#g:method:getFd"), [getFloat]("GI.Wp.Structs.SpaPod#g:method:getFloat"), [getFraction]("GI.Wp.Structs.SpaPod#g:method:getFraction"), [getId]("GI.Wp.Structs.SpaPod#g:method:getId"), [getInt]("GI.Wp.Structs.SpaPod#g:method:getInt"), [getLong]("GI.Wp.Structs.SpaPod#g:method:getLong"), [getPointer]("GI.Wp.Structs.SpaPod#g:method:getPointer"), [getProperty]("GI.Wp.Structs.SpaPod#g:method:getProperty"), [getRectangle]("GI.Wp.Structs.SpaPod#g:method:getRectangle"), [getSpaPod]("GI.Wp.Structs.SpaPod#g:method:getSpaPod"), [getSpaType]("GI.Wp.Structs.SpaPod#g:method:getSpaType"), [getString]("GI.Wp.Structs.SpaPod#g:method:getString").
-- 
-- ==== Setters
-- [setBoolean]("GI.Wp.Structs.SpaPod#g:method:setBoolean"), [setDouble]("GI.Wp.Structs.SpaPod#g:method:setDouble"), [setFd]("GI.Wp.Structs.SpaPod#g:method:setFd"), [setFloat]("GI.Wp.Structs.SpaPod#g:method:setFloat"), [setFraction]("GI.Wp.Structs.SpaPod#g:method:setFraction"), [setId]("GI.Wp.Structs.SpaPod#g:method:setId"), [setInt]("GI.Wp.Structs.SpaPod#g:method:setInt"), [setLong]("GI.Wp.Structs.SpaPod#g:method:setLong"), [setPod]("GI.Wp.Structs.SpaPod#g:method:setPod"), [setPointer]("GI.Wp.Structs.SpaPod#g:method:setPointer"), [setRectangle]("GI.Wp.Structs.SpaPod#g:method:setRectangle").

#if defined(ENABLE_OVERLOADING)
    ResolveSpaPodMethod                     ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    SpaPodCopyMethodInfo                    ,
#endif
    spaPodCopy                              ,


-- ** ensureUniqueOwner #method:ensureUniqueOwner#

#if defined(ENABLE_OVERLOADING)
    SpaPodEnsureUniqueOwnerMethodInfo       ,
#endif
    spaPodEnsureUniqueOwner                 ,


-- ** equal #method:equal#

#if defined(ENABLE_OVERLOADING)
    SpaPodEqualMethodInfo                   ,
#endif
    spaPodEqual                             ,


-- ** filter #method:filter#

#if defined(ENABLE_OVERLOADING)
    SpaPodFilterMethodInfo                  ,
#endif
    spaPodFilter                            ,


-- ** fixate #method:fixate#

#if defined(ENABLE_OVERLOADING)
    SpaPodFixateMethodInfo                  ,
#endif
    spaPodFixate                            ,


-- ** getArrayChild #method:getArrayChild#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetArrayChildMethodInfo           ,
#endif
    spaPodGetArrayChild                     ,


-- ** getBoolean #method:getBoolean#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetBooleanMethodInfo              ,
#endif
    spaPodGetBoolean                        ,


-- ** getBytes #method:getBytes#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetBytesMethodInfo                ,
#endif
    spaPodGetBytes                          ,


-- ** getChoiceChild #method:getChoiceChild#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetChoiceChildMethodInfo          ,
#endif
    spaPodGetChoiceChild                    ,


-- ** getChoiceType #method:getChoiceType#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetChoiceTypeMethodInfo           ,
#endif
    spaPodGetChoiceType                     ,


-- ** getControl #method:getControl#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetControlMethodInfo              ,
#endif
    spaPodGetControl                        ,


-- ** getDouble #method:getDouble#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetDoubleMethodInfo               ,
#endif
    spaPodGetDouble                         ,


-- ** getFd #method:getFd#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetFdMethodInfo                   ,
#endif
    spaPodGetFd                             ,


-- ** getFloat #method:getFloat#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetFloatMethodInfo                ,
#endif
    spaPodGetFloat                          ,


-- ** getFraction #method:getFraction#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetFractionMethodInfo             ,
#endif
    spaPodGetFraction                       ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetIdMethodInfo                   ,
#endif
    spaPodGetId                             ,


-- ** getInt #method:getInt#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetIntMethodInfo                  ,
#endif
    spaPodGetInt                            ,


-- ** getLong #method:getLong#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetLongMethodInfo                 ,
#endif
    spaPodGetLong                           ,


-- ** getPointer #method:getPointer#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetPointerMethodInfo              ,
#endif
    spaPodGetPointer                        ,


-- ** getProperty #method:getProperty#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetPropertyMethodInfo             ,
#endif
    spaPodGetProperty                       ,


-- ** getRectangle #method:getRectangle#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetRectangleMethodInfo            ,
#endif
    spaPodGetRectangle                      ,


-- ** getSpaPod #method:getSpaPod#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetSpaPodMethodInfo               ,
#endif
    spaPodGetSpaPod                         ,


-- ** getSpaType #method:getSpaType#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetSpaTypeMethodInfo              ,
#endif
    spaPodGetSpaType                        ,


-- ** getString #method:getString#

#if defined(ENABLE_OVERLOADING)
    SpaPodGetStringMethodInfo               ,
#endif
    spaPodGetString                         ,


-- ** isArray #method:isArray#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsArrayMethodInfo                 ,
#endif
    spaPodIsArray                           ,


-- ** isBoolean #method:isBoolean#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsBooleanMethodInfo               ,
#endif
    spaPodIsBoolean                         ,


-- ** isBytes #method:isBytes#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsBytesMethodInfo                 ,
#endif
    spaPodIsBytes                           ,


-- ** isChoice #method:isChoice#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsChoiceMethodInfo                ,
#endif
    spaPodIsChoice                          ,


-- ** isControl #method:isControl#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsControlMethodInfo               ,
#endif
    spaPodIsControl                         ,


-- ** isDouble #method:isDouble#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsDoubleMethodInfo                ,
#endif
    spaPodIsDouble                          ,


-- ** isFd #method:isFd#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsFdMethodInfo                    ,
#endif
    spaPodIsFd                              ,


-- ** isFloat #method:isFloat#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsFloatMethodInfo                 ,
#endif
    spaPodIsFloat                           ,


-- ** isFraction #method:isFraction#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsFractionMethodInfo              ,
#endif
    spaPodIsFraction                        ,


-- ** isId #method:isId#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsIdMethodInfo                    ,
#endif
    spaPodIsId                              ,


-- ** isInt #method:isInt#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsIntMethodInfo                   ,
#endif
    spaPodIsInt                             ,


-- ** isLong #method:isLong#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsLongMethodInfo                  ,
#endif
    spaPodIsLong                            ,


-- ** isNone #method:isNone#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsNoneMethodInfo                  ,
#endif
    spaPodIsNone                            ,


-- ** isObject #method:isObject#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsObjectMethodInfo                ,
#endif
    spaPodIsObject                          ,


-- ** isPointer #method:isPointer#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsPointerMethodInfo               ,
#endif
    spaPodIsPointer                         ,


-- ** isProperty #method:isProperty#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsPropertyMethodInfo              ,
#endif
    spaPodIsProperty                        ,


-- ** isRectangle #method:isRectangle#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsRectangleMethodInfo             ,
#endif
    spaPodIsRectangle                       ,


-- ** isSequence #method:isSequence#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsSequenceMethodInfo              ,
#endif
    spaPodIsSequence                        ,


-- ** isString #method:isString#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsStringMethodInfo                ,
#endif
    spaPodIsString                          ,


-- ** isStruct #method:isStruct#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsStructMethodInfo                ,
#endif
    spaPodIsStruct                          ,


-- ** isUniqueOwner #method:isUniqueOwner#

#if defined(ENABLE_OVERLOADING)
    SpaPodIsUniqueOwnerMethodInfo           ,
#endif
    spaPodIsUniqueOwner                     ,


-- ** newBoolean #method:newBoolean#

    spaPodNewBoolean                        ,


-- ** newBytes #method:newBytes#

    spaPodNewBytes                          ,


-- ** newDouble #method:newDouble#

    spaPodNewDouble                         ,


-- ** newFd #method:newFd#

    spaPodNewFd                             ,


-- ** newFloat #method:newFloat#

    spaPodNewFloat                          ,


-- ** newFraction #method:newFraction#

    spaPodNewFraction                       ,


-- ** newId #method:newId#

    spaPodNewId                             ,


-- ** newInt #method:newInt#

    spaPodNewInt                            ,


-- ** newIterator #method:newIterator#

#if defined(ENABLE_OVERLOADING)
    SpaPodNewIteratorMethodInfo             ,
#endif
    spaPodNewIterator                       ,


-- ** newLong #method:newLong#

    spaPodNewLong                           ,


-- ** newNone #method:newNone#

    spaPodNewNone                           ,


-- ** newPointer #method:newPointer#

    spaPodNewPointer                        ,


-- ** newRectangle #method:newRectangle#

    spaPodNewRectangle                      ,


-- ** newString #method:newString#

    spaPodNewString                         ,


-- ** newWrap #method:newWrap#

    spaPodNewWrap                           ,


-- ** newWrapConst #method:newWrapConst#

    spaPodNewWrapConst                      ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    SpaPodRefMethodInfo                     ,
#endif
    spaPodRef                               ,


-- ** setBoolean #method:setBoolean#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetBooleanMethodInfo              ,
#endif
    spaPodSetBoolean                        ,


-- ** setDouble #method:setDouble#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetDoubleMethodInfo               ,
#endif
    spaPodSetDouble                         ,


-- ** setFd #method:setFd#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetFdMethodInfo                   ,
#endif
    spaPodSetFd                             ,


-- ** setFloat #method:setFloat#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetFloatMethodInfo                ,
#endif
    spaPodSetFloat                          ,


-- ** setFraction #method:setFraction#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetFractionMethodInfo             ,
#endif
    spaPodSetFraction                       ,


-- ** setId #method:setId#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetIdMethodInfo                   ,
#endif
    spaPodSetId                             ,


-- ** setInt #method:setInt#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetIntMethodInfo                  ,
#endif
    spaPodSetInt                            ,


-- ** setLong #method:setLong#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetLongMethodInfo                 ,
#endif
    spaPodSetLong                           ,


-- ** setPod #method:setPod#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetPodMethodInfo                  ,
#endif
    spaPodSetPod                            ,


-- ** setPointer #method:setPointer#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetPointerMethodInfo              ,
#endif
    spaPodSetPointer                        ,


-- ** setRectangle #method:setRectangle#

#if defined(ENABLE_OVERLOADING)
    SpaPodSetRectangleMethodInfo            ,
#endif
    spaPodSetRectangle                      ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    SpaPodUnrefMethodInfo                   ,
#endif
    spaPodUnref                             ,




    ) 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 qualified GI.Wp.Callbacks as Wp.Callbacks
import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType
import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator
import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods

#else
import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType
import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator

#endif

-- | Memory-managed wrapper type.
newtype SpaPod = SpaPod (SP.ManagedPtr SpaPod)
    deriving (Eq)

instance SP.ManagedPtrNewtype SpaPod where
    toManagedPtr (SpaPod p) = p

foreign import ccall "wp_spa_pod_get_type" c_wp_spa_pod_get_type :: 
    IO GType

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

instance B.Types.TypedObject SpaPod where
    glibType = c_wp_spa_pod_get_type

instance B.Types.GBoxed SpaPod

-- | Convert t'SpaPod' 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 SpaPod) where
    gvalueGType_ = c_wp_spa_pod_get_type
    gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaPod)
    gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv)
    gvalueGet_ gv = do
        ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaPod)
        if ptr /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newBoxed SpaPod ptr
        else return P.Nothing
        
    


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

-- method SpaPod::new_boolean
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the boolean value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_boolean" wp_spa_pod_new_boolean :: 
    CInt ->                                 -- value : TBasicType TBoolean
    IO (Ptr SpaPod)

-- | Creates a spa pod of type boolean.
spaPodNewBoolean ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bool
    -- ^ /@value@/: the boolean value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewBoolean value = liftIO $ do
    let value' = (P.fromIntegral . P.fromEnum) value
    result <- wp_spa_pod_new_boolean value'
    checkUnexpectedReturnNULL "spaPodNewBoolean" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_bytes
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bytes value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of the bytes value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_bytes" wp_spa_pod_new_bytes :: 
    Ptr () ->                               -- value : TBasicType TPtr
    Word32 ->                               -- len : TBasicType TUInt32
    IO (Ptr SpaPod)

-- | Creates a spa pod of type bytes.
spaPodNewBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@value@/: the bytes value
    -> Word32
    -- ^ /@len@/: the length of the bytes value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewBytes value len = liftIO $ do
    result <- wp_spa_pod_new_bytes value len
    checkUnexpectedReturnNULL "spaPodNewBytes" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_double
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the double value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_double" wp_spa_pod_new_double :: 
    CDouble ->                              -- value : TBasicType TDouble
    IO (Ptr SpaPod)

-- | Creates a spa pod of type double.
spaPodNewDouble ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Double
    -- ^ /@value@/: the double value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewDouble value = liftIO $ do
    let value' = realToFrac value
    result <- wp_spa_pod_new_double value'
    checkUnexpectedReturnNULL "spaPodNewDouble" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_fd
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Fd value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_fd" wp_spa_pod_new_fd :: 
    Int64 ->                                -- value : TBasicType TInt64
    IO (Ptr SpaPod)

-- | Creates a spa pod of type Fd.
spaPodNewFd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int64
    -- ^ /@value@/: the Fd value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewFd value = liftIO $ do
    result <- wp_spa_pod_new_fd value
    checkUnexpectedReturnNULL "spaPodNewFd" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_float
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the float value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_float" wp_spa_pod_new_float :: 
    CFloat ->                               -- value : TBasicType TFloat
    IO (Ptr SpaPod)

-- | Creates a spa pod of type float.
spaPodNewFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Float
    -- ^ /@value@/: the float value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewFloat value = liftIO $ do
    let value' = realToFrac value
    result <- wp_spa_pod_new_float value'
    checkUnexpectedReturnNULL "spaPodNewFloat" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_fraction
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "num"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the numerator value of the fraction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "denom"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the denominator value of the fraction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_fraction" wp_spa_pod_new_fraction :: 
    Word32 ->                               -- num : TBasicType TUInt32
    Word32 ->                               -- denom : TBasicType TUInt32
    IO (Ptr SpaPod)

-- | Creates a spa pod of type fraction.
spaPodNewFraction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@num@/: the numerator value of the fraction
    -> Word32
    -- ^ /@denom@/: the denominator value of the fraction
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewFraction num denom = liftIO $ do
    result <- wp_spa_pod_new_fraction num denom
    checkUnexpectedReturnNULL "spaPodNewFraction" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_id
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Id value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_id" wp_spa_pod_new_id :: 
    Word32 ->                               -- value : TBasicType TUInt32
    IO (Ptr SpaPod)

-- | Creates a spa pod of type Id.
spaPodNewId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@value@/: the Id value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewId value = liftIO $ do
    result <- wp_spa_pod_new_id value
    checkUnexpectedReturnNULL "spaPodNewId" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_int
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TInt32
--           , argCType = Just "gint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the int value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_int" wp_spa_pod_new_int :: 
    Int32 ->                                -- value : TBasicType TInt32
    IO (Ptr SpaPod)

-- | Creates a spa pod of type int.
spaPodNewInt ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    -- ^ /@value@/: the int value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewInt value = liftIO $ do
    result <- wp_spa_pod_new_int value
    checkUnexpectedReturnNULL "spaPodNewInt" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_long
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the long value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_long" wp_spa_pod_new_long :: 
    Int64 ->                                -- value : TBasicType TInt64
    IO (Ptr SpaPod)

-- | Creates a spa pod of type long.
spaPodNewLong ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int64
    -- ^ /@value@/: the long value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewLong value = liftIO $ do
    result <- wp_spa_pod_new_long value
    checkUnexpectedReturnNULL "spaPodNewLong" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "wp_spa_pod_new_none" wp_spa_pod_new_none :: 
    IO (Ptr SpaPod)

-- | Creates a spa pod of type None.
spaPodNewNone ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewNone  = liftIO $ do
    result <- wp_spa_pod_new_none
    checkUnexpectedReturnNULL "spaPodNewNone" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_pointer
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "type_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the type of the pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pointer value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_pointer" wp_spa_pod_new_pointer :: 
    CString ->                              -- type_name : TBasicType TUTF8
    Ptr () ->                               -- value : TBasicType TPtr
    IO (Ptr SpaPod)

-- | Creates a spa pod of type pointer.
spaPodNewPointer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@typeName@/: the name of the type of the pointer
    -> Ptr ()
    -- ^ /@value@/: the pointer value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewPointer typeName value = liftIO $ do
    typeName' <- textToCString typeName
    result <- wp_spa_pod_new_pointer typeName' value
    checkUnexpectedReturnNULL "spaPodNewPointer" result
    result' <- (wrapBoxed SpaPod) result
    freeMem typeName'
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_rectangle
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width value of the rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height value of the rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_rectangle" wp_spa_pod_new_rectangle :: 
    Word32 ->                               -- width : TBasicType TUInt32
    Word32 ->                               -- height : TBasicType TUInt32
    IO (Ptr SpaPod)

-- | Creates a spa pod of type rectangle.
spaPodNewRectangle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@width@/: the width value of the rectangle
    -> Word32
    -- ^ /@height@/: the height value of the rectangle
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewRectangle width height = liftIO $ do
    result <- wp_spa_pod_new_rectangle width height
    checkUnexpectedReturnNULL "spaPodNewRectangle" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_string
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_string" wp_spa_pod_new_string :: 
    CString ->                              -- value : TBasicType TUTF8
    IO (Ptr SpaPod)

-- | Creates a spa pod of type string.
spaPodNewString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@value@/: the string value
    -> m SpaPod
    -- ^ __Returns:__ The new spa pod
spaPodNewString value = liftIO $ do
    value' <- textToCString value
    result <- wp_spa_pod_new_string value'
    checkUnexpectedReturnNULL "spaPodNewString" result
    result' <- (wrapBoxed SpaPod) result
    freeMem value'
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_wrap
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "pod"
--           , argType = TBasicType TPtr
--           , argCType = Just "spa_pod*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa_pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_wrap" wp_spa_pod_new_wrap :: 
    Ptr () ->                               -- pod : TBasicType TPtr
    IO (Ptr SpaPod)

-- | Constructs a new WpSpaPod that wraps the given spa_pod.
spaPodNewWrap ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@pod@/: a spa_pod
    -> m SpaPod
    -- ^ __Returns:__ a new WpSpaPod that references the data in /@pod@/. /@pod@/ is not copied, so it needs to stay alive. The returned WpSpaPod can be modified by using the setter functions, in which case /@pod@/ will be modified underneath.
spaPodNewWrap pod = liftIO $ do
    result <- wp_spa_pod_new_wrap pod
    checkUnexpectedReturnNULL "spaPodNewWrap" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::new_wrap_const
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "pod"
--           , argType = TBasicType TPtr
--           , argCType = Just "const spa_pod*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a constant spa_pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_wrap_const" wp_spa_pod_new_wrap_const :: 
    Ptr () ->                               -- pod : TBasicType TPtr
    IO (Ptr SpaPod)

-- | Constructs a new immutable WpSpaPod that wraps the given spa_pod.
spaPodNewWrapConst ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Ptr ()
    -- ^ /@pod@/: a constant spa_pod
    -> m SpaPod
    -- ^ __Returns:__ a new WpSpaPod that references the data in /@pod@/. /@pod@/ is not copied, so it needs to stay alive. The returned WpSpaPod cannot be modified, unless it\'s copied first.
spaPodNewWrapConst pod = liftIO $ do
    result <- wp_spa_pod_new_wrap_const pod
    checkUnexpectedReturnNULL "spaPodNewWrapConst" result
    result' <- (wrapBoxed SpaPod) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpaPod::copy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "other"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_copy" wp_spa_pod_copy :: 
    Ptr SpaPod ->                           -- other : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | Copies a spa pod object.
spaPodCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@other@/: a spa pod object
    -> m SpaPod
    -- ^ __Returns:__ The newly copied spa pod
spaPodCopy other = liftIO $ do
    other' <- unsafeManagedPtrGetPtr other
    result <- wp_spa_pod_copy other'
    checkUnexpectedReturnNULL "spaPodCopy" result
    result' <- (wrapBoxed SpaPod) result
    touchManagedPtr other
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodCopyMethodInfo
instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodCopyMethodInfo SpaPod signature where
    overloadedMethod = spaPodCopy

instance O.OverloadedMethodInfo SpaPodCopyMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodCopy"
        })


#endif

-- method SpaPod::ensure_unique_owner
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_ensure_unique_owner" wp_spa_pod_ensure_unique_owner :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | If /@self@/ is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider /@self@/ as unsafe to use after this call and you should use the returned object instead.
spaPodEnsureUniqueOwner ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod object
    -> m SpaPod
    -- ^ __Returns:__ the uniquely owned spa pod object which may or may not be the same as /@self@/.
spaPodEnsureUniqueOwner self = liftIO $ do
    self' <- B.ManagedPtr.disownBoxed self
    result <- wp_spa_pod_ensure_unique_owner self'
    checkUnexpectedReturnNULL "spaPodEnsureUniqueOwner" result
    result' <- (wrapBoxed SpaPod) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodEnsureUniqueOwnerMethodInfo
instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodEnsureUniqueOwnerMethodInfo SpaPod signature where
    overloadedMethod = spaPodEnsureUniqueOwner

instance O.OverloadedMethodInfo SpaPodEnsureUniqueOwnerMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodEnsureUniqueOwner",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodEnsureUniqueOwner"
        })


#endif

-- method SpaPod::equal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pod"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pod with the value to be compared with"
--                 , 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 "wp_spa_pod_equal" wp_spa_pod_equal :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr SpaPod ->                           -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether two spa pod objects have the same value or not.
spaPodEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> SpaPod
    -- ^ /@pod@/: the pod with the value to be compared with
    -> m Bool
    -- ^ __Returns:__ TRUE if both spa pod objects have the same values, FALSE otherwise.
spaPodEqual self pod = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    pod' <- unsafeManagedPtrGetPtr pod
    result <- wp_spa_pod_equal self' pod'
    let result' = (/= 0) result
    touchManagedPtr self
    touchManagedPtr pod
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodEqualMethodInfo
instance (signature ~ (SpaPod -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodEqualMethodInfo SpaPod signature where
    overloadedMethod = spaPodEqual

instance O.OverloadedMethodInfo SpaPodEqualMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodEqual",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodEqual"
        })


#endif

-- method SpaPod::filter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the first pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "filter"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the second pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_filter" wp_spa_pod_filter :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr SpaPod ->                           -- filter : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | Returns the intersection between /@self@/ and /@filter@/.
-- 
-- 
-- This is typically used to intersect pods that describe formats, in order to find a common format that is acceptable by both sides. For that purpose, this is not exactly an intersection with its mathematical meaning. Object properties can be thought of as format constraints. When one side does not specify a specific property, it is considered to accept any value for it, so the value of this property from the other side is added in the result.
-- Both input pods are left unmodified after this function call.
-- If NULL is passed in the /@filter@/, this function just copies /@self@/ and returns the copy.
spaPodFilter ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the first pod
    -> Maybe (SpaPod)
    -- ^ /@filter@/: the second pod
    -> m (Maybe SpaPod)
    -- ^ __Returns:__ a new pod that contains the intersection between /@self@/ and /@filter@/, or NULL if the intersection was not possible to make
spaPodFilter self filter = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    maybeFilter <- case filter of
        Nothing -> return FP.nullPtr
        Just jFilter -> do
            jFilter' <- unsafeManagedPtrGetPtr jFilter
            return jFilter'
    result <- wp_spa_pod_filter self' maybeFilter
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed SpaPod) result'
        return result''
    touchManagedPtr self
    whenJust filter touchManagedPtr
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data SpaPodFilterMethodInfo
instance (signature ~ (Maybe (SpaPod) -> m (Maybe SpaPod)), MonadIO m) => O.OverloadedMethod SpaPodFilterMethodInfo SpaPod signature where
    overloadedMethod = spaPodFilter

instance O.OverloadedMethodInfo SpaPodFilterMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodFilter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodFilter"
        })


#endif

-- method SpaPod::fixate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod" , 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 "wp_spa_pod_fixate" wp_spa_pod_fixate :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Fixates choices in an object pod so that they only have one value.
spaPodFixate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod
    -> m Bool
    -- ^ __Returns:__ TRUE if the pod was an object and it went through the fixation procedure, FALSE otherwise
spaPodFixate self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_fixate self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodFixateMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodFixateMethodInfo SpaPod signature where
    overloadedMethod = spaPodFixate

instance O.OverloadedMethodInfo SpaPodFixateMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodFixate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodFixate"
        })


#endif

-- method SpaPod::get_array_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod choice object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_array_child" wp_spa_pod_get_array_child :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | Gets the child of a spa pod array object.
spaPodGetArrayChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod choice object
    -> m SpaPod
    -- ^ __Returns:__ the child of the spa pod array object
spaPodGetArrayChild self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_get_array_child self'
    checkUnexpectedReturnNULL "spaPodGetArrayChild" result
    result' <- (wrapBoxed SpaPod) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodGetArrayChildMethodInfo
instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodGetArrayChildMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetArrayChild

instance O.OverloadedMethodInfo SpaPodGetArrayChildMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetArrayChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetArrayChild"
        })


#endif

-- method SpaPod::get_boolean
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the boolean value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_boolean" wp_spa_pod_get_boolean :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr CInt ->                             -- value : TBasicType TBoolean
    IO CInt

-- | Gets the boolean value of a spa pod object.
spaPodGetBoolean ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Bool))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetBoolean self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr CInt)
    result <- wp_spa_pod_get_boolean self' value
    let result' = (/= 0) result
    value' <- peek value
    let value'' = (/= 0) value'
    touchManagedPtr self
    freeMem value
    return (result', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetBooleanMethodInfo
instance (signature ~ (m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SpaPodGetBooleanMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetBoolean

instance O.OverloadedMethodInfo SpaPodGetBooleanMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetBoolean",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetBoolean"
        })


#endif

-- method SpaPod::get_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer*"
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the bytes value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of the bytes value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_bytes" wp_spa_pod_get_bytes :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr (Ptr ()) ->                         -- value : TBasicType TPtr
    Ptr Word32 ->                           -- len : TBasicType TUInt32
    IO CInt

-- | Gets the bytes value and its len of a spa pod object.
spaPodGetBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Ptr (), Word32))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetBytes self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- callocMem :: IO (Ptr (Ptr ()))
    len <- allocMem :: IO (Ptr Word32)
    result <- wp_spa_pod_get_bytes self' value len
    let result' = (/= 0) result
    value' <- peek value
    len' <- peek len
    touchManagedPtr self
    freeMem value
    freeMem len
    return (result', value', len')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetBytesMethodInfo
instance (signature ~ (m ((Bool, Ptr (), Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetBytesMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetBytes

instance O.OverloadedMethodInfo SpaPodGetBytesMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetBytes"
        })


#endif

-- method SpaPod::get_choice_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod choice object"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_choice_child" wp_spa_pod_get_choice_child :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | Gets the child of a spa pod choice object.
spaPodGetChoiceChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod choice object
    -> m SpaPod
    -- ^ __Returns:__ the child of the spa pod choice object
spaPodGetChoiceChild self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_get_choice_child self'
    checkUnexpectedReturnNULL "spaPodGetChoiceChild" result
    result' <- (wrapBoxed SpaPod) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodGetChoiceChildMethodInfo
instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodGetChoiceChildMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetChoiceChild

instance O.OverloadedMethodInfo SpaPodGetChoiceChildMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetChoiceChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetChoiceChild"
        })


#endif

-- method SpaPod::get_choice_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a choice pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_choice_type" wp_spa_pod_get_choice_type :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr ())

-- | If the pod is a Choice, this gets the choice type (Range, Step, Enum, ...).
spaPodGetChoiceType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a choice pod
    -> m (Ptr ())
    -- ^ __Returns:__ the choice type of the choice pod
spaPodGetChoiceType self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_get_choice_type self'
    touchManagedPtr self
    return result

#if defined(ENABLE_OVERLOADING)
data SpaPodGetChoiceTypeMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod SpaPodGetChoiceTypeMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetChoiceType

instance O.OverloadedMethodInfo SpaPodGetChoiceTypeMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetChoiceType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetChoiceType"
        })


#endif

-- method SpaPod::get_control
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the offset of the control"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "ctl_type"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the control type (Properties, Midi, ...)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod value of the control"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_control" wp_spa_pod_get_control :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Word32 ->                           -- offset : TBasicType TUInt32
    Ptr CString ->                          -- ctl_type : TBasicType TUTF8
    Ptr (Ptr SpaPod) ->                     -- value : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Gets the offset, type name and spa pod value of a spa pod control.
spaPodGetControl ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Word32, T.Text, SpaPod))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetControl self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    offset <- allocMem :: IO (Ptr Word32)
    ctlType <- callocMem :: IO (Ptr CString)
    value <- callocMem :: IO (Ptr (Ptr SpaPod))
    result <- wp_spa_pod_get_control self' offset ctlType value
    let result' = (/= 0) result
    offset' <- peek offset
    ctlType' <- peek ctlType
    ctlType'' <- cstringToText ctlType'
    value' <- peek value
    value'' <- (wrapBoxed SpaPod) value'
    touchManagedPtr self
    freeMem offset
    freeMem ctlType
    freeMem value
    return (result', offset', ctlType'', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetControlMethodInfo
instance (signature ~ (m ((Bool, Word32, T.Text, SpaPod))), MonadIO m) => O.OverloadedMethod SpaPodGetControlMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetControl

instance O.OverloadedMethodInfo SpaPodGetControlMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetControl",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetControl"
        })


#endif

-- method SpaPod::get_double
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , argCType = Just "double*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the double value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_double" wp_spa_pod_get_double :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr CDouble ->                          -- value : TBasicType TDouble
    IO CInt

-- | Gets the double value of a spa pod object.
spaPodGetDouble ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Double))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetDouble self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr CDouble)
    result <- wp_spa_pod_get_double self' value
    let result' = (/= 0) result
    value' <- peek value
    let value'' = realToFrac value'
    touchManagedPtr self
    freeMem value
    return (result', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetDoubleMethodInfo
instance (signature ~ (m ((Bool, Double))), MonadIO m) => O.OverloadedMethod SpaPodGetDoubleMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetDouble

instance O.OverloadedMethodInfo SpaPodGetDoubleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetDouble",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetDouble"
        })


#endif

-- method SpaPod::get_fd
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Fd value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_fd" wp_spa_pod_get_fd :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Int64 ->                            -- value : TBasicType TInt64
    IO CInt

-- | Gets the Fd value of a spa pod object.
spaPodGetFd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Int64))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetFd self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr Int64)
    result <- wp_spa_pod_get_fd self' value
    let result' = (/= 0) result
    value' <- peek value
    touchManagedPtr self
    freeMem value
    return (result', value')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetFdMethodInfo
instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodGetFdMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetFd

instance O.OverloadedMethodInfo SpaPodGetFdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFd"
        })


#endif

-- method SpaPod::get_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TFloat
--           , argCType = Just "float*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the float value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_float" wp_spa_pod_get_float :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr CFloat ->                           -- value : TBasicType TFloat
    IO CInt

-- | Gets the float value of a spa pod object.
spaPodGetFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Float))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetFloat self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr CFloat)
    result <- wp_spa_pod_get_float self' value
    let result' = (/= 0) result
    value' <- peek value
    let value'' = realToFrac value'
    touchManagedPtr self
    freeMem value
    return (result', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetFloatMethodInfo
instance (signature ~ (m ((Bool, Float))), MonadIO m) => O.OverloadedMethod SpaPodGetFloatMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetFloat

instance O.OverloadedMethodInfo SpaPodGetFloatMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFloat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFloat"
        })


#endif

-- method SpaPod::get_fraction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "num"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fractions's numerator value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "denom"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the fractions's denominator value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_fraction" wp_spa_pod_get_fraction :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Word32 ->                           -- num : TBasicType TUInt32
    Ptr Word32 ->                           -- denom : TBasicType TUInt32
    IO CInt

-- | Gets the fractions\'s numerator and denominator value of a spa pod object.
spaPodGetFraction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Word32, Word32))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetFraction self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    num <- allocMem :: IO (Ptr Word32)
    denom <- allocMem :: IO (Ptr Word32)
    result <- wp_spa_pod_get_fraction self' num denom
    let result' = (/= 0) result
    num' <- peek num
    denom' <- peek denom
    touchManagedPtr self
    freeMem num
    freeMem denom
    return (result', num', denom')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetFractionMethodInfo
instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetFractionMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetFraction

instance O.OverloadedMethodInfo SpaPodGetFractionMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFraction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFraction"
        })


#endif

-- method SpaPod::get_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Id value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_id" wp_spa_pod_get_id :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Word32 ->                           -- value : TBasicType TUInt32
    IO CInt

-- | Gets the Id value of a spa pod object.
spaPodGetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Word32))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetId self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr Word32)
    result <- wp_spa_pod_get_id self' value
    let result' = (/= 0) result
    value' <- peek value
    touchManagedPtr self
    freeMem value
    return (result', value')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetIdMethodInfo
instance (signature ~ (m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetIdMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetId

instance O.OverloadedMethodInfo SpaPodGetIdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetId"
        })


#endif

-- method SpaPod::get_int
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt32
--           , argCType = Just "gint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the int value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_int" wp_spa_pod_get_int :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Int32 ->                            -- value : TBasicType TInt32
    IO CInt

-- | Gets the int value of a spa pod object.
spaPodGetInt ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Int32))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetInt self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr Int32)
    result <- wp_spa_pod_get_int self' value
    let result' = (/= 0) result
    value' <- peek value
    touchManagedPtr self
    freeMem value
    return (result', value')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetIntMethodInfo
instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod SpaPodGetIntMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetInt

instance O.OverloadedMethodInfo SpaPodGetIntMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetInt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetInt"
        })


#endif

-- method SpaPod::get_long
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the long value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_long" wp_spa_pod_get_long :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Int64 ->                            -- value : TBasicType TInt64
    IO CInt

-- | Gets the long value of a spa pod object.
spaPodGetLong ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Int64))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetLong self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- allocMem :: IO (Ptr Int64)
    result <- wp_spa_pod_get_long self' value
    let result' = (/= 0) result
    value' <- peek value
    touchManagedPtr self
    freeMem value
    return (result', value')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetLongMethodInfo
instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodGetLongMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetLong

instance O.OverloadedMethodInfo SpaPodGetLongMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetLong",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetLong"
        })


#endif

-- method SpaPod::get_pointer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer*"
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pointer value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_pointer" wp_spa_pod_get_pointer :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr (Ptr ()) ->                         -- value : TBasicType TPtr
    IO CInt

-- | Gets the pointer value and its type name of a spa pod object.
spaPodGetPointer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Ptr ()))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetPointer self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- callocMem :: IO (Ptr (Ptr ()))
    result <- wp_spa_pod_get_pointer self' value
    let result' = (/= 0) result
    value' <- peek value
    touchManagedPtr self
    freeMem value
    return (result', value')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetPointerMethodInfo
instance (signature ~ (m ((Bool, Ptr ()))), MonadIO m) => O.OverloadedMethod SpaPodGetPointerMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetPointer

instance O.OverloadedMethodInfo SpaPodGetPointerMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetPointer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetPointer"
        })


#endif

-- method SpaPod::get_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod value of the property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_property" wp_spa_pod_get_property :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr CString ->                          -- key : TBasicType TUTF8
    Ptr (Ptr SpaPod) ->                     -- value : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Gets the name, flags and spa pod value of a spa pod property.
spaPodGetProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, T.Text, SpaPod))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetProperty self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    key <- callocMem :: IO (Ptr CString)
    value <- callocMem :: IO (Ptr (Ptr SpaPod))
    result <- wp_spa_pod_get_property self' key value
    let result' = (/= 0) result
    key' <- peek key
    key'' <- cstringToText key'
    value' <- peek value
    value'' <- (wrapBoxed SpaPod) value'
    touchManagedPtr self
    freeMem key
    freeMem value
    return (result', key'', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetPropertyMethodInfo
instance (signature ~ (m ((Bool, T.Text, SpaPod))), MonadIO m) => O.OverloadedMethod SpaPodGetPropertyMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetProperty

instance O.OverloadedMethodInfo SpaPodGetPropertyMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetProperty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetProperty"
        })


#endif

-- method SpaPod::get_rectangle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle's width value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32*"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the rectangle's height value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_rectangle" wp_spa_pod_get_rectangle :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr Word32 ->                           -- width : TBasicType TUInt32
    Ptr Word32 ->                           -- height : TBasicType TUInt32
    IO CInt

-- | Gets the rectangle\'s width and height value of a spa pod object.
spaPodGetRectangle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, Word32, Word32))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetRectangle self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    width <- allocMem :: IO (Ptr Word32)
    height <- allocMem :: IO (Ptr Word32)
    result <- wp_spa_pod_get_rectangle self' width height
    let result' = (/= 0) result
    width' <- peek width
    height' <- peek height
    touchManagedPtr self
    freeMem width
    freeMem height
    return (result', width', height')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetRectangleMethodInfo
instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetRectangleMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetRectangle

instance O.OverloadedMethodInfo SpaPodGetRectangleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetRectangle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetRectangle"
        })


#endif

-- method SpaPod::get_spa_pod
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "const WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TPtr)
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_spa_pod" wp_spa_pod_get_spa_pod :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr ())

-- | Converts a WpSpaPod pointer to a struct spa_pod one, for use with native pipewire & spa functions. The returned pointer is owned by WpSpaPod and may not be modified or freed.
spaPodGetSpaPod ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod object
    -> m (Ptr ())
    -- ^ __Returns:__ a const pointer to the underlying spa_pod structure
spaPodGetSpaPod self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_get_spa_pod self'
    touchManagedPtr self
    return result

#if defined(ENABLE_OVERLOADING)
data SpaPodGetSpaPodMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod SpaPodGetSpaPodMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetSpaPod

instance O.OverloadedMethodInfo SpaPodGetSpaPodMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetSpaPod",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetSpaPod"
        })


#endif

-- method SpaPod::get_spa_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_get_spa_type" wp_spa_pod_get_spa_type :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr Wp.SpaType.SpaType)

-- | Gets the SPA type of the spa pod.
-- 
-- 
-- If the pod is an object or pointer, this will return the derived object\/pointer type directly. If the pod is an object property or a control, this will return the type of the contained value.
spaPodGetSpaType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod
    -> m Wp.SpaType.SpaType
    -- ^ __Returns:__ the type of the spa pod
spaPodGetSpaType self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_get_spa_type self'
    checkUnexpectedReturnNULL "spaPodGetSpaType" result
    result' <- (newPtr Wp.SpaType.SpaType) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodGetSpaTypeMethodInfo
instance (signature ~ (m Wp.SpaType.SpaType), MonadIO m) => O.OverloadedMethod SpaPodGetSpaTypeMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetSpaType

instance O.OverloadedMethodInfo SpaPodGetSpaTypeMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetSpaType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetSpaType"
        })


#endif

-- method SpaPod::get_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char**"
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the string 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 "wp_spa_pod_get_string" wp_spa_pod_get_string :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr CString ->                          -- value : TBasicType TUTF8
    IO CInt

-- | Gets the string value of a spa pod object.
spaPodGetString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m ((Bool, T.Text))
    -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise
spaPodGetString self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    value <- callocMem :: IO (Ptr CString)
    result <- wp_spa_pod_get_string self' value
    let result' = (/= 0) result
    value' <- peek value
    value'' <- cstringToText value'
    touchManagedPtr self
    freeMem value
    return (result', value'')

#if defined(ENABLE_OVERLOADING)
data SpaPodGetStringMethodInfo
instance (signature ~ (m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod SpaPodGetStringMethodInfo SpaPod signature where
    overloadedMethod = spaPodGetString

instance O.OverloadedMethodInfo SpaPodGetStringMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetString",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetString"
        })


#endif

-- method SpaPod::is_array
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_array" wp_spa_pod_is_array :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type array or not.
spaPodIsArray ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type array, FALSE otherwise
spaPodIsArray self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_array self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsArrayMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsArrayMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsArray

instance O.OverloadedMethodInfo SpaPodIsArrayMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsArray",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsArray"
        })


#endif

-- method SpaPod::is_boolean
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_boolean" wp_spa_pod_is_boolean :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type boolean or not.
spaPodIsBoolean ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type boolean, FALSE otherwise
spaPodIsBoolean self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_boolean self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsBooleanMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsBooleanMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsBoolean

instance O.OverloadedMethodInfo SpaPodIsBooleanMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsBoolean",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsBoolean"
        })


#endif

-- method SpaPod::is_bytes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_bytes" wp_spa_pod_is_bytes :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type bytes or not.
spaPodIsBytes ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type bytes, FALSE otherwise
spaPodIsBytes self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_bytes self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsBytesMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsBytesMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsBytes

instance O.OverloadedMethodInfo SpaPodIsBytesMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsBytes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsBytes"
        })


#endif

-- method SpaPod::is_choice
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_choice" wp_spa_pod_is_choice :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type choice or not.
spaPodIsChoice ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type choice, FALSE otherwise
spaPodIsChoice self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_choice self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsChoiceMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsChoiceMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsChoice

instance O.OverloadedMethodInfo SpaPodIsChoiceMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsChoice",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsChoice"
        })


#endif

-- method SpaPod::is_control
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_control" wp_spa_pod_is_control :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type control or not.
spaPodIsControl ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type control, FALSE otherwise
spaPodIsControl self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_control self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsControlMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsControlMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsControl

instance O.OverloadedMethodInfo SpaPodIsControlMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsControl",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsControl"
        })


#endif

-- method SpaPod::is_double
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_double" wp_spa_pod_is_double :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type double or not.
spaPodIsDouble ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type double, FALSE otherwise
spaPodIsDouble self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_double self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsDoubleMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsDoubleMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsDouble

instance O.OverloadedMethodInfo SpaPodIsDoubleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsDouble",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsDouble"
        })


#endif

-- method SpaPod::is_fd
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_fd" wp_spa_pod_is_fd :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type Fd or not.
spaPodIsFd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type Fd, FALSE otherwise
spaPodIsFd self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_fd self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsFdMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFdMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsFd

instance O.OverloadedMethodInfo SpaPodIsFdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFd"
        })


#endif

-- method SpaPod::is_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_float" wp_spa_pod_is_float :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type float or not.
spaPodIsFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type float, FALSE otherwise
spaPodIsFloat self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_float self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsFloatMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFloatMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsFloat

instance O.OverloadedMethodInfo SpaPodIsFloatMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFloat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFloat"
        })


#endif

-- method SpaPod::is_fraction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_fraction" wp_spa_pod_is_fraction :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type fraction or not.
spaPodIsFraction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type fraction, FALSE otherwise
spaPodIsFraction self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_fraction self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsFractionMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFractionMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsFraction

instance O.OverloadedMethodInfo SpaPodIsFractionMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFraction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFraction"
        })


#endif

-- method SpaPod::is_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_id" wp_spa_pod_is_id :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type Id or not.
spaPodIsId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type Id, FALSE otherwise
spaPodIsId self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_id self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsIdMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsIdMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsId

instance O.OverloadedMethodInfo SpaPodIsIdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsId"
        })


#endif

-- method SpaPod::is_int
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_int" wp_spa_pod_is_int :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type int or not.
spaPodIsInt ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type int, FALSE otherwise
spaPodIsInt self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_int self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsIntMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsIntMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsInt

instance O.OverloadedMethodInfo SpaPodIsIntMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsInt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsInt"
        })


#endif

-- method SpaPod::is_long
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_long" wp_spa_pod_is_long :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type long or not.
spaPodIsLong ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type long, FALSE otherwise
spaPodIsLong self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_long self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsLongMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsLongMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsLong

instance O.OverloadedMethodInfo SpaPodIsLongMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsLong",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsLong"
        })


#endif

-- method SpaPod::is_none
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_none" wp_spa_pod_is_none :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type none or not.
spaPodIsNone ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type none, FALSE otherwise
spaPodIsNone self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_none self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsNoneMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsNoneMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsNone

instance O.OverloadedMethodInfo SpaPodIsNoneMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsNone",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsNone"
        })


#endif

-- method SpaPod::is_object
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_object" wp_spa_pod_is_object :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type object or not.
spaPodIsObject ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type object, FALSE otherwise
spaPodIsObject self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_object self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsObjectMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsObjectMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsObject

instance O.OverloadedMethodInfo SpaPodIsObjectMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsObject"
        })


#endif

-- method SpaPod::is_pointer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_pointer" wp_spa_pod_is_pointer :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type pointer or not.
spaPodIsPointer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type pointer, FALSE otherwise
spaPodIsPointer self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_pointer self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsPointerMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsPointerMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsPointer

instance O.OverloadedMethodInfo SpaPodIsPointerMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsPointer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsPointer"
        })


#endif

-- method SpaPod::is_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_property" wp_spa_pod_is_property :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type property or not.
spaPodIsProperty ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type property, FALSE otherwise
spaPodIsProperty self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_property self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsPropertyMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsPropertyMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsProperty

instance O.OverloadedMethodInfo SpaPodIsPropertyMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsProperty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsProperty"
        })


#endif

-- method SpaPod::is_rectangle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_rectangle" wp_spa_pod_is_rectangle :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type rectangle or not.
spaPodIsRectangle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type rectangle, FALSE otherwise
spaPodIsRectangle self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_rectangle self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsRectangleMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsRectangleMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsRectangle

instance O.OverloadedMethodInfo SpaPodIsRectangleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsRectangle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsRectangle"
        })


#endif

-- method SpaPod::is_sequence
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_sequence" wp_spa_pod_is_sequence :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type sequence or not.
spaPodIsSequence ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type sequence, FALSE otherwise
spaPodIsSequence self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_sequence self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsSequenceMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsSequenceMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsSequence

instance O.OverloadedMethodInfo SpaPodIsSequenceMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsSequence",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsSequence"
        })


#endif

-- method SpaPod::is_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_string" wp_spa_pod_is_string :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type string or not.
spaPodIsString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type string, FALSE otherwise
spaPodIsString self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_string self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsStringMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsStringMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsString

instance O.OverloadedMethodInfo SpaPodIsStringMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsString",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsString"
        })


#endif

-- method SpaPod::is_struct
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , 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 "wp_spa_pod_is_struct" wp_spa_pod_is_struct :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks whether the spa pod is of type struct or not.
spaPodIsStruct ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if it is of type struct, FALSE otherwise
spaPodIsStruct self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_struct self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsStructMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsStructMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsStruct

instance O.OverloadedMethodInfo SpaPodIsStructMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsStruct",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsStruct"
        })


#endif

-- method SpaPod::is_unique_owner
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , 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 "wp_spa_pod_is_unique_owner" wp_spa_pod_is_unique_owner :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Checks if the pod is the unique owner of its data or not.
spaPodIsUniqueOwner ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod object
    -> m Bool
    -- ^ __Returns:__ TRUE if the pod owns the data, FALSE otherwise.
spaPodIsUniqueOwner self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_is_unique_owner self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodIsUniqueOwnerMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsUniqueOwnerMethodInfo SpaPod signature where
    overloadedMethod = spaPodIsUniqueOwner

instance O.OverloadedMethodInfo SpaPodIsUniqueOwnerMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsUniqueOwner",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsUniqueOwner"
        })


#endif

-- method SpaPod::new_iterator
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pod"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_new_iterator" wp_spa_pod_new_iterator :: 
    Ptr SpaPod ->                           -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr Wp.Iterator.Iterator)

-- | Creates a new iterator for a spa pod object.
spaPodNewIterator ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@pod@/: a spa pod object
    -> m Wp.Iterator.Iterator
    -- ^ __Returns:__ the new spa pod iterator
spaPodNewIterator pod = liftIO $ do
    pod' <- unsafeManagedPtrGetPtr pod
    result <- wp_spa_pod_new_iterator pod'
    checkUnexpectedReturnNULL "spaPodNewIterator" result
    result' <- (wrapBoxed Wp.Iterator.Iterator) result
    touchManagedPtr pod
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodNewIteratorMethodInfo
instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m) => O.OverloadedMethod SpaPodNewIteratorMethodInfo SpaPod signature where
    overloadedMethod = spaPodNewIterator

instance O.OverloadedMethodInfo SpaPodNewIteratorMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodNewIterator",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodNewIterator"
        })


#endif

-- method SpaPod::ref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" })
-- throws : False
-- Skip return : False

foreign import ccall "wp_spa_pod_ref" wp_spa_pod_ref :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO (Ptr SpaPod)

-- | Increases the reference count of a spa pod object.
spaPodRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod object
    -> m SpaPod
    -- ^ __Returns:__ /@self@/ with an additional reference count on it
spaPodRef self = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_ref self'
    checkUnexpectedReturnNULL "spaPodRef" result
    result' <- (wrapBoxed SpaPod) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodRefMethodInfo
instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodRefMethodInfo SpaPod signature where
    overloadedMethod = spaPodRef

instance O.OverloadedMethodInfo SpaPodRefMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodRef",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodRef"
        })


#endif

-- method SpaPod::set_boolean
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the boolean 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 "wp_spa_pod_set_boolean" wp_spa_pod_set_boolean :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO CInt

-- | Sets a boolean value in the spa pod object.
spaPodSetBoolean ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Bool
    -- ^ /@value@/: the boolean value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetBoolean self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    let value' = (P.fromIntegral . P.fromEnum) value
    result <- wp_spa_pod_set_boolean self' value'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetBooleanMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetBooleanMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetBoolean

instance O.OverloadedMethodInfo SpaPodSetBooleanMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetBoolean",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetBoolean"
        })


#endif

-- method SpaPod::set_double
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , argCType = Just "double"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the double 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 "wp_spa_pod_set_double" wp_spa_pod_set_double :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    CDouble ->                              -- value : TBasicType TDouble
    IO CInt

-- | Sets a double value in the spa pod object.
spaPodSetDouble ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Double
    -- ^ /@value@/: the double value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetDouble self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    let value' = realToFrac value
    result <- wp_spa_pod_set_double self' value'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetDoubleMethodInfo
instance (signature ~ (Double -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetDoubleMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetDouble

instance O.OverloadedMethodInfo SpaPodSetDoubleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetDouble",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetDouble"
        })


#endif

-- method SpaPod::set_fd
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Fd 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 "wp_spa_pod_set_fd" wp_spa_pod_set_fd :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Int64 ->                                -- value : TBasicType TInt64
    IO CInt

-- | Sets a Fd value in the spa pod object.
spaPodSetFd ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Int64
    -- ^ /@value@/: the Fd value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetFd self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_fd self' value
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetFdMethodInfo
instance (signature ~ (Int64 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFdMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetFd

instance O.OverloadedMethodInfo SpaPodSetFdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFd"
        })


#endif

-- method SpaPod::set_float
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TFloat
--           , argCType = Just "float"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the float 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 "wp_spa_pod_set_float" wp_spa_pod_set_float :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    CFloat ->                               -- value : TBasicType TFloat
    IO CInt

-- | Sets a float value in the spa pod object.
spaPodSetFloat ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Float
    -- ^ /@value@/: the float value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetFloat self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    let value' = realToFrac value
    result <- wp_spa_pod_set_float self' value'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetFloatMethodInfo
instance (signature ~ (Float -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFloatMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetFloat

instance O.OverloadedMethodInfo SpaPodSetFloatMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFloat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFloat"
        })


#endif

-- method SpaPod::set_fraction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "num"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the numerator value of the fraction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "denom"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the denominator value of the fraction"
--                 , 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 "wp_spa_pod_set_fraction" wp_spa_pod_set_fraction :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Word32 ->                               -- num : TBasicType TUInt32
    Word32 ->                               -- denom : TBasicType TUInt32
    IO CInt

-- | Sets the numerator and denominator values of a fraction in the spa pod object.
spaPodSetFraction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Word32
    -- ^ /@num@/: the numerator value of the fraction
    -> Word32
    -- ^ /@denom@/: the denominator value of the fraction
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetFraction self num denom = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_fraction self' num denom
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetFractionMethodInfo
instance (signature ~ (Word32 -> Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFractionMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetFraction

instance O.OverloadedMethodInfo SpaPodSetFractionMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFraction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFraction"
        })


#endif

-- method SpaPod::set_id
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the Id 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 "wp_spa_pod_set_id" wp_spa_pod_set_id :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Word32 ->                               -- value : TBasicType TUInt32
    IO CInt

-- | Sets an Id value in the spa pod object.
spaPodSetId ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Word32
    -- ^ /@value@/: the Id value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetId self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_id self' value
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetIdMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetIdMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetId

instance O.OverloadedMethodInfo SpaPodSetIdMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetId"
        })


#endif

-- method SpaPod::set_int
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt32
--           , argCType = Just "gint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the int 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 "wp_spa_pod_set_int" wp_spa_pod_set_int :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Int32 ->                                -- value : TBasicType TInt32
    IO CInt

-- | Sets an int value in the spa pod object.
spaPodSetInt ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Int32
    -- ^ /@value@/: the int value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetInt self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_int self' value
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetIntMethodInfo
instance (signature ~ (Int32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetIntMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetInt

instance O.OverloadedMethodInfo SpaPodSetIntMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetInt",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetInt"
        })


#endif

-- method SpaPod::set_long
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , argCType = Just "gint64"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the long 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 "wp_spa_pod_set_long" wp_spa_pod_set_long :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Int64 ->                                -- value : TBasicType TInt64
    IO CInt

-- | Sets a long value in the spa pod object.
spaPodSetLong ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Int64
    -- ^ /@value@/: the long value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetLong self value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_long self' value
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetLongMethodInfo
instance (signature ~ (Int64 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetLongMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetLong

instance O.OverloadedMethodInfo SpaPodSetLongMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetLong",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetLong"
        })


#endif

-- method SpaPod::set_pod
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pod"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pod with the value to be set"
--                 , 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 "wp_spa_pod_set_pod" wp_spa_pod_set_pod :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Ptr SpaPod ->                           -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO CInt

-- | Sets the value of a spa pod object in the current spa pod object. The spa pod objects must be of the same value.
spaPodSetPod ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> SpaPod
    -- ^ /@pod@/: the pod with the value to be set
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetPod self pod = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    pod' <- unsafeManagedPtrGetPtr pod
    result <- wp_spa_pod_set_pod self' pod'
    let result' = (/= 0) result
    touchManagedPtr self
    touchManagedPtr pod
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetPodMethodInfo
instance (signature ~ (SpaPod -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetPodMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetPod

instance O.OverloadedMethodInfo SpaPodSetPodMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetPod",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetPod"
        })


#endif

-- method SpaPod::set_pointer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const char*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the type of the pointer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TPtr
--           , argCType = Just "gconstpointer"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pointer 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 "wp_spa_pod_set_pointer" wp_spa_pod_set_pointer :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    CString ->                              -- type_name : TBasicType TUTF8
    Ptr () ->                               -- value : TBasicType TPtr
    IO CInt

-- | Sets a pointer value with its type name in the spa pod object.
spaPodSetPointer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> T.Text
    -- ^ /@typeName@/: the name of the type of the pointer
    -> Ptr ()
    -- ^ /@value@/: the pointer value
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetPointer self typeName value = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    typeName' <- textToCString typeName
    result <- wp_spa_pod_set_pointer self' typeName' value
    let result' = (/= 0) result
    touchManagedPtr self
    freeMem typeName'
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetPointerMethodInfo
instance (signature ~ (T.Text -> Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetPointerMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetPointer

instance O.OverloadedMethodInfo SpaPodSetPointerMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetPointer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetPointer"
        })


#endif

-- method SpaPod::set_rectangle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the spa pod object" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the width value of the rectangle"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TUInt32
--           , argCType = Just "guint32"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the height value of the rectangle"
--                 , 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 "wp_spa_pod_set_rectangle" wp_spa_pod_set_rectangle :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    Word32 ->                               -- width : TBasicType TUInt32
    Word32 ->                               -- height : TBasicType TUInt32
    IO CInt

-- | Sets the width and height values of a rectangle in the spa pod object.
spaPodSetRectangle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: the spa pod object
    -> Word32
    -- ^ /@width@/: the width value of the rectangle
    -> Word32
    -- ^ /@height@/: the height value of the rectangle
    -> m Bool
    -- ^ __Returns:__ TRUE if the value could be set, FALSE otherwise.
spaPodSetRectangle self width height = liftIO $ do
    self' <- unsafeManagedPtrGetPtr self
    result <- wp_spa_pod_set_rectangle self' width height
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING)
data SpaPodSetRectangleMethodInfo
instance (signature ~ (Word32 -> Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetRectangleMethodInfo SpaPod signature where
    overloadedMethod = spaPodSetRectangle

instance O.OverloadedMethodInfo SpaPodSetRectangleMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetRectangle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetRectangle"
        })


#endif

-- method SpaPod::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" }
--           , argCType = Just "WpSpaPod*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spa pod object" , 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 "wp_spa_pod_unref" wp_spa_pod_unref :: 
    Ptr SpaPod ->                           -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"})
    IO ()

-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero.
spaPodUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SpaPod
    -- ^ /@self@/: a spa pod object
    -> m ()
spaPodUnref self = liftIO $ do
    self' <- B.ManagedPtr.disownBoxed self
    wp_spa_pod_unref self'
    touchManagedPtr self
    return ()

#if defined(ENABLE_OVERLOADING)
data SpaPodUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodUnrefMethodInfo SpaPod signature where
    overloadedMethod = spaPodUnref

instance O.OverloadedMethodInfo SpaPodUnrefMethodInfo SpaPod where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodUnref",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14.2/docs/GI-Wp-Structs-SpaPod.html#v:spaPodUnref"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveSpaPodMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSpaPodMethod "copy" o = SpaPodCopyMethodInfo
    ResolveSpaPodMethod "ensureUniqueOwner" o = SpaPodEnsureUniqueOwnerMethodInfo
    ResolveSpaPodMethod "equal" o = SpaPodEqualMethodInfo
    ResolveSpaPodMethod "filter" o = SpaPodFilterMethodInfo
    ResolveSpaPodMethod "fixate" o = SpaPodFixateMethodInfo
    ResolveSpaPodMethod "isArray" o = SpaPodIsArrayMethodInfo
    ResolveSpaPodMethod "isBoolean" o = SpaPodIsBooleanMethodInfo
    ResolveSpaPodMethod "isBytes" o = SpaPodIsBytesMethodInfo
    ResolveSpaPodMethod "isChoice" o = SpaPodIsChoiceMethodInfo
    ResolveSpaPodMethod "isControl" o = SpaPodIsControlMethodInfo
    ResolveSpaPodMethod "isDouble" o = SpaPodIsDoubleMethodInfo
    ResolveSpaPodMethod "isFd" o = SpaPodIsFdMethodInfo
    ResolveSpaPodMethod "isFloat" o = SpaPodIsFloatMethodInfo
    ResolveSpaPodMethod "isFraction" o = SpaPodIsFractionMethodInfo
    ResolveSpaPodMethod "isId" o = SpaPodIsIdMethodInfo
    ResolveSpaPodMethod "isInt" o = SpaPodIsIntMethodInfo
    ResolveSpaPodMethod "isLong" o = SpaPodIsLongMethodInfo
    ResolveSpaPodMethod "isNone" o = SpaPodIsNoneMethodInfo
    ResolveSpaPodMethod "isObject" o = SpaPodIsObjectMethodInfo
    ResolveSpaPodMethod "isPointer" o = SpaPodIsPointerMethodInfo
    ResolveSpaPodMethod "isProperty" o = SpaPodIsPropertyMethodInfo
    ResolveSpaPodMethod "isRectangle" o = SpaPodIsRectangleMethodInfo
    ResolveSpaPodMethod "isSequence" o = SpaPodIsSequenceMethodInfo
    ResolveSpaPodMethod "isString" o = SpaPodIsStringMethodInfo
    ResolveSpaPodMethod "isStruct" o = SpaPodIsStructMethodInfo
    ResolveSpaPodMethod "isUniqueOwner" o = SpaPodIsUniqueOwnerMethodInfo
    ResolveSpaPodMethod "newIterator" o = SpaPodNewIteratorMethodInfo
    ResolveSpaPodMethod "ref" o = SpaPodRefMethodInfo
    ResolveSpaPodMethod "unref" o = SpaPodUnrefMethodInfo
    ResolveSpaPodMethod "getArrayChild" o = SpaPodGetArrayChildMethodInfo
    ResolveSpaPodMethod "getBoolean" o = SpaPodGetBooleanMethodInfo
    ResolveSpaPodMethod "getBytes" o = SpaPodGetBytesMethodInfo
    ResolveSpaPodMethod "getChoiceChild" o = SpaPodGetChoiceChildMethodInfo
    ResolveSpaPodMethod "getChoiceType" o = SpaPodGetChoiceTypeMethodInfo
    ResolveSpaPodMethod "getControl" o = SpaPodGetControlMethodInfo
    ResolveSpaPodMethod "getDouble" o = SpaPodGetDoubleMethodInfo
    ResolveSpaPodMethod "getFd" o = SpaPodGetFdMethodInfo
    ResolveSpaPodMethod "getFloat" o = SpaPodGetFloatMethodInfo
    ResolveSpaPodMethod "getFraction" o = SpaPodGetFractionMethodInfo
    ResolveSpaPodMethod "getId" o = SpaPodGetIdMethodInfo
    ResolveSpaPodMethod "getInt" o = SpaPodGetIntMethodInfo
    ResolveSpaPodMethod "getLong" o = SpaPodGetLongMethodInfo
    ResolveSpaPodMethod "getPointer" o = SpaPodGetPointerMethodInfo
    ResolveSpaPodMethod "getProperty" o = SpaPodGetPropertyMethodInfo
    ResolveSpaPodMethod "getRectangle" o = SpaPodGetRectangleMethodInfo
    ResolveSpaPodMethod "getSpaPod" o = SpaPodGetSpaPodMethodInfo
    ResolveSpaPodMethod "getSpaType" o = SpaPodGetSpaTypeMethodInfo
    ResolveSpaPodMethod "getString" o = SpaPodGetStringMethodInfo
    ResolveSpaPodMethod "setBoolean" o = SpaPodSetBooleanMethodInfo
    ResolveSpaPodMethod "setDouble" o = SpaPodSetDoubleMethodInfo
    ResolveSpaPodMethod "setFd" o = SpaPodSetFdMethodInfo
    ResolveSpaPodMethod "setFloat" o = SpaPodSetFloatMethodInfo
    ResolveSpaPodMethod "setFraction" o = SpaPodSetFractionMethodInfo
    ResolveSpaPodMethod "setId" o = SpaPodSetIdMethodInfo
    ResolveSpaPodMethod "setInt" o = SpaPodSetIntMethodInfo
    ResolveSpaPodMethod "setLong" o = SpaPodSetLongMethodInfo
    ResolveSpaPodMethod "setPod" o = SpaPodSetPodMethodInfo
    ResolveSpaPodMethod "setPointer" o = SpaPodSetPointerMethodInfo
    ResolveSpaPodMethod "setRectangle" o = SpaPodSetRectangleMethodInfo
    ResolveSpaPodMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif


