    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    The data structure representing a lexical scanner.

    You should set /@inputName@/ after creating the scanner, since
    it is used by the default message handler when displaying
    warnings and errors. If you are scanning a file, the filename
    would be a good choice.

    The /@userData@/ and /@maxParseErrors@/ fields are not used.
    If you need to associate extra data with the scanner you
    can place them here.

    If you want to use your own message handler you can set the
    /@msgHandler@/ field. The type of the message handler function
    is declared by 'GI.GLib.Callbacks.ScannerMsgFunc'.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.GLib.Structs.Scanner
        (

    -- * Exported types
        Scanner(..)                             ,
        newZeroScanner                          ,
        noScanner                               ,

     -- * Methods
    -- ** curLine #method:curLine#

    #if ENABLE_OVERLOADING
        ScannerCurLineMethodInfo                ,
    #endif
        scannerCurLine                          ,

    -- ** curPosition #method:curPosition#

    #if ENABLE_OVERLOADING
        ScannerCurPositionMethodInfo            ,
    #endif
        scannerCurPosition                      ,

    -- ** curToken #method:curToken#

    #if ENABLE_OVERLOADING
        ScannerCurTokenMethodInfo               ,
    #endif
        scannerCurToken                         ,

    -- ** destroy #method:destroy#

    #if ENABLE_OVERLOADING
        ScannerDestroyMethodInfo                ,
    #endif
        scannerDestroy                          ,

    -- ** eof #method:eof#

    #if ENABLE_OVERLOADING
        ScannerEofMethodInfo                    ,
    #endif
        scannerEof                              ,

    -- ** getNextToken #method:getNextToken#

    #if ENABLE_OVERLOADING
        ScannerGetNextTokenMethodInfo           ,
    #endif
        scannerGetNextToken                     ,

    -- ** inputFile #method:inputFile#

    #if ENABLE_OVERLOADING
        ScannerInputFileMethodInfo              ,
    #endif
        scannerInputFile                        ,

    -- ** inputText #method:inputText#

    #if ENABLE_OVERLOADING
        ScannerInputTextMethodInfo              ,
    #endif
        scannerInputText                        ,

    -- ** lookupSymbol #method:lookupSymbol#

    #if ENABLE_OVERLOADING
        ScannerLookupSymbolMethodInfo           ,
    #endif
        scannerLookupSymbol                     ,

    -- ** peekNextToken #method:peekNextToken#

    #if ENABLE_OVERLOADING
        ScannerPeekNextTokenMethodInfo          ,
    #endif
        scannerPeekNextToken                    ,

    -- ** scopeAddSymbol #method:scopeAddSymbol#

    #if ENABLE_OVERLOADING
        ScannerScopeAddSymbolMethodInfo         ,
    #endif
        scannerScopeAddSymbol                   ,

    -- ** scopeLookupSymbol #method:scopeLookupSymbol#

    #if ENABLE_OVERLOADING
        ScannerScopeLookupSymbolMethodInfo      ,
    #endif
        scannerScopeLookupSymbol                ,

    -- ** scopeRemoveSymbol #method:scopeRemoveSymbol#

    #if ENABLE_OVERLOADING
        ScannerScopeRemoveSymbolMethodInfo      ,
    #endif
        scannerScopeRemoveSymbol                ,

    -- ** setScope #method:setScope#

    #if ENABLE_OVERLOADING
        ScannerSetScopeMethodInfo               ,
    #endif
        scannerSetScope                         ,

    -- ** syncFileOffset #method:syncFileOffset#

    #if ENABLE_OVERLOADING
        ScannerSyncFileOffsetMethodInfo         ,
    #endif
        scannerSyncFileOffset                   ,

    -- ** unexpToken #method:unexpToken#

    #if ENABLE_OVERLOADING
        ScannerUnexpTokenMethodInfo             ,
    #endif
        scannerUnexpToken                       ,

     -- * Properties
    -- ** config #attr:config#
    {- | link into the scanner configuration
    -}
        clearScannerConfig                      ,
        getScannerConfig                        ,
    #if ENABLE_OVERLOADING
        scanner_config                          ,
    #endif
        setScannerConfig                        ,

    -- ** inputName #attr:inputName#
    {- | name of input stream, featured by the default message handler
    -}
        clearScannerInputName                   ,
        getScannerInputName                     ,
    #if ENABLE_OVERLOADING
        scanner_inputName                       ,
    #endif
        setScannerInputName                     ,

    -- ** line #attr:line#
    {- | line number of the last token from 'GI.GLib.Structs.Scanner.scannerGetNextToken'
    -}
        getScannerLine                          ,
    #if ENABLE_OVERLOADING
        scanner_line                            ,
    #endif
        setScannerLine                          ,

    -- ** maxParseErrors #attr:maxParseErrors#
    {- | unused
    -}
        getScannerMaxParseErrors                ,
    #if ENABLE_OVERLOADING
        scanner_maxParseErrors                  ,
    #endif
        setScannerMaxParseErrors                ,

    -- ** msgHandler #attr:msgHandler#
    {- | handler function for _warn and _error
    -}
        clearScannerMsgHandler                  ,
        getScannerMsgHandler                    ,
    #if ENABLE_OVERLOADING
        scanner_msgHandler                      ,
    #endif
        setScannerMsgHandler                    ,

    -- ** nextLine #attr:nextLine#
    {- | line number of the last token from 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    -}
        getScannerNextLine                      ,
    #if ENABLE_OVERLOADING
        scanner_nextLine                        ,
    #endif
        setScannerNextLine                      ,

    -- ** nextPosition #attr:nextPosition#
    {- | char number of the last token from 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    -}
        getScannerNextPosition                  ,
    #if ENABLE_OVERLOADING
        scanner_nextPosition                    ,
    #endif
        setScannerNextPosition                  ,

    -- ** nextToken #attr:nextToken#
    {- | token parsed by the last 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    -}
        getScannerNextToken                     ,
    #if ENABLE_OVERLOADING
        scanner_nextToken                       ,
    #endif
        setScannerNextToken                     ,

    -- ** nextValue #attr:nextValue#
    {- | value of the last token from 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    -}
        getScannerNextValue                     ,
    #if ENABLE_OVERLOADING
        scanner_nextValue                       ,
    #endif

    -- ** parseErrors #attr:parseErrors#
    {- | @/g_scanner_error()/@ increments this field
    -}
        getScannerParseErrors                   ,
    #if ENABLE_OVERLOADING
        scanner_parseErrors                     ,
    #endif
        setScannerParseErrors                   ,

    -- ** position #attr:position#
    {- | char number of the last token from 'GI.GLib.Structs.Scanner.scannerGetNextToken'
    -}
        getScannerPosition                      ,
    #if ENABLE_OVERLOADING
        scanner_position                        ,
    #endif
        setScannerPosition                      ,

    -- ** qdata #attr:qdata#
    {- | quarked data
    -}
        clearScannerQdata                       ,
        getScannerQdata                         ,
    #if ENABLE_OVERLOADING
        scanner_qdata                           ,
    #endif
        setScannerQdata                         ,

    -- ** token #attr:token#
    {- | token parsed by the last 'GI.GLib.Structs.Scanner.scannerGetNextToken'
    -}
        getScannerToken                         ,
    #if ENABLE_OVERLOADING
        scanner_token                           ,
    #endif
        setScannerToken                         ,

    -- ** userData #attr:userData#
    {- | unused
    -}
        clearScannerUserData                    ,
        getScannerUserData                      ,
    #if ENABLE_OVERLOADING
        scanner_userData                        ,
    #endif
        setScannerUserData                      ,

    -- ** value #attr:value#
    {- | value of the last token from 'GI.GLib.Structs.Scanner.scannerGetNextToken'
    -}
        getScannerValue                         ,
    #if ENABLE_OVERLOADING
        scanner_value                           ,
    #endif

        ) 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.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GLib.Callbacks as GLib.Callbacks
    import {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
    import {-# SOURCE #-} qualified GI.GLib.Structs.Data as GLib.Data
    import {-# SOURCE #-} qualified GI.GLib.Structs.ScannerConfig as GLib.ScannerConfig
    import {-# SOURCE #-} qualified GI.GLib.Unions.TokenValue as GLib.TokenValue

    -- | Memory-managed wrapper type.
    newtype Scanner = Scanner (ManagedPtr Scanner)
    instance WrappedPtr Scanner where
        wrappedPtrCalloc = callocBytes 144
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 144 >=> wrapPtr Scanner)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `Scanner` struct initialized to zero.
    newZeroScanner :: MonadIO m => m Scanner
    newZeroScanner = liftIO $ wrappedPtrCalloc >>= wrapPtr Scanner

    instance tag ~ 'AttrSet => Constructible Scanner tag where
        new _ attrs = do
            o <- newZeroScanner
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `Scanner`.
    noScanner :: Maybe Scanner
    noScanner = Nothing

    {- |
    Get the value of the “@user_data@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #userData
    @
    -}
    getScannerUserData :: MonadIO m => Scanner -> m (Ptr ())
    getScannerUserData s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
        return val

    {- |
    Set the value of the “@user_data@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #userData 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerUserData :: MonadIO m => Scanner -> Ptr () -> m ()
    setScannerUserData s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (val :: Ptr ())

    {- |
    Set the value of the “@user_data@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #userData
    @
    -}
    clearScannerUserData :: MonadIO m => Scanner -> m ()
    clearScannerUserData s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr ())

    #if ENABLE_OVERLOADING
    data ScannerUserDataFieldInfo
    instance AttrInfo ScannerUserDataFieldInfo where
        type AttrAllowedOps ScannerUserDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ScannerUserDataFieldInfo = (~) (Ptr ())
        type AttrBaseTypeConstraint ScannerUserDataFieldInfo = (~) Scanner
        type AttrGetType ScannerUserDataFieldInfo = Ptr ()
        type AttrLabel ScannerUserDataFieldInfo = "user_data"
        type AttrOrigin ScannerUserDataFieldInfo = Scanner
        attrGet _ = getScannerUserData
        attrSet _ = setScannerUserData
        attrConstruct = undefined
        attrClear _ = clearScannerUserData

    scanner_userData :: AttrLabelProxy "userData"
    scanner_userData = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@max_parse_errors@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #maxParseErrors
    @
    -}
    getScannerMaxParseErrors :: MonadIO m => Scanner -> m Word32
    getScannerMaxParseErrors s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO Word32
        return val

    {- |
    Set the value of the “@max_parse_errors@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #maxParseErrors 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerMaxParseErrors :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerMaxParseErrors s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerMaxParseErrorsFieldInfo
    instance AttrInfo ScannerMaxParseErrorsFieldInfo where
        type AttrAllowedOps ScannerMaxParseErrorsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerMaxParseErrorsFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerMaxParseErrorsFieldInfo = (~) Scanner
        type AttrGetType ScannerMaxParseErrorsFieldInfo = Word32
        type AttrLabel ScannerMaxParseErrorsFieldInfo = "max_parse_errors"
        type AttrOrigin ScannerMaxParseErrorsFieldInfo = Scanner
        attrGet _ = getScannerMaxParseErrors
        attrSet _ = setScannerMaxParseErrors
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_maxParseErrors :: AttrLabelProxy "maxParseErrors"
    scanner_maxParseErrors = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@parse_errors@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #parseErrors
    @
    -}
    getScannerParseErrors :: MonadIO m => Scanner -> m Word32
    getScannerParseErrors s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 12) :: IO Word32
        return val

    {- |
    Set the value of the “@parse_errors@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #parseErrors 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerParseErrors :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerParseErrors s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 12) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerParseErrorsFieldInfo
    instance AttrInfo ScannerParseErrorsFieldInfo where
        type AttrAllowedOps ScannerParseErrorsFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerParseErrorsFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerParseErrorsFieldInfo = (~) Scanner
        type AttrGetType ScannerParseErrorsFieldInfo = Word32
        type AttrLabel ScannerParseErrorsFieldInfo = "parse_errors"
        type AttrOrigin ScannerParseErrorsFieldInfo = Scanner
        attrGet _ = getScannerParseErrors
        attrSet _ = setScannerParseErrors
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_parseErrors :: AttrLabelProxy "parseErrors"
    scanner_parseErrors = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@input_name@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #inputName
    @
    -}
    getScannerInputName :: MonadIO m => Scanner -> m (Maybe T.Text)
    getScannerInputName s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO CString
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- cstringToText val'
            return val''
        return result

    {- |
    Set the value of the “@input_name@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #inputName 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerInputName :: MonadIO m => Scanner -> CString -> m ()
    setScannerInputName s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: CString)

    {- |
    Set the value of the “@input_name@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #inputName
    @
    -}
    clearScannerInputName :: MonadIO m => Scanner -> m ()
    clearScannerInputName s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

    #if ENABLE_OVERLOADING
    data ScannerInputNameFieldInfo
    instance AttrInfo ScannerInputNameFieldInfo where
        type AttrAllowedOps ScannerInputNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ScannerInputNameFieldInfo = (~) CString
        type AttrBaseTypeConstraint ScannerInputNameFieldInfo = (~) Scanner
        type AttrGetType ScannerInputNameFieldInfo = Maybe T.Text
        type AttrLabel ScannerInputNameFieldInfo = "input_name"
        type AttrOrigin ScannerInputNameFieldInfo = Scanner
        attrGet _ = getScannerInputName
        attrSet _ = setScannerInputName
        attrConstruct = undefined
        attrClear _ = clearScannerInputName

    scanner_inputName :: AttrLabelProxy "inputName"
    scanner_inputName = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@qdata@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #qdata
    @
    -}
    getScannerQdata :: MonadIO m => Scanner -> m (Maybe GLib.Data.Data)
    getScannerQdata s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 24) :: IO (Ptr GLib.Data.Data)
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- (newPtr GLib.Data.Data) val'
            return val''
        return result

    {- |
    Set the value of the “@qdata@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #qdata 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerQdata :: MonadIO m => Scanner -> Ptr GLib.Data.Data -> m ()
    setScannerQdata s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (val :: Ptr GLib.Data.Data)

    {- |
    Set the value of the “@qdata@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #qdata
    @
    -}
    clearScannerQdata :: MonadIO m => Scanner -> m ()
    clearScannerQdata s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr GLib.Data.Data)

    #if ENABLE_OVERLOADING
    data ScannerQdataFieldInfo
    instance AttrInfo ScannerQdataFieldInfo where
        type AttrAllowedOps ScannerQdataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ScannerQdataFieldInfo = (~) (Ptr GLib.Data.Data)
        type AttrBaseTypeConstraint ScannerQdataFieldInfo = (~) Scanner
        type AttrGetType ScannerQdataFieldInfo = Maybe GLib.Data.Data
        type AttrLabel ScannerQdataFieldInfo = "qdata"
        type AttrOrigin ScannerQdataFieldInfo = Scanner
        attrGet _ = getScannerQdata
        attrSet _ = setScannerQdata
        attrConstruct = undefined
        attrClear _ = clearScannerQdata

    scanner_qdata :: AttrLabelProxy "qdata"
    scanner_qdata = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@config@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #config
    @
    -}
    getScannerConfig :: MonadIO m => Scanner -> m (Maybe GLib.ScannerConfig.ScannerConfig)
    getScannerConfig s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 32) :: IO (Ptr GLib.ScannerConfig.ScannerConfig)
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- (newPtr GLib.ScannerConfig.ScannerConfig) val'
            return val''
        return result

    {- |
    Set the value of the “@config@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #config 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerConfig :: MonadIO m => Scanner -> Ptr GLib.ScannerConfig.ScannerConfig -> m ()
    setScannerConfig s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (val :: Ptr GLib.ScannerConfig.ScannerConfig)

    {- |
    Set the value of the “@config@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #config
    @
    -}
    clearScannerConfig :: MonadIO m => Scanner -> m ()
    clearScannerConfig s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr GLib.ScannerConfig.ScannerConfig)

    #if ENABLE_OVERLOADING
    data ScannerConfigFieldInfo
    instance AttrInfo ScannerConfigFieldInfo where
        type AttrAllowedOps ScannerConfigFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ScannerConfigFieldInfo = (~) (Ptr GLib.ScannerConfig.ScannerConfig)
        type AttrBaseTypeConstraint ScannerConfigFieldInfo = (~) Scanner
        type AttrGetType ScannerConfigFieldInfo = Maybe GLib.ScannerConfig.ScannerConfig
        type AttrLabel ScannerConfigFieldInfo = "config"
        type AttrOrigin ScannerConfigFieldInfo = Scanner
        attrGet _ = getScannerConfig
        attrSet _ = setScannerConfig
        attrConstruct = undefined
        attrClear _ = clearScannerConfig

    scanner_config :: AttrLabelProxy "config"
    scanner_config = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@token@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #token
    @
    -}
    getScannerToken :: MonadIO m => Scanner -> m GLib.Enums.TokenType
    getScannerToken s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 40) :: IO CUInt
        let val' = (toEnum . fromIntegral) val
        return val'

    {- |
    Set the value of the “@token@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #token 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerToken :: MonadIO m => Scanner -> GLib.Enums.TokenType -> m ()
    setScannerToken s val = liftIO $ withManagedPtr s $ \ptr -> do
        let val' = (fromIntegral . fromEnum) val
        poke (ptr `plusPtr` 40) (val' :: CUInt)

    #if ENABLE_OVERLOADING
    data ScannerTokenFieldInfo
    instance AttrInfo ScannerTokenFieldInfo where
        type AttrAllowedOps ScannerTokenFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerTokenFieldInfo = (~) GLib.Enums.TokenType
        type AttrBaseTypeConstraint ScannerTokenFieldInfo = (~) Scanner
        type AttrGetType ScannerTokenFieldInfo = GLib.Enums.TokenType
        type AttrLabel ScannerTokenFieldInfo = "token"
        type AttrOrigin ScannerTokenFieldInfo = Scanner
        attrGet _ = getScannerToken
        attrSet _ = setScannerToken
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_token :: AttrLabelProxy "token"
    scanner_token = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@value@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #value
    @
    -}
    getScannerValue :: MonadIO m => Scanner -> m GLib.TokenValue.TokenValue
    getScannerValue s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 48 :: (Ptr GLib.TokenValue.TokenValue)
        val' <- (newPtr GLib.TokenValue.TokenValue) val
        return val'

    #if ENABLE_OVERLOADING
    data ScannerValueFieldInfo
    instance AttrInfo ScannerValueFieldInfo where
        type AttrAllowedOps ScannerValueFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ScannerValueFieldInfo = (~) (Ptr GLib.TokenValue.TokenValue)
        type AttrBaseTypeConstraint ScannerValueFieldInfo = (~) Scanner
        type AttrGetType ScannerValueFieldInfo = GLib.TokenValue.TokenValue
        type AttrLabel ScannerValueFieldInfo = "value"
        type AttrOrigin ScannerValueFieldInfo = Scanner
        attrGet _ = getScannerValue
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_value :: AttrLabelProxy "value"
    scanner_value = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@line@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #line
    @
    -}
    getScannerLine :: MonadIO m => Scanner -> m Word32
    getScannerLine s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 56) :: IO Word32
        return val

    {- |
    Set the value of the “@line@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #line 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerLine :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerLine s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 56) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerLineFieldInfo
    instance AttrInfo ScannerLineFieldInfo where
        type AttrAllowedOps ScannerLineFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerLineFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerLineFieldInfo = (~) Scanner
        type AttrGetType ScannerLineFieldInfo = Word32
        type AttrLabel ScannerLineFieldInfo = "line"
        type AttrOrigin ScannerLineFieldInfo = Scanner
        attrGet _ = getScannerLine
        attrSet _ = setScannerLine
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_line :: AttrLabelProxy "line"
    scanner_line = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@position@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #position
    @
    -}
    getScannerPosition :: MonadIO m => Scanner -> m Word32
    getScannerPosition s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 60) :: IO Word32
        return val

    {- |
    Set the value of the “@position@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #position 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerPosition :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerPosition s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 60) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerPositionFieldInfo
    instance AttrInfo ScannerPositionFieldInfo where
        type AttrAllowedOps ScannerPositionFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerPositionFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerPositionFieldInfo = (~) Scanner
        type AttrGetType ScannerPositionFieldInfo = Word32
        type AttrLabel ScannerPositionFieldInfo = "position"
        type AttrOrigin ScannerPositionFieldInfo = Scanner
        attrGet _ = getScannerPosition
        attrSet _ = setScannerPosition
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_position :: AttrLabelProxy "position"
    scanner_position = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@next_token@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #nextToken
    @
    -}
    getScannerNextToken :: MonadIO m => Scanner -> m GLib.Enums.TokenType
    getScannerNextToken s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 64) :: IO CUInt
        let val' = (toEnum . fromIntegral) val
        return val'

    {- |
    Set the value of the “@next_token@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #nextToken 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerNextToken :: MonadIO m => Scanner -> GLib.Enums.TokenType -> m ()
    setScannerNextToken s val = liftIO $ withManagedPtr s $ \ptr -> do
        let val' = (fromIntegral . fromEnum) val
        poke (ptr `plusPtr` 64) (val' :: CUInt)

    #if ENABLE_OVERLOADING
    data ScannerNextTokenFieldInfo
    instance AttrInfo ScannerNextTokenFieldInfo where
        type AttrAllowedOps ScannerNextTokenFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerNextTokenFieldInfo = (~) GLib.Enums.TokenType
        type AttrBaseTypeConstraint ScannerNextTokenFieldInfo = (~) Scanner
        type AttrGetType ScannerNextTokenFieldInfo = GLib.Enums.TokenType
        type AttrLabel ScannerNextTokenFieldInfo = "next_token"
        type AttrOrigin ScannerNextTokenFieldInfo = Scanner
        attrGet _ = getScannerNextToken
        attrSet _ = setScannerNextToken
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_nextToken :: AttrLabelProxy "nextToken"
    scanner_nextToken = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@next_value@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #nextValue
    @
    -}
    getScannerNextValue :: MonadIO m => Scanner -> m GLib.TokenValue.TokenValue
    getScannerNextValue s = liftIO $ withManagedPtr s $ \ptr -> do
        let val = ptr `plusPtr` 72 :: (Ptr GLib.TokenValue.TokenValue)
        val' <- (newPtr GLib.TokenValue.TokenValue) val
        return val'

    #if ENABLE_OVERLOADING
    data ScannerNextValueFieldInfo
    instance AttrInfo ScannerNextValueFieldInfo where
        type AttrAllowedOps ScannerNextValueFieldInfo = '[ 'AttrGet]
        type AttrSetTypeConstraint ScannerNextValueFieldInfo = (~) (Ptr GLib.TokenValue.TokenValue)
        type AttrBaseTypeConstraint ScannerNextValueFieldInfo = (~) Scanner
        type AttrGetType ScannerNextValueFieldInfo = GLib.TokenValue.TokenValue
        type AttrLabel ScannerNextValueFieldInfo = "next_value"
        type AttrOrigin ScannerNextValueFieldInfo = Scanner
        attrGet _ = getScannerNextValue
        attrSet _ = undefined
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_nextValue :: AttrLabelProxy "nextValue"
    scanner_nextValue = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@next_line@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #nextLine
    @
    -}
    getScannerNextLine :: MonadIO m => Scanner -> m Word32
    getScannerNextLine s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 80) :: IO Word32
        return val

    {- |
    Set the value of the “@next_line@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #nextLine 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerNextLine :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerNextLine s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 80) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerNextLineFieldInfo
    instance AttrInfo ScannerNextLineFieldInfo where
        type AttrAllowedOps ScannerNextLineFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerNextLineFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerNextLineFieldInfo = (~) Scanner
        type AttrGetType ScannerNextLineFieldInfo = Word32
        type AttrLabel ScannerNextLineFieldInfo = "next_line"
        type AttrOrigin ScannerNextLineFieldInfo = Scanner
        attrGet _ = getScannerNextLine
        attrSet _ = setScannerNextLine
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_nextLine :: AttrLabelProxy "nextLine"
    scanner_nextLine = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@next_position@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #nextPosition
    @
    -}
    getScannerNextPosition :: MonadIO m => Scanner -> m Word32
    getScannerNextPosition s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 84) :: IO Word32
        return val

    {- |
    Set the value of the “@next_position@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #nextPosition 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerNextPosition :: MonadIO m => Scanner -> Word32 -> m ()
    setScannerNextPosition s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 84) (val :: Word32)

    #if ENABLE_OVERLOADING
    data ScannerNextPositionFieldInfo
    instance AttrInfo ScannerNextPositionFieldInfo where
        type AttrAllowedOps ScannerNextPositionFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint ScannerNextPositionFieldInfo = (~) Word32
        type AttrBaseTypeConstraint ScannerNextPositionFieldInfo = (~) Scanner
        type AttrGetType ScannerNextPositionFieldInfo = Word32
        type AttrLabel ScannerNextPositionFieldInfo = "next_position"
        type AttrOrigin ScannerNextPositionFieldInfo = Scanner
        attrGet _ = getScannerNextPosition
        attrSet _ = setScannerNextPosition
        attrConstruct = undefined
        attrClear _ = undefined

    scanner_nextPosition :: AttrLabelProxy "nextPosition"
    scanner_nextPosition = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@msg_handler@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' scanner #msgHandler
    @
    -}
    getScannerMsgHandler :: MonadIO m => Scanner -> m (Maybe GLib.Callbacks.ScannerMsgFunc)
    getScannerMsgHandler s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 136) :: IO (FunPtr GLib.Callbacks.C_ScannerMsgFunc)
        result <- SP.convertFunPtrIfNonNull val $ \val' -> do
            let val'' = GLib.Callbacks.dynamic_ScannerMsgFunc val'
            return val''
        return result

    {- |
    Set the value of the “@msg_handler@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' scanner [ #msgHandler 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setScannerMsgHandler :: MonadIO m => Scanner -> FunPtr GLib.Callbacks.C_ScannerMsgFunc -> m ()
    setScannerMsgHandler s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 136) (val :: FunPtr GLib.Callbacks.C_ScannerMsgFunc)

    {- |
    Set the value of the “@msg_handler@” field to `Nothing`.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.clear' #msgHandler
    @
    -}
    clearScannerMsgHandler :: MonadIO m => Scanner -> m ()
    clearScannerMsgHandler s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 136) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_ScannerMsgFunc)

    #if ENABLE_OVERLOADING
    data ScannerMsgHandlerFieldInfo
    instance AttrInfo ScannerMsgHandlerFieldInfo where
        type AttrAllowedOps ScannerMsgHandlerFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint ScannerMsgHandlerFieldInfo = (~) (FunPtr GLib.Callbacks.C_ScannerMsgFunc)
        type AttrBaseTypeConstraint ScannerMsgHandlerFieldInfo = (~) Scanner
        type AttrGetType ScannerMsgHandlerFieldInfo = Maybe GLib.Callbacks.ScannerMsgFunc
        type AttrLabel ScannerMsgHandlerFieldInfo = "msg_handler"
        type AttrOrigin ScannerMsgHandlerFieldInfo = Scanner
        attrGet _ = getScannerMsgHandler
        attrSet _ = setScannerMsgHandler
        attrConstruct = undefined
        attrClear _ = clearScannerMsgHandler

    scanner_msgHandler :: AttrLabelProxy "msgHandler"
    scanner_msgHandler = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Scanner
    type instance O.AttributeList Scanner = ScannerAttributeList
    type ScannerAttributeList = ('[ '("userData", ScannerUserDataFieldInfo), '("maxParseErrors", ScannerMaxParseErrorsFieldInfo), '("parseErrors", ScannerParseErrorsFieldInfo), '("inputName", ScannerInputNameFieldInfo), '("qdata", ScannerQdataFieldInfo), '("config", ScannerConfigFieldInfo), '("token", ScannerTokenFieldInfo), '("value", ScannerValueFieldInfo), '("line", ScannerLineFieldInfo), '("position", ScannerPositionFieldInfo), '("nextToken", ScannerNextTokenFieldInfo), '("nextValue", ScannerNextValueFieldInfo), '("nextLine", ScannerNextLineFieldInfo), '("nextPosition", ScannerNextPositionFieldInfo), '("msgHandler", ScannerMsgHandlerFieldInfo)] :: [(Symbol, *)])
    #endif

    -- method Scanner::cur_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_cur_line" g_scanner_cur_line ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO Word32

    {- |
    Returns the current line in the input stream (counting
    from 1). This is the line of the last token parsed via
    'GI.GLib.Structs.Scanner.scannerGetNextToken'.
    -}
    scannerCurLine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m Word32
        {- ^ __Returns:__ the current line -}
    scannerCurLine scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_cur_line scanner'
        touchManagedPtr scanner
        return result

    #if ENABLE_OVERLOADING
    data ScannerCurLineMethodInfo
    instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo ScannerCurLineMethodInfo Scanner signature where
        overloadedMethod _ = scannerCurLine

    #endif

    -- method Scanner::cur_position
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_cur_position" g_scanner_cur_position ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO Word32

    {- |
    Returns the current position in the current line (counting
    from 0). This is the position of the last token parsed via
    'GI.GLib.Structs.Scanner.scannerGetNextToken'.
    -}
    scannerCurPosition ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m Word32
        {- ^ __Returns:__ the current position on the line -}
    scannerCurPosition scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_cur_position scanner'
        touchManagedPtr scanner
        return result

    #if ENABLE_OVERLOADING
    data ScannerCurPositionMethodInfo
    instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo ScannerCurPositionMethodInfo Scanner signature where
        overloadedMethod _ = scannerCurPosition

    #endif

    -- method Scanner::cur_token
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "TokenType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_cur_token" g_scanner_cur_token ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO CUInt

    {- |
    Gets the current token type. This is simply the /@token@/
    field in the 'GI.GLib.Structs.Scanner.Scanner' structure.
    -}
    scannerCurToken ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m GLib.Enums.TokenType
        {- ^ __Returns:__ the current token type -}
    scannerCurToken scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_cur_token scanner'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr scanner
        return result'

    #if ENABLE_OVERLOADING
    data ScannerCurTokenMethodInfo
    instance (signature ~ (m GLib.Enums.TokenType), MonadIO m) => O.MethodInfo ScannerCurTokenMethodInfo Scanner signature where
        overloadedMethod _ = scannerCurToken

    #endif

    -- method Scanner::destroy
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_destroy" g_scanner_destroy ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO ()

    {- |
    Frees all memory used by the 'GI.GLib.Structs.Scanner.Scanner'.
    -}
    scannerDestroy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m ()
    scannerDestroy scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        g_scanner_destroy scanner'
        touchManagedPtr scanner
        return ()

    #if ENABLE_OVERLOADING
    data ScannerDestroyMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ScannerDestroyMethodInfo Scanner signature where
        overloadedMethod _ = scannerDestroy

    #endif

    -- method Scanner::eof
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_eof" g_scanner_eof ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO CInt

    {- |
    Returns 'True' if the scanner has reached the end of
    the file or text buffer.
    -}
    scannerEof ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the scanner has reached the end of
        the file or text buffer -}
    scannerEof scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_eof scanner'
        let result' = (/= 0) result
        touchManagedPtr scanner
        return result'

    #if ENABLE_OVERLOADING
    data ScannerEofMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo ScannerEofMethodInfo Scanner signature where
        overloadedMethod _ = scannerEof

    #endif

    -- method Scanner::get_next_token
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "TokenType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_get_next_token" g_scanner_get_next_token ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO CUInt

    {- |
    Parses the next token just like 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    and also removes it from the input stream. The token data is
    placed in the /@token@/, /@value@/, /@line@/, and /@position@/ fields of
    the 'GI.GLib.Structs.Scanner.Scanner' structure.
    -}
    scannerGetNextToken ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m GLib.Enums.TokenType
        {- ^ __Returns:__ the type of the token -}
    scannerGetNextToken scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_get_next_token scanner'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr scanner
        return result'

    #if ENABLE_OVERLOADING
    data ScannerGetNextTokenMethodInfo
    instance (signature ~ (m GLib.Enums.TokenType), MonadIO m) => O.MethodInfo ScannerGetNextTokenMethodInfo Scanner signature where
        overloadedMethod _ = scannerGetNextToken

    #endif

    -- method Scanner::input_file
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "input_fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file descriptor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_input_file" g_scanner_input_file ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        Int32 ->                                -- input_fd : TBasicType TInt
        IO ()

    {- |
    Prepares to scan a file.
    -}
    scannerInputFile ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> Int32
        {- ^ /@inputFd@/: a file descriptor -}
        -> m ()
    scannerInputFile scanner inputFd = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        g_scanner_input_file scanner' inputFd
        touchManagedPtr scanner
        return ()

    #if ENABLE_OVERLOADING
    data ScannerInputFileMethodInfo
    instance (signature ~ (Int32 -> m ()), MonadIO m) => O.MethodInfo ScannerInputFileMethodInfo Scanner signature where
        overloadedMethod _ = scannerInputFile

    #endif

    -- method Scanner::input_text
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text buffer to scan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text_len", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the text buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_input_text" g_scanner_input_text ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        CString ->                              -- text : TBasicType TUTF8
        Word32 ->                               -- text_len : TBasicType TUInt
        IO ()

    {- |
    Prepares to scan a text buffer.
    -}
    scannerInputText ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> T.Text
        {- ^ /@text@/: the text buffer to scan -}
        -> Word32
        {- ^ /@textLen@/: the length of the text buffer -}
        -> m ()
    scannerInputText scanner text textLen = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        text' <- textToCString text
        g_scanner_input_text scanner' text' textLen
        touchManagedPtr scanner
        freeMem text'
        return ()

    #if ENABLE_OVERLOADING
    data ScannerInputTextMethodInfo
    instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m) => O.MethodInfo ScannerInputTextMethodInfo Scanner signature where
        overloadedMethod _ = scannerInputText

    #endif

    -- method Scanner::lookup_symbol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the symbol to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_lookup_symbol" g_scanner_lookup_symbol ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        CString ->                              -- symbol : TBasicType TUTF8
        IO (Ptr ())

    {- |
    Looks up a symbol in the current scope and return its value.
    If the symbol is not bound in the current scope, 'Nothing' is
    returned.
    -}
    scannerLookupSymbol ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> T.Text
        {- ^ /@symbol@/: the symbol to look up -}
        -> m (Ptr ())
        {- ^ __Returns:__ the value of /@symbol@/ in the current scope, or 'Nothing'
        if /@symbol@/ is not bound in the current scope -}
    scannerLookupSymbol scanner symbol = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        symbol' <- textToCString symbol
        result <- g_scanner_lookup_symbol scanner' symbol'
        touchManagedPtr scanner
        freeMem symbol'
        return result

    #if ENABLE_OVERLOADING
    data ScannerLookupSymbolMethodInfo
    instance (signature ~ (T.Text -> m (Ptr ())), MonadIO m) => O.MethodInfo ScannerLookupSymbolMethodInfo Scanner signature where
        overloadedMethod _ = scannerLookupSymbol

    #endif

    -- method Scanner::peek_next_token
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "GLib", name = "TokenType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_peek_next_token" g_scanner_peek_next_token ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO CUInt

    {- |
    Parses the next token, without removing it from the input stream.
    The token data is placed in the /@nextToken@/, /@nextValue@/, /@nextLine@/,
    and /@nextPosition@/ fields of the 'GI.GLib.Structs.Scanner.Scanner' structure.

    Note that, while the token is not removed from the input stream
    (i.e. the next call to 'GI.GLib.Structs.Scanner.scannerGetNextToken' will return the
    same token), it will not be reevaluated. This can lead to surprising
    results when changing scope or the scanner configuration after peeking
    the next token. Getting the next token after switching the scope or
    configuration will return whatever was peeked before, regardless of
    any symbols that may have been added or removed in the new scope.
    -}
    scannerPeekNextToken ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m GLib.Enums.TokenType
        {- ^ __Returns:__ the type of the token -}
    scannerPeekNextToken scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_peek_next_token scanner'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr scanner
        return result'

    #if ENABLE_OVERLOADING
    data ScannerPeekNextTokenMethodInfo
    instance (signature ~ (m GLib.Enums.TokenType), MonadIO m) => O.MethodInfo ScannerPeekNextTokenMethodInfo Scanner signature where
        overloadedMethod _ = scannerPeekNextToken

    #endif

    -- method Scanner::scope_add_symbol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scope id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the symbol to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the value of the symbol", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_scope_add_symbol" g_scanner_scope_add_symbol ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        Word32 ->                               -- scope_id : TBasicType TUInt
        CString ->                              -- symbol : TBasicType TUTF8
        Ptr () ->                               -- value : TBasicType TPtr
        IO ()

    {- |
    Adds a symbol to the given scope.
    -}
    scannerScopeAddSymbol ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> Word32
        {- ^ /@scopeId@/: the scope id -}
        -> T.Text
        {- ^ /@symbol@/: the symbol to add -}
        -> Ptr ()
        {- ^ /@value@/: the value of the symbol -}
        -> m ()
    scannerScopeAddSymbol scanner scopeId symbol value = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        symbol' <- textToCString symbol
        g_scanner_scope_add_symbol scanner' scopeId symbol' value
        touchManagedPtr scanner
        freeMem symbol'
        return ()

    #if ENABLE_OVERLOADING
    data ScannerScopeAddSymbolMethodInfo
    instance (signature ~ (Word32 -> T.Text -> Ptr () -> m ()), MonadIO m) => O.MethodInfo ScannerScopeAddSymbolMethodInfo Scanner signature where
        overloadedMethod _ = scannerScopeAddSymbol

    #endif

    -- method Scanner::scope_lookup_symbol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scope id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the symbol to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TPtr)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_scope_lookup_symbol" g_scanner_scope_lookup_symbol ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        Word32 ->                               -- scope_id : TBasicType TUInt
        CString ->                              -- symbol : TBasicType TUTF8
        IO (Ptr ())

    {- |
    Looks up a symbol in a scope and return its value. If the
    symbol is not bound in the scope, 'Nothing' is returned.
    -}
    scannerScopeLookupSymbol ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> Word32
        {- ^ /@scopeId@/: the scope id -}
        -> T.Text
        {- ^ /@symbol@/: the symbol to look up -}
        -> m (Ptr ())
        {- ^ __Returns:__ the value of /@symbol@/ in the given scope, or 'Nothing'
        if /@symbol@/ is not bound in the given scope. -}
    scannerScopeLookupSymbol scanner scopeId symbol = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        symbol' <- textToCString symbol
        result <- g_scanner_scope_lookup_symbol scanner' scopeId symbol'
        touchManagedPtr scanner
        freeMem symbol'
        return result

    #if ENABLE_OVERLOADING
    data ScannerScopeLookupSymbolMethodInfo
    instance (signature ~ (Word32 -> T.Text -> m (Ptr ())), MonadIO m) => O.MethodInfo ScannerScopeLookupSymbolMethodInfo Scanner signature where
        overloadedMethod _ = scannerScopeLookupSymbol

    #endif

    -- method Scanner::scope_remove_symbol
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the scope id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the symbol to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_scope_remove_symbol" g_scanner_scope_remove_symbol ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        Word32 ->                               -- scope_id : TBasicType TUInt
        CString ->                              -- symbol : TBasicType TUTF8
        IO ()

    {- |
    Removes a symbol from a scope.
    -}
    scannerScopeRemoveSymbol ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> Word32
        {- ^ /@scopeId@/: the scope id -}
        -> T.Text
        {- ^ /@symbol@/: the symbol to remove -}
        -> m ()
    scannerScopeRemoveSymbol scanner scopeId symbol = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        symbol' <- textToCString symbol
        g_scanner_scope_remove_symbol scanner' scopeId symbol'
        touchManagedPtr scanner
        freeMem symbol'
        return ()

    #if ENABLE_OVERLOADING
    data ScannerScopeRemoveSymbolMethodInfo
    instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m) => O.MethodInfo ScannerScopeRemoveSymbolMethodInfo Scanner signature where
        overloadedMethod _ = scannerScopeRemoveSymbol

    #endif

    -- method Scanner::set_scope
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new scope id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_set_scope" g_scanner_set_scope ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        Word32 ->                               -- scope_id : TBasicType TUInt
        IO Word32

    {- |
    Sets the current scope.
    -}
    scannerSetScope ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> Word32
        {- ^ /@scopeId@/: the new scope id -}
        -> m Word32
        {- ^ __Returns:__ the old scope id -}
    scannerSetScope scanner scopeId = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        result <- g_scanner_set_scope scanner' scopeId
        touchManagedPtr scanner
        return result

    #if ENABLE_OVERLOADING
    data ScannerSetScopeMethodInfo
    instance (signature ~ (Word32 -> m Word32), MonadIO m) => O.MethodInfo ScannerSetScopeMethodInfo Scanner signature where
        overloadedMethod _ = scannerSetScope

    #endif

    -- method Scanner::sync_file_offset
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_sync_file_offset" g_scanner_sync_file_offset ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        IO ()

    {- |
    Rewinds the filedescriptor to the current buffer position
    and blows the file read ahead buffer. This is useful for
    third party uses of the scanners filedescriptor, which hooks
    onto the current scanning position.
    -}
    scannerSyncFileOffset ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> m ()
    scannerSyncFileOffset scanner = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        g_scanner_sync_file_offset scanner'
        touchManagedPtr scanner
        return ()

    #if ENABLE_OVERLOADING
    data ScannerSyncFileOffsetMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ScannerSyncFileOffsetMethodInfo Scanner signature where
        overloadedMethod _ = scannerSyncFileOffset

    #endif

    -- method Scanner::unexp_token
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "scanner", argType = TInterface (Name {namespace = "GLib", name = "Scanner"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GScanner", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expected_token", argType = TInterface (Name {namespace = "GLib", name = "TokenType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the expected token", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identifier_spec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string describing how the scanner's user\n    refers to identifiers (%NULL defaults to \"identifier\").\n    This is used if @expected_token is %G_TOKEN_IDENTIFIER or\n    %G_TOKEN_IDENTIFIER_NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol_spec", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string describing how the scanner's user refers\n    to symbols (%NULL defaults to \"symbol\"). This is used if\n    @expected_token is %G_TOKEN_SYMBOL or any token value greater\n    than %G_TOKEN_LAST.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "symbol_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the symbol, if the scanner's current\n    token is a symbol.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a message string to output at the end of the\n    warning/error, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_error", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE it is output as an error. If %FALSE it is\n    output as a warning.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_scanner_unexp_token" g_scanner_unexp_token ::
        Ptr Scanner ->                          -- scanner : TInterface (Name {namespace = "GLib", name = "Scanner"})
        CUInt ->                                -- expected_token : TInterface (Name {namespace = "GLib", name = "TokenType"})
        CString ->                              -- identifier_spec : TBasicType TUTF8
        CString ->                              -- symbol_spec : TBasicType TUTF8
        CString ->                              -- symbol_name : TBasicType TUTF8
        CString ->                              -- message : TBasicType TUTF8
        Int32 ->                                -- is_error : TBasicType TInt
        IO ()

    {- |
    Outputs a message through the scanner\'s msg_handler,
    resulting from an unexpected token in the input stream.
    Note that you should not call 'GI.GLib.Structs.Scanner.scannerPeekNextToken'
    followed by 'GI.GLib.Structs.Scanner.scannerUnexpToken' without an intermediate
    call to 'GI.GLib.Structs.Scanner.scannerGetNextToken', as 'GI.GLib.Structs.Scanner.scannerUnexpToken'
    evaluates the scanner\'s current token (not the peeked token)
    to construct part of the message.
    -}
    scannerUnexpToken ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Scanner
        {- ^ /@scanner@/: a 'GI.GLib.Structs.Scanner.Scanner' -}
        -> GLib.Enums.TokenType
        {- ^ /@expectedToken@/: the expected token -}
        -> T.Text
        {- ^ /@identifierSpec@/: a string describing how the scanner\'s user
        refers to identifiers ('Nothing' defaults to \"identifier\").
        This is used if /@expectedToken@/ is 'GI.GLib.Enums.TokenTypeIdentifier' or
        'GI.GLib.Enums.TokenTypeIdentifierNull'. -}
        -> T.Text
        {- ^ /@symbolSpec@/: a string describing how the scanner\'s user refers
        to symbols ('Nothing' defaults to \"symbol\"). This is used if
        /@expectedToken@/ is 'GI.GLib.Enums.TokenTypeSymbol' or any token value greater
        than @/G_TOKEN_LAST/@. -}
        -> T.Text
        {- ^ /@symbolName@/: the name of the symbol, if the scanner\'s current
        token is a symbol. -}
        -> T.Text
        {- ^ /@message@/: a message string to output at the end of the
        warning\/error, or 'Nothing'. -}
        -> Int32
        {- ^ /@isError@/: if 'True' it is output as an error. If 'False' it is
        output as a warning. -}
        -> m ()
    scannerUnexpToken scanner expectedToken identifierSpec symbolSpec symbolName message isError = liftIO $ do
        scanner' <- unsafeManagedPtrGetPtr scanner
        let expectedToken' = (fromIntegral . fromEnum) expectedToken
        identifierSpec' <- textToCString identifierSpec
        symbolSpec' <- textToCString symbolSpec
        symbolName' <- textToCString symbolName
        message' <- textToCString message
        g_scanner_unexp_token scanner' expectedToken' identifierSpec' symbolSpec' symbolName' message' isError
        touchManagedPtr scanner
        freeMem identifierSpec'
        freeMem symbolSpec'
        freeMem symbolName'
        freeMem message'
        return ()

    #if ENABLE_OVERLOADING
    data ScannerUnexpTokenMethodInfo
    instance (signature ~ (GLib.Enums.TokenType -> T.Text -> T.Text -> T.Text -> T.Text -> Int32 -> m ()), MonadIO m) => O.MethodInfo ScannerUnexpTokenMethodInfo Scanner signature where
        overloadedMethod _ = scannerUnexpToken

    #endif

    #if ENABLE_OVERLOADING
    type family ResolveScannerMethod (t :: Symbol) (o :: *) :: * where
        ResolveScannerMethod "curLine" o = ScannerCurLineMethodInfo
        ResolveScannerMethod "curPosition" o = ScannerCurPositionMethodInfo
        ResolveScannerMethod "curToken" o = ScannerCurTokenMethodInfo
        ResolveScannerMethod "destroy" o = ScannerDestroyMethodInfo
        ResolveScannerMethod "eof" o = ScannerEofMethodInfo
        ResolveScannerMethod "inputFile" o = ScannerInputFileMethodInfo
        ResolveScannerMethod "inputText" o = ScannerInputTextMethodInfo
        ResolveScannerMethod "lookupSymbol" o = ScannerLookupSymbolMethodInfo
        ResolveScannerMethod "peekNextToken" o = ScannerPeekNextTokenMethodInfo
        ResolveScannerMethod "scopeAddSymbol" o = ScannerScopeAddSymbolMethodInfo
        ResolveScannerMethod "scopeLookupSymbol" o = ScannerScopeLookupSymbolMethodInfo
        ResolveScannerMethod "scopeRemoveSymbol" o = ScannerScopeRemoveSymbolMethodInfo
        ResolveScannerMethod "syncFileOffset" o = ScannerSyncFileOffsetMethodInfo
        ResolveScannerMethod "unexpToken" o = ScannerUnexpTokenMethodInfo
        ResolveScannerMethod "getNextToken" o = ScannerGetNextTokenMethodInfo
        ResolveScannerMethod "setScope" o = ScannerSetScopeMethodInfo
        ResolveScannerMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveScannerMethod t Scanner, O.MethodInfo info Scanner p) => O.IsLabelProxy t (Scanner -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveScannerMethod t Scanner, O.MethodInfo info Scanner p) => O.IsLabel t (Scanner -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif