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

module GI.Vte.Objects.Terminal
    ( 

-- * Exported types
    Terminal(..)                            ,
    IsTerminal                              ,
    toTerminal                              ,
    noTerminal                              ,


 -- * Methods
-- ** Unsupported methods #method:Unsupported methods#
    TerminalGetTextIncludeTrailingSpacesMethodInfo,
    TerminalGetTextMethodInfo               ,
    TerminalGetTextRangeMethodInfo          ,


-- ** copyClipboard #method:copyClipboard#
    TerminalCopyClipboardMethodInfo         ,
    terminalCopyClipboard                   ,


-- ** copyPrimary #method:copyPrimary#
    TerminalCopyPrimaryMethodInfo           ,
    terminalCopyPrimary                     ,


-- ** feed #method:feed#
    TerminalFeedMethodInfo                  ,
    terminalFeed                            ,


-- ** feedChild #method:feedChild#
    TerminalFeedChildMethodInfo             ,
    terminalFeedChild                       ,


-- ** feedChildBinary #method:feedChildBinary#
    TerminalFeedChildBinaryMethodInfo       ,
    terminalFeedChildBinary                 ,


-- ** getAllowBold #method:getAllowBold#
    TerminalGetAllowBoldMethodInfo          ,
    terminalGetAllowBold                    ,


-- ** getAudibleBell #method:getAudibleBell#
    TerminalGetAudibleBellMethodInfo        ,
    terminalGetAudibleBell                  ,


-- ** getCharHeight #method:getCharHeight#
    TerminalGetCharHeightMethodInfo         ,
    terminalGetCharHeight                   ,


-- ** getCharWidth #method:getCharWidth#
    TerminalGetCharWidthMethodInfo          ,
    terminalGetCharWidth                    ,


-- ** getCjkAmbiguousWidth #method:getCjkAmbiguousWidth#
    TerminalGetCjkAmbiguousWidthMethodInfo  ,
    terminalGetCjkAmbiguousWidth            ,


-- ** getColumnCount #method:getColumnCount#
    TerminalGetColumnCountMethodInfo        ,
    terminalGetColumnCount                  ,


-- ** getCurrentDirectoryUri #method:getCurrentDirectoryUri#
    TerminalGetCurrentDirectoryUriMethodInfo,
    terminalGetCurrentDirectoryUri          ,


-- ** getCurrentFileUri #method:getCurrentFileUri#
    TerminalGetCurrentFileUriMethodInfo     ,
    terminalGetCurrentFileUri               ,


-- ** getCursorBlinkMode #method:getCursorBlinkMode#
    TerminalGetCursorBlinkModeMethodInfo    ,
    terminalGetCursorBlinkMode              ,


-- ** getCursorPosition #method:getCursorPosition#
    TerminalGetCursorPositionMethodInfo     ,
    terminalGetCursorPosition               ,


-- ** getCursorShape #method:getCursorShape#
    TerminalGetCursorShapeMethodInfo        ,
    terminalGetCursorShape                  ,


-- ** getEncoding #method:getEncoding#
    TerminalGetEncodingMethodInfo           ,
    terminalGetEncoding                     ,


-- ** getFont #method:getFont#
    TerminalGetFontMethodInfo               ,
    terminalGetFont                         ,


-- ** getFontScale #method:getFontScale#
    TerminalGetFontScaleMethodInfo          ,
    terminalGetFontScale                    ,


-- ** getGeometryHints #method:getGeometryHints#
    TerminalGetGeometryHintsMethodInfo      ,
    terminalGetGeometryHints                ,


-- ** getHasSelection #method:getHasSelection#
    TerminalGetHasSelectionMethodInfo       ,
    terminalGetHasSelection                 ,


-- ** getIconTitle #method:getIconTitle#
    TerminalGetIconTitleMethodInfo          ,
    terminalGetIconTitle                    ,


-- ** getInputEnabled #method:getInputEnabled#
    TerminalGetInputEnabledMethodInfo       ,
    terminalGetInputEnabled                 ,


-- ** getMouseAutohide #method:getMouseAutohide#
    TerminalGetMouseAutohideMethodInfo      ,
    terminalGetMouseAutohide                ,


-- ** getPty #method:getPty#
    TerminalGetPtyMethodInfo                ,
    terminalGetPty                          ,


-- ** getRewrapOnResize #method:getRewrapOnResize#
    TerminalGetRewrapOnResizeMethodInfo     ,
    terminalGetRewrapOnResize               ,


-- ** getRowCount #method:getRowCount#
    TerminalGetRowCountMethodInfo           ,
    terminalGetRowCount                     ,


-- ** getWindowTitle #method:getWindowTitle#
    TerminalGetWindowTitleMethodInfo        ,
    terminalGetWindowTitle                  ,


-- ** getWordCharExceptions #method:getWordCharExceptions#
    TerminalGetWordCharExceptionsMethodInfo ,
    terminalGetWordCharExceptions           ,


-- ** matchAddGregex #method:matchAddGregex#
    TerminalMatchAddGregexMethodInfo        ,
    terminalMatchAddGregex                  ,


-- ** matchAddRegex #method:matchAddRegex#
    TerminalMatchAddRegexMethodInfo         ,
    terminalMatchAddRegex                   ,


-- ** matchCheck #method:matchCheck#
    TerminalMatchCheckMethodInfo            ,
    terminalMatchCheck                      ,


-- ** matchCheckEvent #method:matchCheckEvent#
    TerminalMatchCheckEventMethodInfo       ,
    terminalMatchCheckEvent                 ,


-- ** matchRemove #method:matchRemove#
    TerminalMatchRemoveMethodInfo           ,
    terminalMatchRemove                     ,


-- ** matchRemoveAll #method:matchRemoveAll#
    TerminalMatchRemoveAllMethodInfo        ,
    terminalMatchRemoveAll                  ,


-- ** matchSetCursor #method:matchSetCursor#
    TerminalMatchSetCursorMethodInfo        ,
    terminalMatchSetCursor                  ,


-- ** matchSetCursorName #method:matchSetCursorName#
    TerminalMatchSetCursorNameMethodInfo    ,
    terminalMatchSetCursorName              ,


-- ** matchSetCursorType #method:matchSetCursorType#
    TerminalMatchSetCursorTypeMethodInfo    ,
    terminalMatchSetCursorType              ,


-- ** new #method:new#
    terminalNew                             ,


-- ** pasteClipboard #method:pasteClipboard#
    TerminalPasteClipboardMethodInfo        ,
    terminalPasteClipboard                  ,


-- ** pastePrimary #method:pastePrimary#
    TerminalPastePrimaryMethodInfo          ,
    terminalPastePrimary                    ,


-- ** ptyNewSync #method:ptyNewSync#
    TerminalPtyNewSyncMethodInfo            ,
    terminalPtyNewSync                      ,


-- ** reset #method:reset#
    TerminalResetMethodInfo                 ,
    terminalReset                           ,


-- ** searchFindNext #method:searchFindNext#
    TerminalSearchFindNextMethodInfo        ,
    terminalSearchFindNext                  ,


-- ** searchFindPrevious #method:searchFindPrevious#
    TerminalSearchFindPreviousMethodInfo    ,
    terminalSearchFindPrevious              ,


-- ** searchGetGregex #method:searchGetGregex#
    TerminalSearchGetGregexMethodInfo       ,
    terminalSearchGetGregex                 ,


-- ** searchGetRegex #method:searchGetRegex#
    TerminalSearchGetRegexMethodInfo        ,
    terminalSearchGetRegex                  ,


-- ** searchGetWrapAround #method:searchGetWrapAround#
    TerminalSearchGetWrapAroundMethodInfo   ,
    terminalSearchGetWrapAround             ,


-- ** searchSetGregex #method:searchSetGregex#
    TerminalSearchSetGregexMethodInfo       ,
    terminalSearchSetGregex                 ,


-- ** searchSetRegex #method:searchSetRegex#
    TerminalSearchSetRegexMethodInfo        ,
    terminalSearchSetRegex                  ,


-- ** searchSetWrapAround #method:searchSetWrapAround#
    TerminalSearchSetWrapAroundMethodInfo   ,
    terminalSearchSetWrapAround             ,


-- ** selectAll #method:selectAll#
    TerminalSelectAllMethodInfo             ,
    terminalSelectAll                       ,


-- ** setAllowBold #method:setAllowBold#
    TerminalSetAllowBoldMethodInfo          ,
    terminalSetAllowBold                    ,


-- ** setAudibleBell #method:setAudibleBell#
    TerminalSetAudibleBellMethodInfo        ,
    terminalSetAudibleBell                  ,


-- ** setBackspaceBinding #method:setBackspaceBinding#
    TerminalSetBackspaceBindingMethodInfo   ,
    terminalSetBackspaceBinding             ,


-- ** setCjkAmbiguousWidth #method:setCjkAmbiguousWidth#
    TerminalSetCjkAmbiguousWidthMethodInfo  ,
    terminalSetCjkAmbiguousWidth            ,


-- ** setColorBackground #method:setColorBackground#
    TerminalSetColorBackgroundMethodInfo    ,
    terminalSetColorBackground              ,


-- ** setColorBold #method:setColorBold#
    TerminalSetColorBoldMethodInfo          ,
    terminalSetColorBold                    ,


-- ** setColorCursor #method:setColorCursor#
    TerminalSetColorCursorMethodInfo        ,
    terminalSetColorCursor                  ,


-- ** setColorCursorForeground #method:setColorCursorForeground#
    TerminalSetColorCursorForegroundMethodInfo,
    terminalSetColorCursorForeground        ,


-- ** setColorForeground #method:setColorForeground#
    TerminalSetColorForegroundMethodInfo    ,
    terminalSetColorForeground              ,


-- ** setColorHighlight #method:setColorHighlight#
    TerminalSetColorHighlightMethodInfo     ,
    terminalSetColorHighlight               ,


-- ** setColorHighlightForeground #method:setColorHighlightForeground#
    TerminalSetColorHighlightForegroundMethodInfo,
    terminalSetColorHighlightForeground     ,


-- ** setColors #method:setColors#
    TerminalSetColorsMethodInfo             ,
    terminalSetColors                       ,


-- ** setCursorBlinkMode #method:setCursorBlinkMode#
    TerminalSetCursorBlinkModeMethodInfo    ,
    terminalSetCursorBlinkMode              ,


-- ** setCursorShape #method:setCursorShape#
    TerminalSetCursorShapeMethodInfo        ,
    terminalSetCursorShape                  ,


-- ** setDefaultColors #method:setDefaultColors#
    TerminalSetDefaultColorsMethodInfo      ,
    terminalSetDefaultColors                ,


-- ** setDeleteBinding #method:setDeleteBinding#
    TerminalSetDeleteBindingMethodInfo      ,
    terminalSetDeleteBinding                ,


-- ** setEncoding #method:setEncoding#
    TerminalSetEncodingMethodInfo           ,
    terminalSetEncoding                     ,


-- ** setFont #method:setFont#
    TerminalSetFontMethodInfo               ,
    terminalSetFont                         ,


-- ** setFontScale #method:setFontScale#
    TerminalSetFontScaleMethodInfo          ,
    terminalSetFontScale                    ,


-- ** setGeometryHintsForWindow #method:setGeometryHintsForWindow#
    TerminalSetGeometryHintsForWindowMethodInfo,
    terminalSetGeometryHintsForWindow       ,


-- ** setInputEnabled #method:setInputEnabled#
    TerminalSetInputEnabledMethodInfo       ,
    terminalSetInputEnabled                 ,


-- ** setMouseAutohide #method:setMouseAutohide#
    TerminalSetMouseAutohideMethodInfo      ,
    terminalSetMouseAutohide                ,


-- ** setPty #method:setPty#
    TerminalSetPtyMethodInfo                ,
    terminalSetPty                          ,


-- ** setRewrapOnResize #method:setRewrapOnResize#
    TerminalSetRewrapOnResizeMethodInfo     ,
    terminalSetRewrapOnResize               ,


-- ** setScrollOnKeystroke #method:setScrollOnKeystroke#
    TerminalSetScrollOnKeystrokeMethodInfo  ,
    terminalSetScrollOnKeystroke            ,


-- ** setScrollOnOutput #method:setScrollOnOutput#
    TerminalSetScrollOnOutputMethodInfo     ,
    terminalSetScrollOnOutput               ,


-- ** setScrollSpeed #method:setScrollSpeed#
    TerminalSetScrollSpeedMethodInfo        ,
    terminalSetScrollSpeed                  ,


-- ** setScrollbackLines #method:setScrollbackLines#
    TerminalSetScrollbackLinesMethodInfo    ,
    terminalSetScrollbackLines              ,


-- ** setSize #method:setSize#
    TerminalSetSizeMethodInfo               ,
    terminalSetSize                         ,


-- ** setWordCharExceptions #method:setWordCharExceptions#
    TerminalSetWordCharExceptionsMethodInfo ,
    terminalSetWordCharExceptions           ,


-- ** spawnSync #method:spawnSync#
    TerminalSpawnSyncMethodInfo             ,
    terminalSpawnSync                       ,


-- ** unselectAll #method:unselectAll#
    TerminalUnselectAllMethodInfo           ,
    terminalUnselectAll                     ,


-- ** watchChild #method:watchChild#
    TerminalWatchChildMethodInfo            ,
    terminalWatchChild                      ,


-- ** writeContentsSync #method:writeContentsSync#
    TerminalWriteContentsSyncMethodInfo     ,
    terminalWriteContentsSync               ,




 -- * Properties
-- ** allowBold #attr:allowBold#
    TerminalAllowBoldPropertyInfo           ,
    constructTerminalAllowBold              ,
    getTerminalAllowBold                    ,
    setTerminalAllowBold                    ,
    terminalAllowBold                       ,


-- ** audibleBell #attr:audibleBell#
    TerminalAudibleBellPropertyInfo         ,
    constructTerminalAudibleBell            ,
    getTerminalAudibleBell                  ,
    setTerminalAudibleBell                  ,
    terminalAudibleBell                     ,


-- ** backspaceBinding #attr:backspaceBinding#
    TerminalBackspaceBindingPropertyInfo    ,
    constructTerminalBackspaceBinding       ,
    getTerminalBackspaceBinding             ,
    setTerminalBackspaceBinding             ,
    terminalBackspaceBinding                ,


-- ** cjkAmbiguousWidth #attr:cjkAmbiguousWidth#
    TerminalCjkAmbiguousWidthPropertyInfo   ,
    constructTerminalCjkAmbiguousWidth      ,
    getTerminalCjkAmbiguousWidth            ,
    setTerminalCjkAmbiguousWidth            ,
    terminalCjkAmbiguousWidth               ,


-- ** currentDirectoryUri #attr:currentDirectoryUri#
    TerminalCurrentDirectoryUriPropertyInfo ,
    getTerminalCurrentDirectoryUri          ,
    terminalCurrentDirectoryUri             ,


-- ** currentFileUri #attr:currentFileUri#
    TerminalCurrentFileUriPropertyInfo      ,
    getTerminalCurrentFileUri               ,
    terminalCurrentFileUri                  ,


-- ** cursorBlinkMode #attr:cursorBlinkMode#
    TerminalCursorBlinkModePropertyInfo     ,
    constructTerminalCursorBlinkMode        ,
    getTerminalCursorBlinkMode              ,
    setTerminalCursorBlinkMode              ,
    terminalCursorBlinkMode                 ,


-- ** cursorShape #attr:cursorShape#
    TerminalCursorShapePropertyInfo         ,
    constructTerminalCursorShape            ,
    getTerminalCursorShape                  ,
    setTerminalCursorShape                  ,
    terminalCursorShape                     ,


-- ** deleteBinding #attr:deleteBinding#
    TerminalDeleteBindingPropertyInfo       ,
    constructTerminalDeleteBinding          ,
    getTerminalDeleteBinding                ,
    setTerminalDeleteBinding                ,
    terminalDeleteBinding                   ,


-- ** encoding #attr:encoding#
    TerminalEncodingPropertyInfo            ,
    clearTerminalEncoding                   ,
    constructTerminalEncoding               ,
    getTerminalEncoding                     ,
    setTerminalEncoding                     ,
    terminalEncoding                        ,


-- ** fontDesc #attr:fontDesc#
    TerminalFontDescPropertyInfo            ,
    clearTerminalFontDesc                   ,
    constructTerminalFontDesc               ,
    getTerminalFontDesc                     ,
    setTerminalFontDesc                     ,
    terminalFontDesc                        ,


-- ** fontScale #attr:fontScale#
    TerminalFontScalePropertyInfo           ,
    constructTerminalFontScale              ,
    getTerminalFontScale                    ,
    setTerminalFontScale                    ,
    terminalFontScale                       ,


-- ** iconTitle #attr:iconTitle#
    TerminalIconTitlePropertyInfo           ,
    getTerminalIconTitle                    ,
    terminalIconTitle                       ,


-- ** inputEnabled #attr:inputEnabled#
    TerminalInputEnabledPropertyInfo        ,
    constructTerminalInputEnabled           ,
    getTerminalInputEnabled                 ,
    setTerminalInputEnabled                 ,
    terminalInputEnabled                    ,


-- ** pointerAutohide #attr:pointerAutohide#
    TerminalPointerAutohidePropertyInfo     ,
    constructTerminalPointerAutohide        ,
    getTerminalPointerAutohide              ,
    setTerminalPointerAutohide              ,
    terminalPointerAutohide                 ,


-- ** pty #attr:pty#
    TerminalPtyPropertyInfo                 ,
    clearTerminalPty                        ,
    constructTerminalPty                    ,
    getTerminalPty                          ,
    setTerminalPty                          ,
    terminalPty                             ,


-- ** rewrapOnResize #attr:rewrapOnResize#
    TerminalRewrapOnResizePropertyInfo      ,
    constructTerminalRewrapOnResize         ,
    getTerminalRewrapOnResize               ,
    setTerminalRewrapOnResize               ,
    terminalRewrapOnResize                  ,


-- ** scrollOnKeystroke #attr:scrollOnKeystroke#
    TerminalScrollOnKeystrokePropertyInfo   ,
    constructTerminalScrollOnKeystroke      ,
    getTerminalScrollOnKeystroke            ,
    setTerminalScrollOnKeystroke            ,
    terminalScrollOnKeystroke               ,


-- ** scrollOnOutput #attr:scrollOnOutput#
    TerminalScrollOnOutputPropertyInfo      ,
    constructTerminalScrollOnOutput         ,
    getTerminalScrollOnOutput               ,
    setTerminalScrollOnOutput               ,
    terminalScrollOnOutput                  ,


-- ** scrollSpeed #attr:scrollSpeed#
    TerminalScrollSpeedPropertyInfo         ,
    constructTerminalScrollSpeed            ,
    getTerminalScrollSpeed                  ,
    setTerminalScrollSpeed                  ,
    terminalScrollSpeed                     ,


-- ** scrollbackLines #attr:scrollbackLines#
    TerminalScrollbackLinesPropertyInfo     ,
    constructTerminalScrollbackLines        ,
    getTerminalScrollbackLines              ,
    setTerminalScrollbackLines              ,
    terminalScrollbackLines                 ,


-- ** windowTitle #attr:windowTitle#
    TerminalWindowTitlePropertyInfo         ,
    getTerminalWindowTitle                  ,
    terminalWindowTitle                     ,


-- ** wordCharExceptions #attr:wordCharExceptions#
    TerminalWordCharExceptionsPropertyInfo  ,
    getTerminalWordCharExceptions           ,
    terminalWordCharExceptions              ,




 -- * Signals
-- ** bell #signal:bell#
    C_TerminalBellCallback                  ,
    TerminalBellCallback                    ,
    TerminalBellSignalInfo                  ,
    afterTerminalBell                       ,
    genClosure_TerminalBell                 ,
    mk_TerminalBellCallback                 ,
    noTerminalBellCallback                  ,
    onTerminalBell                          ,
    wrap_TerminalBellCallback               ,


-- ** charSizeChanged #signal:charSizeChanged#
    C_TerminalCharSizeChangedCallback       ,
    TerminalCharSizeChangedCallback         ,
    TerminalCharSizeChangedSignalInfo       ,
    afterTerminalCharSizeChanged            ,
    genClosure_TerminalCharSizeChanged      ,
    mk_TerminalCharSizeChangedCallback      ,
    noTerminalCharSizeChangedCallback       ,
    onTerminalCharSizeChanged               ,
    wrap_TerminalCharSizeChangedCallback    ,


-- ** childExited #signal:childExited#
    C_TerminalChildExitedCallback           ,
    TerminalChildExitedCallback             ,
    TerminalChildExitedSignalInfo           ,
    afterTerminalChildExited                ,
    genClosure_TerminalChildExited          ,
    mk_TerminalChildExitedCallback          ,
    noTerminalChildExitedCallback           ,
    onTerminalChildExited                   ,
    wrap_TerminalChildExitedCallback        ,


-- ** commit #signal:commit#
    C_TerminalCommitCallback                ,
    TerminalCommitCallback                  ,
    TerminalCommitSignalInfo                ,
    afterTerminalCommit                     ,
    genClosure_TerminalCommit               ,
    mk_TerminalCommitCallback               ,
    noTerminalCommitCallback                ,
    onTerminalCommit                        ,
    wrap_TerminalCommitCallback             ,


-- ** contentsChanged #signal:contentsChanged#
    C_TerminalContentsChangedCallback       ,
    TerminalContentsChangedCallback         ,
    TerminalContentsChangedSignalInfo       ,
    afterTerminalContentsChanged            ,
    genClosure_TerminalContentsChanged      ,
    mk_TerminalContentsChangedCallback      ,
    noTerminalContentsChangedCallback       ,
    onTerminalContentsChanged               ,
    wrap_TerminalContentsChangedCallback    ,


-- ** copyClipboard #signal:copyClipboard#
    C_TerminalCopyClipboardCallback         ,
    TerminalCopyClipboardCallback           ,
    TerminalCopyClipboardSignalInfo         ,
    afterTerminalCopyClipboard              ,
    genClosure_TerminalCopyClipboard        ,
    mk_TerminalCopyClipboardCallback        ,
    noTerminalCopyClipboardCallback         ,
    onTerminalCopyClipboard                 ,
    wrap_TerminalCopyClipboardCallback      ,


-- ** currentDirectoryUriChanged #signal:currentDirectoryUriChanged#
    C_TerminalCurrentDirectoryUriChangedCallback,
    TerminalCurrentDirectoryUriChangedCallback,
    TerminalCurrentDirectoryUriChangedSignalInfo,
    afterTerminalCurrentDirectoryUriChanged ,
    genClosure_TerminalCurrentDirectoryUriChanged,
    mk_TerminalCurrentDirectoryUriChangedCallback,
    noTerminalCurrentDirectoryUriChangedCallback,
    onTerminalCurrentDirectoryUriChanged    ,
    wrap_TerminalCurrentDirectoryUriChangedCallback,


-- ** currentFileUriChanged #signal:currentFileUriChanged#
    C_TerminalCurrentFileUriChangedCallback ,
    TerminalCurrentFileUriChangedCallback   ,
    TerminalCurrentFileUriChangedSignalInfo ,
    afterTerminalCurrentFileUriChanged      ,
    genClosure_TerminalCurrentFileUriChanged,
    mk_TerminalCurrentFileUriChangedCallback,
    noTerminalCurrentFileUriChangedCallback ,
    onTerminalCurrentFileUriChanged         ,
    wrap_TerminalCurrentFileUriChangedCallback,


-- ** cursorMoved #signal:cursorMoved#
    C_TerminalCursorMovedCallback           ,
    TerminalCursorMovedCallback             ,
    TerminalCursorMovedSignalInfo           ,
    afterTerminalCursorMoved                ,
    genClosure_TerminalCursorMoved          ,
    mk_TerminalCursorMovedCallback          ,
    noTerminalCursorMovedCallback           ,
    onTerminalCursorMoved                   ,
    wrap_TerminalCursorMovedCallback        ,


-- ** decreaseFontSize #signal:decreaseFontSize#
    C_TerminalDecreaseFontSizeCallback      ,
    TerminalDecreaseFontSizeCallback        ,
    TerminalDecreaseFontSizeSignalInfo      ,
    afterTerminalDecreaseFontSize           ,
    genClosure_TerminalDecreaseFontSize     ,
    mk_TerminalDecreaseFontSizeCallback     ,
    noTerminalDecreaseFontSizeCallback      ,
    onTerminalDecreaseFontSize              ,
    wrap_TerminalDecreaseFontSizeCallback   ,


-- ** deiconifyWindow #signal:deiconifyWindow#
    C_TerminalDeiconifyWindowCallback       ,
    TerminalDeiconifyWindowCallback         ,
    TerminalDeiconifyWindowSignalInfo       ,
    afterTerminalDeiconifyWindow            ,
    genClosure_TerminalDeiconifyWindow      ,
    mk_TerminalDeiconifyWindowCallback      ,
    noTerminalDeiconifyWindowCallback       ,
    onTerminalDeiconifyWindow               ,
    wrap_TerminalDeiconifyWindowCallback    ,


-- ** encodingChanged #signal:encodingChanged#
    C_TerminalEncodingChangedCallback       ,
    TerminalEncodingChangedCallback         ,
    TerminalEncodingChangedSignalInfo       ,
    afterTerminalEncodingChanged            ,
    genClosure_TerminalEncodingChanged      ,
    mk_TerminalEncodingChangedCallback      ,
    noTerminalEncodingChangedCallback       ,
    onTerminalEncodingChanged               ,
    wrap_TerminalEncodingChangedCallback    ,


-- ** eof #signal:eof#
    C_TerminalEofCallback                   ,
    TerminalEofCallback                     ,
    TerminalEofSignalInfo                   ,
    afterTerminalEof                        ,
    genClosure_TerminalEof                  ,
    mk_TerminalEofCallback                  ,
    noTerminalEofCallback                   ,
    onTerminalEof                           ,
    wrap_TerminalEofCallback                ,


-- ** iconTitleChanged #signal:iconTitleChanged#
    C_TerminalIconTitleChangedCallback      ,
    TerminalIconTitleChangedCallback        ,
    TerminalIconTitleChangedSignalInfo      ,
    afterTerminalIconTitleChanged           ,
    genClosure_TerminalIconTitleChanged     ,
    mk_TerminalIconTitleChangedCallback     ,
    noTerminalIconTitleChangedCallback      ,
    onTerminalIconTitleChanged              ,
    wrap_TerminalIconTitleChangedCallback   ,


-- ** iconifyWindow #signal:iconifyWindow#
    C_TerminalIconifyWindowCallback         ,
    TerminalIconifyWindowCallback           ,
    TerminalIconifyWindowSignalInfo         ,
    afterTerminalIconifyWindow              ,
    genClosure_TerminalIconifyWindow        ,
    mk_TerminalIconifyWindowCallback        ,
    noTerminalIconifyWindowCallback         ,
    onTerminalIconifyWindow                 ,
    wrap_TerminalIconifyWindowCallback      ,


-- ** increaseFontSize #signal:increaseFontSize#
    C_TerminalIncreaseFontSizeCallback      ,
    TerminalIncreaseFontSizeCallback        ,
    TerminalIncreaseFontSizeSignalInfo      ,
    afterTerminalIncreaseFontSize           ,
    genClosure_TerminalIncreaseFontSize     ,
    mk_TerminalIncreaseFontSizeCallback     ,
    noTerminalIncreaseFontSizeCallback      ,
    onTerminalIncreaseFontSize              ,
    wrap_TerminalIncreaseFontSizeCallback   ,


-- ** lowerWindow #signal:lowerWindow#
    C_TerminalLowerWindowCallback           ,
    TerminalLowerWindowCallback             ,
    TerminalLowerWindowSignalInfo           ,
    afterTerminalLowerWindow                ,
    genClosure_TerminalLowerWindow          ,
    mk_TerminalLowerWindowCallback          ,
    noTerminalLowerWindowCallback           ,
    onTerminalLowerWindow                   ,
    wrap_TerminalLowerWindowCallback        ,


-- ** maximizeWindow #signal:maximizeWindow#
    C_TerminalMaximizeWindowCallback        ,
    TerminalMaximizeWindowCallback          ,
    TerminalMaximizeWindowSignalInfo        ,
    afterTerminalMaximizeWindow             ,
    genClosure_TerminalMaximizeWindow       ,
    mk_TerminalMaximizeWindowCallback       ,
    noTerminalMaximizeWindowCallback        ,
    onTerminalMaximizeWindow                ,
    wrap_TerminalMaximizeWindowCallback     ,


-- ** moveWindow #signal:moveWindow#
    C_TerminalMoveWindowCallback            ,
    TerminalMoveWindowCallback              ,
    TerminalMoveWindowSignalInfo            ,
    afterTerminalMoveWindow                 ,
    genClosure_TerminalMoveWindow           ,
    mk_TerminalMoveWindowCallback           ,
    noTerminalMoveWindowCallback            ,
    onTerminalMoveWindow                    ,
    wrap_TerminalMoveWindowCallback         ,


-- ** notificationReceived #signal:notificationReceived#
    C_TerminalNotificationReceivedCallback  ,
    TerminalNotificationReceivedCallback    ,
    TerminalNotificationReceivedSignalInfo  ,
    afterTerminalNotificationReceived       ,
    genClosure_TerminalNotificationReceived ,
    mk_TerminalNotificationReceivedCallback ,
    noTerminalNotificationReceivedCallback  ,
    onTerminalNotificationReceived          ,
    wrap_TerminalNotificationReceivedCallback,


-- ** pasteClipboard #signal:pasteClipboard#
    C_TerminalPasteClipboardCallback        ,
    TerminalPasteClipboardCallback          ,
    TerminalPasteClipboardSignalInfo        ,
    afterTerminalPasteClipboard             ,
    genClosure_TerminalPasteClipboard       ,
    mk_TerminalPasteClipboardCallback       ,
    noTerminalPasteClipboardCallback        ,
    onTerminalPasteClipboard                ,
    wrap_TerminalPasteClipboardCallback     ,


-- ** raiseWindow #signal:raiseWindow#
    C_TerminalRaiseWindowCallback           ,
    TerminalRaiseWindowCallback             ,
    TerminalRaiseWindowSignalInfo           ,
    afterTerminalRaiseWindow                ,
    genClosure_TerminalRaiseWindow          ,
    mk_TerminalRaiseWindowCallback          ,
    noTerminalRaiseWindowCallback           ,
    onTerminalRaiseWindow                   ,
    wrap_TerminalRaiseWindowCallback        ,


-- ** refreshWindow #signal:refreshWindow#
    C_TerminalRefreshWindowCallback         ,
    TerminalRefreshWindowCallback           ,
    TerminalRefreshWindowSignalInfo         ,
    afterTerminalRefreshWindow              ,
    genClosure_TerminalRefreshWindow        ,
    mk_TerminalRefreshWindowCallback        ,
    noTerminalRefreshWindowCallback         ,
    onTerminalRefreshWindow                 ,
    wrap_TerminalRefreshWindowCallback      ,


-- ** resizeWindow #signal:resizeWindow#
    C_TerminalResizeWindowCallback          ,
    TerminalResizeWindowCallback            ,
    TerminalResizeWindowSignalInfo          ,
    afterTerminalResizeWindow               ,
    genClosure_TerminalResizeWindow         ,
    mk_TerminalResizeWindowCallback         ,
    noTerminalResizeWindowCallback          ,
    onTerminalResizeWindow                  ,
    wrap_TerminalResizeWindowCallback       ,


-- ** restoreWindow #signal:restoreWindow#
    C_TerminalRestoreWindowCallback         ,
    TerminalRestoreWindowCallback           ,
    TerminalRestoreWindowSignalInfo         ,
    afterTerminalRestoreWindow              ,
    genClosure_TerminalRestoreWindow        ,
    mk_TerminalRestoreWindowCallback        ,
    noTerminalRestoreWindowCallback         ,
    onTerminalRestoreWindow                 ,
    wrap_TerminalRestoreWindowCallback      ,


-- ** selectionChanged #signal:selectionChanged#
    C_TerminalSelectionChangedCallback      ,
    TerminalSelectionChangedCallback        ,
    TerminalSelectionChangedSignalInfo      ,
    afterTerminalSelectionChanged           ,
    genClosure_TerminalSelectionChanged     ,
    mk_TerminalSelectionChangedCallback     ,
    noTerminalSelectionChangedCallback      ,
    onTerminalSelectionChanged              ,
    wrap_TerminalSelectionChangedCallback   ,


-- ** textDeleted #signal:textDeleted#
    C_TerminalTextDeletedCallback           ,
    TerminalTextDeletedCallback             ,
    TerminalTextDeletedSignalInfo           ,
    afterTerminalTextDeleted                ,
    genClosure_TerminalTextDeleted          ,
    mk_TerminalTextDeletedCallback          ,
    noTerminalTextDeletedCallback           ,
    onTerminalTextDeleted                   ,
    wrap_TerminalTextDeletedCallback        ,


-- ** textInserted #signal:textInserted#
    C_TerminalTextInsertedCallback          ,
    TerminalTextInsertedCallback            ,
    TerminalTextInsertedSignalInfo          ,
    afterTerminalTextInserted               ,
    genClosure_TerminalTextInserted         ,
    mk_TerminalTextInsertedCallback         ,
    noTerminalTextInsertedCallback          ,
    onTerminalTextInserted                  ,
    wrap_TerminalTextInsertedCallback       ,


-- ** textModified #signal:textModified#
    C_TerminalTextModifiedCallback          ,
    TerminalTextModifiedCallback            ,
    TerminalTextModifiedSignalInfo          ,
    afterTerminalTextModified               ,
    genClosure_TerminalTextModified         ,
    mk_TerminalTextModifiedCallback         ,
    noTerminalTextModifiedCallback          ,
    onTerminalTextModified                  ,
    wrap_TerminalTextModifiedCallback       ,


-- ** textScrolled #signal:textScrolled#
    C_TerminalTextScrolledCallback          ,
    TerminalTextScrolledCallback            ,
    TerminalTextScrolledSignalInfo          ,
    afterTerminalTextScrolled               ,
    genClosure_TerminalTextScrolled         ,
    mk_TerminalTextScrolledCallback         ,
    noTerminalTextScrolledCallback          ,
    onTerminalTextScrolled                  ,
    wrap_TerminalTextScrolledCallback       ,


-- ** windowTitleChanged #signal:windowTitleChanged#
    C_TerminalWindowTitleChangedCallback    ,
    TerminalWindowTitleChangedCallback      ,
    TerminalWindowTitleChangedSignalInfo    ,
    afterTerminalWindowTitleChanged         ,
    genClosure_TerminalWindowTitleChanged   ,
    mk_TerminalWindowTitleChangedCallback   ,
    noTerminalWindowTitleChangedCallback    ,
    onTerminalWindowTitleChanged            ,
    wrap_TerminalWindowTitleChangedCallback ,




    ) 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.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.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Flags as GLib.Flags
import qualified GI.GLib.Structs.Regex as GLib.Regex
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Objects.Cursor as Gdk.Cursor
import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.OutputStream as Gio.OutputStream
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Objects.Window as Gtk.Window
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
import {-# SOURCE #-} qualified GI.Vte.Enums as Vte.Enums
import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags
import {-# SOURCE #-} qualified GI.Vte.Objects.Pty as Vte.Pty
import {-# SOURCE #-} qualified GI.Vte.Structs.Regex as Vte.Regex

newtype Terminal = Terminal (ManagedPtr Terminal)
foreign import ccall "vte_terminal_get_type"
    c_vte_terminal_get_type :: IO GType

instance GObject Terminal where
    gobjectType _ = c_vte_terminal_get_type
    

class GObject o => IsTerminal o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Terminal a) =>
    IsTerminal a
#endif
instance IsTerminal Terminal
instance Gtk.Widget.IsWidget Terminal
instance GObject.Object.IsObject Terminal
instance Atk.ImplementorIface.IsImplementorIface Terminal
instance Gtk.Buildable.IsBuildable Terminal
instance Gtk.Scrollable.IsScrollable Terminal

toTerminal :: IsTerminal o => o -> IO Terminal
toTerminal = unsafeCastTo Terminal

noTerminal :: Maybe Terminal
noTerminal = Nothing

type family ResolveTerminalMethod (t :: Symbol) (o :: *) :: * where
    ResolveTerminalMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTerminalMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTerminalMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTerminalMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTerminalMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTerminalMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTerminalMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTerminalMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTerminalMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTerminalMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTerminalMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTerminalMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo
    ResolveTerminalMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTerminalMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTerminalMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTerminalMethod "copyClipboard" o = TerminalCopyClipboardMethodInfo
    ResolveTerminalMethod "copyPrimary" o = TerminalCopyPrimaryMethodInfo
    ResolveTerminalMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTerminalMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTerminalMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTerminalMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTerminalMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTerminalMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTerminalMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTerminalMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTerminalMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTerminalMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTerminalMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTerminalMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTerminalMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTerminalMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTerminalMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTerminalMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTerminalMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTerminalMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTerminalMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTerminalMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTerminalMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTerminalMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTerminalMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTerminalMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTerminalMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTerminalMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTerminalMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTerminalMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTerminalMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTerminalMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTerminalMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTerminalMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTerminalMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTerminalMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTerminalMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTerminalMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTerminalMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTerminalMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTerminalMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTerminalMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTerminalMethod "feed" o = TerminalFeedMethodInfo
    ResolveTerminalMethod "feedChild" o = TerminalFeedChildMethodInfo
    ResolveTerminalMethod "feedChildBinary" o = TerminalFeedChildBinaryMethodInfo
    ResolveTerminalMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTerminalMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTerminalMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTerminalMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTerminalMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTerminalMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTerminalMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTerminalMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTerminalMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTerminalMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTerminalMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTerminalMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTerminalMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTerminalMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTerminalMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTerminalMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTerminalMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTerminalMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTerminalMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTerminalMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTerminalMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTerminalMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveTerminalMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTerminalMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTerminalMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTerminalMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTerminalMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTerminalMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTerminalMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTerminalMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTerminalMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTerminalMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTerminalMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTerminalMethod "matchAddGregex" o = TerminalMatchAddGregexMethodInfo
    ResolveTerminalMethod "matchAddRegex" o = TerminalMatchAddRegexMethodInfo
    ResolveTerminalMethod "matchCheck" o = TerminalMatchCheckMethodInfo
    ResolveTerminalMethod "matchCheckEvent" o = TerminalMatchCheckEventMethodInfo
    ResolveTerminalMethod "matchRemove" o = TerminalMatchRemoveMethodInfo
    ResolveTerminalMethod "matchRemoveAll" o = TerminalMatchRemoveAllMethodInfo
    ResolveTerminalMethod "matchSetCursor" o = TerminalMatchSetCursorMethodInfo
    ResolveTerminalMethod "matchSetCursorName" o = TerminalMatchSetCursorNameMethodInfo
    ResolveTerminalMethod "matchSetCursorType" o = TerminalMatchSetCursorTypeMethodInfo
    ResolveTerminalMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTerminalMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTerminalMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTerminalMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTerminalMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTerminalMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTerminalMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTerminalMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTerminalMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTerminalMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTerminalMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTerminalMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTerminalMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTerminalMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTerminalMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTerminalMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTerminalMethod "pasteClipboard" o = TerminalPasteClipboardMethodInfo
    ResolveTerminalMethod "pastePrimary" o = TerminalPastePrimaryMethodInfo
    ResolveTerminalMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTerminalMethod "ptyNewSync" o = TerminalPtyNewSyncMethodInfo
    ResolveTerminalMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTerminalMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTerminalMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTerminalMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTerminalMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTerminalMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTerminalMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTerminalMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTerminalMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTerminalMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTerminalMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTerminalMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTerminalMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTerminalMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTerminalMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTerminalMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTerminalMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTerminalMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTerminalMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveTerminalMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveTerminalMethod "reset" o = TerminalResetMethodInfo
    ResolveTerminalMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTerminalMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTerminalMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTerminalMethod "searchFindNext" o = TerminalSearchFindNextMethodInfo
    ResolveTerminalMethod "searchFindPrevious" o = TerminalSearchFindPreviousMethodInfo
    ResolveTerminalMethod "searchGetGregex" o = TerminalSearchGetGregexMethodInfo
    ResolveTerminalMethod "searchGetRegex" o = TerminalSearchGetRegexMethodInfo
    ResolveTerminalMethod "searchGetWrapAround" o = TerminalSearchGetWrapAroundMethodInfo
    ResolveTerminalMethod "searchSetGregex" o = TerminalSearchSetGregexMethodInfo
    ResolveTerminalMethod "searchSetRegex" o = TerminalSearchSetRegexMethodInfo
    ResolveTerminalMethod "searchSetWrapAround" o = TerminalSearchSetWrapAroundMethodInfo
    ResolveTerminalMethod "selectAll" o = TerminalSelectAllMethodInfo
    ResolveTerminalMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTerminalMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTerminalMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTerminalMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTerminalMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTerminalMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTerminalMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTerminalMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTerminalMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTerminalMethod "spawnSync" o = TerminalSpawnSyncMethodInfo
    ResolveTerminalMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTerminalMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTerminalMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTerminalMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTerminalMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveTerminalMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTerminalMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTerminalMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTerminalMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTerminalMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTerminalMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTerminalMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTerminalMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTerminalMethod "unselectAll" o = TerminalUnselectAllMethodInfo
    ResolveTerminalMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTerminalMethod "watchChild" o = TerminalWatchChildMethodInfo
    ResolveTerminalMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTerminalMethod "writeContentsSync" o = TerminalWriteContentsSyncMethodInfo
    ResolveTerminalMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTerminalMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTerminalMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTerminalMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTerminalMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTerminalMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTerminalMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTerminalMethod "getAllowBold" o = TerminalGetAllowBoldMethodInfo
    ResolveTerminalMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTerminalMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTerminalMethod "getAudibleBell" o = TerminalGetAudibleBellMethodInfo
    ResolveTerminalMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveTerminalMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTerminalMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTerminalMethod "getCharHeight" o = TerminalGetCharHeightMethodInfo
    ResolveTerminalMethod "getCharWidth" o = TerminalGetCharWidthMethodInfo
    ResolveTerminalMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTerminalMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTerminalMethod "getCjkAmbiguousWidth" o = TerminalGetCjkAmbiguousWidthMethodInfo
    ResolveTerminalMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTerminalMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTerminalMethod "getColumnCount" o = TerminalGetColumnCountMethodInfo
    ResolveTerminalMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTerminalMethod "getCurrentDirectoryUri" o = TerminalGetCurrentDirectoryUriMethodInfo
    ResolveTerminalMethod "getCurrentFileUri" o = TerminalGetCurrentFileUriMethodInfo
    ResolveTerminalMethod "getCursorBlinkMode" o = TerminalGetCursorBlinkModeMethodInfo
    ResolveTerminalMethod "getCursorPosition" o = TerminalGetCursorPositionMethodInfo
    ResolveTerminalMethod "getCursorShape" o = TerminalGetCursorShapeMethodInfo
    ResolveTerminalMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTerminalMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTerminalMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTerminalMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTerminalMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTerminalMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTerminalMethod "getEncoding" o = TerminalGetEncodingMethodInfo
    ResolveTerminalMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTerminalMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTerminalMethod "getFont" o = TerminalGetFontMethodInfo
    ResolveTerminalMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTerminalMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTerminalMethod "getFontScale" o = TerminalGetFontScaleMethodInfo
    ResolveTerminalMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTerminalMethod "getGeometryHints" o = TerminalGetGeometryHintsMethodInfo
    ResolveTerminalMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
    ResolveTerminalMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTerminalMethod "getHasSelection" o = TerminalGetHasSelectionMethodInfo
    ResolveTerminalMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTerminalMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTerminalMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTerminalMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTerminalMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveTerminalMethod "getIconTitle" o = TerminalGetIconTitleMethodInfo
    ResolveTerminalMethod "getInputEnabled" o = TerminalGetInputEnabledMethodInfo
    ResolveTerminalMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTerminalMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTerminalMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTerminalMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTerminalMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTerminalMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTerminalMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTerminalMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTerminalMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTerminalMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTerminalMethod "getMouseAutohide" o = TerminalGetMouseAutohideMethodInfo
    ResolveTerminalMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTerminalMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTerminalMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTerminalMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTerminalMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTerminalMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTerminalMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTerminalMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTerminalMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTerminalMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTerminalMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTerminalMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTerminalMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTerminalMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveTerminalMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTerminalMethod "getPty" o = TerminalGetPtyMethodInfo
    ResolveTerminalMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTerminalMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTerminalMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTerminalMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTerminalMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTerminalMethod "getRewrapOnResize" o = TerminalGetRewrapOnResizeMethodInfo
    ResolveTerminalMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTerminalMethod "getRowCount" o = TerminalGetRowCountMethodInfo
    ResolveTerminalMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTerminalMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTerminalMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTerminalMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTerminalMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTerminalMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTerminalMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTerminalMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTerminalMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTerminalMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTerminalMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTerminalMethod "getText" o = TerminalGetTextMethodInfo
    ResolveTerminalMethod "getTextIncludeTrailingSpaces" o = TerminalGetTextIncludeTrailingSpacesMethodInfo
    ResolveTerminalMethod "getTextRange" o = TerminalGetTextRangeMethodInfo
    ResolveTerminalMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTerminalMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTerminalMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTerminalMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTerminalMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
    ResolveTerminalMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTerminalMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTerminalMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTerminalMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTerminalMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTerminalMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTerminalMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveTerminalMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTerminalMethod "getWindowTitle" o = TerminalGetWindowTitleMethodInfo
    ResolveTerminalMethod "getWordCharExceptions" o = TerminalGetWordCharExceptionsMethodInfo
    ResolveTerminalMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTerminalMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTerminalMethod "setAllowBold" o = TerminalSetAllowBoldMethodInfo
    ResolveTerminalMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTerminalMethod "setAudibleBell" o = TerminalSetAudibleBellMethodInfo
    ResolveTerminalMethod "setBackspaceBinding" o = TerminalSetBackspaceBindingMethodInfo
    ResolveTerminalMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTerminalMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTerminalMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTerminalMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTerminalMethod "setCjkAmbiguousWidth" o = TerminalSetCjkAmbiguousWidthMethodInfo
    ResolveTerminalMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTerminalMethod "setColorBackground" o = TerminalSetColorBackgroundMethodInfo
    ResolveTerminalMethod "setColorBold" o = TerminalSetColorBoldMethodInfo
    ResolveTerminalMethod "setColorCursor" o = TerminalSetColorCursorMethodInfo
    ResolveTerminalMethod "setColorCursorForeground" o = TerminalSetColorCursorForegroundMethodInfo
    ResolveTerminalMethod "setColorForeground" o = TerminalSetColorForegroundMethodInfo
    ResolveTerminalMethod "setColorHighlight" o = TerminalSetColorHighlightMethodInfo
    ResolveTerminalMethod "setColorHighlightForeground" o = TerminalSetColorHighlightForegroundMethodInfo
    ResolveTerminalMethod "setColors" o = TerminalSetColorsMethodInfo
    ResolveTerminalMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTerminalMethod "setCursorBlinkMode" o = TerminalSetCursorBlinkModeMethodInfo
    ResolveTerminalMethod "setCursorShape" o = TerminalSetCursorShapeMethodInfo
    ResolveTerminalMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTerminalMethod "setDefaultColors" o = TerminalSetDefaultColorsMethodInfo
    ResolveTerminalMethod "setDeleteBinding" o = TerminalSetDeleteBindingMethodInfo
    ResolveTerminalMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTerminalMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTerminalMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTerminalMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTerminalMethod "setEncoding" o = TerminalSetEncodingMethodInfo
    ResolveTerminalMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTerminalMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTerminalMethod "setFont" o = TerminalSetFontMethodInfo
    ResolveTerminalMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTerminalMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTerminalMethod "setFontScale" o = TerminalSetFontScaleMethodInfo
    ResolveTerminalMethod "setGeometryHintsForWindow" o = TerminalSetGeometryHintsForWindowMethodInfo
    ResolveTerminalMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
    ResolveTerminalMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTerminalMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTerminalMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTerminalMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTerminalMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTerminalMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveTerminalMethod "setInputEnabled" o = TerminalSetInputEnabledMethodInfo
    ResolveTerminalMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTerminalMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTerminalMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTerminalMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTerminalMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTerminalMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTerminalMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTerminalMethod "setMouseAutohide" o = TerminalSetMouseAutohideMethodInfo
    ResolveTerminalMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTerminalMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTerminalMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTerminalMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTerminalMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTerminalMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTerminalMethod "setPty" o = TerminalSetPtyMethodInfo
    ResolveTerminalMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTerminalMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTerminalMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTerminalMethod "setRewrapOnResize" o = TerminalSetRewrapOnResizeMethodInfo
    ResolveTerminalMethod "setScrollOnKeystroke" o = TerminalSetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "setScrollOnOutput" o = TerminalSetScrollOnOutputMethodInfo
    ResolveTerminalMethod "setScrollSpeed" o = TerminalSetScrollSpeedMethodInfo
    ResolveTerminalMethod "setScrollbackLines" o = TerminalSetScrollbackLinesMethodInfo
    ResolveTerminalMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTerminalMethod "setSize" o = TerminalSetSizeMethodInfo
    ResolveTerminalMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTerminalMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTerminalMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTerminalMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTerminalMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTerminalMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTerminalMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTerminalMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveTerminalMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
    ResolveTerminalMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTerminalMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTerminalMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTerminalMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTerminalMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTerminalMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveTerminalMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveTerminalMethod "setWordCharExceptions" o = TerminalSetWordCharExceptionsMethodInfo
    ResolveTerminalMethod l o = O.MethodResolutionFailed l o

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

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

-- signal Terminal::bell
type TerminalBellCallback =
    IO ()

noTerminalBellCallback :: Maybe TerminalBellCallback
noTerminalBellCallback = Nothing

type C_TerminalBellCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalBellCallback :: C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)

genClosure_TerminalBell :: TerminalBellCallback -> IO Closure
genClosure_TerminalBell cb = do
    let cb' = wrap_TerminalBellCallback cb
    mk_TerminalBellCallback cb' >>= newCClosure


wrap_TerminalBellCallback ::
    TerminalBellCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalBellCallback _cb _ _ = do
    _cb 


onTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
onTerminalBell obj cb = liftIO $ do
    let cb' = wrap_TerminalBellCallback cb
    cb'' <- mk_TerminalBellCallback cb'
    connectSignalFunPtr obj "bell" cb'' SignalConnectBefore

afterTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId
afterTerminalBell obj cb = liftIO $ do
    let cb' = wrap_TerminalBellCallback cb
    cb'' <- mk_TerminalBellCallback cb'
    connectSignalFunPtr obj "bell" cb'' SignalConnectAfter


-- signal Terminal::char-size-changed
type TerminalCharSizeChangedCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalCharSizeChangedCallback = Nothing

type C_TerminalCharSizeChangedCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCharSizeChangedCallback :: C_TerminalCharSizeChangedCallback -> IO (FunPtr C_TerminalCharSizeChangedCallback)

genClosure_TerminalCharSizeChanged :: TerminalCharSizeChangedCallback -> IO Closure
genClosure_TerminalCharSizeChanged cb = do
    let cb' = wrap_TerminalCharSizeChangedCallback cb
    mk_TerminalCharSizeChangedCallback cb' >>= newCClosure


wrap_TerminalCharSizeChangedCallback ::
    TerminalCharSizeChangedCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_TerminalCharSizeChangedCallback _cb _ width height _ = do
    _cb  width height


onTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
onTerminalCharSizeChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCharSizeChangedCallback cb
    cb'' <- mk_TerminalCharSizeChangedCallback cb'
    connectSignalFunPtr obj "char-size-changed" cb'' SignalConnectBefore

afterTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId
afterTerminalCharSizeChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCharSizeChangedCallback cb
    cb'' <- mk_TerminalCharSizeChangedCallback cb'
    connectSignalFunPtr obj "char-size-changed" cb'' SignalConnectAfter


-- signal Terminal::child-exited
type TerminalChildExitedCallback =
    Int32 ->
    IO ()

noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback
noTerminalChildExitedCallback = Nothing

type C_TerminalChildExitedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalChildExitedCallback :: C_TerminalChildExitedCallback -> IO (FunPtr C_TerminalChildExitedCallback)

genClosure_TerminalChildExited :: TerminalChildExitedCallback -> IO Closure
genClosure_TerminalChildExited cb = do
    let cb' = wrap_TerminalChildExitedCallback cb
    mk_TerminalChildExitedCallback cb' >>= newCClosure


wrap_TerminalChildExitedCallback ::
    TerminalChildExitedCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TerminalChildExitedCallback _cb _ status _ = do
    _cb  status


onTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
onTerminalChildExited obj cb = liftIO $ do
    let cb' = wrap_TerminalChildExitedCallback cb
    cb'' <- mk_TerminalChildExitedCallback cb'
    connectSignalFunPtr obj "child-exited" cb'' SignalConnectBefore

afterTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId
afterTerminalChildExited obj cb = liftIO $ do
    let cb' = wrap_TerminalChildExitedCallback cb
    cb'' <- mk_TerminalChildExitedCallback cb'
    connectSignalFunPtr obj "child-exited" cb'' SignalConnectAfter


-- signal Terminal::commit
type TerminalCommitCallback =
    T.Text ->
    Word32 ->
    IO ()

noTerminalCommitCallback :: Maybe TerminalCommitCallback
noTerminalCommitCallback = Nothing

type C_TerminalCommitCallback =
    Ptr () ->                               -- object
    CString ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCommitCallback :: C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)

genClosure_TerminalCommit :: TerminalCommitCallback -> IO Closure
genClosure_TerminalCommit cb = do
    let cb' = wrap_TerminalCommitCallback cb
    mk_TerminalCommitCallback cb' >>= newCClosure


wrap_TerminalCommitCallback ::
    TerminalCommitCallback ->
    Ptr () ->
    CString ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_TerminalCommitCallback _cb _ text size _ = do
    text' <- cstringToText text
    _cb  text' size


onTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
onTerminalCommit obj cb = liftIO $ do
    let cb' = wrap_TerminalCommitCallback cb
    cb'' <- mk_TerminalCommitCallback cb'
    connectSignalFunPtr obj "commit" cb'' SignalConnectBefore

afterTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId
afterTerminalCommit obj cb = liftIO $ do
    let cb' = wrap_TerminalCommitCallback cb
    cb'' <- mk_TerminalCommitCallback cb'
    connectSignalFunPtr obj "commit" cb'' SignalConnectAfter


-- signal Terminal::contents-changed
type TerminalContentsChangedCallback =
    IO ()

noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback
noTerminalContentsChangedCallback = Nothing

type C_TerminalContentsChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalContentsChangedCallback :: C_TerminalContentsChangedCallback -> IO (FunPtr C_TerminalContentsChangedCallback)

genClosure_TerminalContentsChanged :: TerminalContentsChangedCallback -> IO Closure
genClosure_TerminalContentsChanged cb = do
    let cb' = wrap_TerminalContentsChangedCallback cb
    mk_TerminalContentsChangedCallback cb' >>= newCClosure


wrap_TerminalContentsChangedCallback ::
    TerminalContentsChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalContentsChangedCallback _cb _ _ = do
    _cb 


onTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
onTerminalContentsChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalContentsChangedCallback cb
    cb'' <- mk_TerminalContentsChangedCallback cb'
    connectSignalFunPtr obj "contents-changed" cb'' SignalConnectBefore

afterTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId
afterTerminalContentsChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalContentsChangedCallback cb
    cb'' <- mk_TerminalContentsChangedCallback cb'
    connectSignalFunPtr obj "contents-changed" cb'' SignalConnectAfter


-- signal Terminal::copy-clipboard
type TerminalCopyClipboardCallback =
    IO ()

noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback
noTerminalCopyClipboardCallback = Nothing

type C_TerminalCopyClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCopyClipboardCallback :: C_TerminalCopyClipboardCallback -> IO (FunPtr C_TerminalCopyClipboardCallback)

genClosure_TerminalCopyClipboard :: TerminalCopyClipboardCallback -> IO Closure
genClosure_TerminalCopyClipboard cb = do
    let cb' = wrap_TerminalCopyClipboardCallback cb
    mk_TerminalCopyClipboardCallback cb' >>= newCClosure


wrap_TerminalCopyClipboardCallback ::
    TerminalCopyClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalCopyClipboardCallback _cb _ _ = do
    _cb 


onTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
onTerminalCopyClipboard obj cb = liftIO $ do
    let cb' = wrap_TerminalCopyClipboardCallback cb
    cb'' <- mk_TerminalCopyClipboardCallback cb'
    connectSignalFunPtr obj "copy-clipboard" cb'' SignalConnectBefore

afterTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId
afterTerminalCopyClipboard obj cb = liftIO $ do
    let cb' = wrap_TerminalCopyClipboardCallback cb
    cb'' <- mk_TerminalCopyClipboardCallback cb'
    connectSignalFunPtr obj "copy-clipboard" cb'' SignalConnectAfter


-- signal Terminal::current-directory-uri-changed
type TerminalCurrentDirectoryUriChangedCallback =
    IO ()

noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback
noTerminalCurrentDirectoryUriChangedCallback = Nothing

type C_TerminalCurrentDirectoryUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCurrentDirectoryUriChangedCallback :: C_TerminalCurrentDirectoryUriChangedCallback -> IO (FunPtr C_TerminalCurrentDirectoryUriChangedCallback)

genClosure_TerminalCurrentDirectoryUriChanged :: TerminalCurrentDirectoryUriChangedCallback -> IO Closure
genClosure_TerminalCurrentDirectoryUriChanged cb = do
    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
    mk_TerminalCurrentDirectoryUriChangedCallback cb' >>= newCClosure


wrap_TerminalCurrentDirectoryUriChangedCallback ::
    TerminalCurrentDirectoryUriChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalCurrentDirectoryUriChangedCallback _cb _ _ = do
    _cb 


onTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
onTerminalCurrentDirectoryUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
    cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'
    connectSignalFunPtr obj "current-directory-uri-changed" cb'' SignalConnectBefore

afterTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentDirectoryUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
    cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'
    connectSignalFunPtr obj "current-directory-uri-changed" cb'' SignalConnectAfter


-- signal Terminal::current-file-uri-changed
type TerminalCurrentFileUriChangedCallback =
    IO ()

noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback
noTerminalCurrentFileUriChangedCallback = Nothing

type C_TerminalCurrentFileUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCurrentFileUriChangedCallback :: C_TerminalCurrentFileUriChangedCallback -> IO (FunPtr C_TerminalCurrentFileUriChangedCallback)

genClosure_TerminalCurrentFileUriChanged :: TerminalCurrentFileUriChangedCallback -> IO Closure
genClosure_TerminalCurrentFileUriChanged cb = do
    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
    mk_TerminalCurrentFileUriChangedCallback cb' >>= newCClosure


wrap_TerminalCurrentFileUriChangedCallback ::
    TerminalCurrentFileUriChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalCurrentFileUriChangedCallback _cb _ _ = do
    _cb 


onTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
onTerminalCurrentFileUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
    cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'
    connectSignalFunPtr obj "current-file-uri-changed" cb'' SignalConnectBefore

afterTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId
afterTerminalCurrentFileUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
    cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'
    connectSignalFunPtr obj "current-file-uri-changed" cb'' SignalConnectAfter


-- signal Terminal::cursor-moved
type TerminalCursorMovedCallback =
    IO ()

noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback
noTerminalCursorMovedCallback = Nothing

type C_TerminalCursorMovedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalCursorMovedCallback :: C_TerminalCursorMovedCallback -> IO (FunPtr C_TerminalCursorMovedCallback)

genClosure_TerminalCursorMoved :: TerminalCursorMovedCallback -> IO Closure
genClosure_TerminalCursorMoved cb = do
    let cb' = wrap_TerminalCursorMovedCallback cb
    mk_TerminalCursorMovedCallback cb' >>= newCClosure


wrap_TerminalCursorMovedCallback ::
    TerminalCursorMovedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalCursorMovedCallback _cb _ _ = do
    _cb 


onTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
onTerminalCursorMoved obj cb = liftIO $ do
    let cb' = wrap_TerminalCursorMovedCallback cb
    cb'' <- mk_TerminalCursorMovedCallback cb'
    connectSignalFunPtr obj "cursor-moved" cb'' SignalConnectBefore

afterTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId
afterTerminalCursorMoved obj cb = liftIO $ do
    let cb' = wrap_TerminalCursorMovedCallback cb
    cb'' <- mk_TerminalCursorMovedCallback cb'
    connectSignalFunPtr obj "cursor-moved" cb'' SignalConnectAfter


-- signal Terminal::decrease-font-size
type TerminalDecreaseFontSizeCallback =
    IO ()

noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback
noTerminalDecreaseFontSizeCallback = Nothing

type C_TerminalDecreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalDecreaseFontSizeCallback :: C_TerminalDecreaseFontSizeCallback -> IO (FunPtr C_TerminalDecreaseFontSizeCallback)

genClosure_TerminalDecreaseFontSize :: TerminalDecreaseFontSizeCallback -> IO Closure
genClosure_TerminalDecreaseFontSize cb = do
    let cb' = wrap_TerminalDecreaseFontSizeCallback cb
    mk_TerminalDecreaseFontSizeCallback cb' >>= newCClosure


wrap_TerminalDecreaseFontSizeCallback ::
    TerminalDecreaseFontSizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalDecreaseFontSizeCallback _cb _ _ = do
    _cb 


onTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
onTerminalDecreaseFontSize obj cb = liftIO $ do
    let cb' = wrap_TerminalDecreaseFontSizeCallback cb
    cb'' <- mk_TerminalDecreaseFontSizeCallback cb'
    connectSignalFunPtr obj "decrease-font-size" cb'' SignalConnectBefore

afterTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId
afterTerminalDecreaseFontSize obj cb = liftIO $ do
    let cb' = wrap_TerminalDecreaseFontSizeCallback cb
    cb'' <- mk_TerminalDecreaseFontSizeCallback cb'
    connectSignalFunPtr obj "decrease-font-size" cb'' SignalConnectAfter


-- signal Terminal::deiconify-window
type TerminalDeiconifyWindowCallback =
    IO ()

noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback
noTerminalDeiconifyWindowCallback = Nothing

type C_TerminalDeiconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalDeiconifyWindowCallback :: C_TerminalDeiconifyWindowCallback -> IO (FunPtr C_TerminalDeiconifyWindowCallback)

genClosure_TerminalDeiconifyWindow :: TerminalDeiconifyWindowCallback -> IO Closure
genClosure_TerminalDeiconifyWindow cb = do
    let cb' = wrap_TerminalDeiconifyWindowCallback cb
    mk_TerminalDeiconifyWindowCallback cb' >>= newCClosure


wrap_TerminalDeiconifyWindowCallback ::
    TerminalDeiconifyWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalDeiconifyWindowCallback _cb _ _ = do
    _cb 


onTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
onTerminalDeiconifyWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalDeiconifyWindowCallback cb
    cb'' <- mk_TerminalDeiconifyWindowCallback cb'
    connectSignalFunPtr obj "deiconify-window" cb'' SignalConnectBefore

afterTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId
afterTerminalDeiconifyWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalDeiconifyWindowCallback cb
    cb'' <- mk_TerminalDeiconifyWindowCallback cb'
    connectSignalFunPtr obj "deiconify-window" cb'' SignalConnectAfter


-- signal Terminal::encoding-changed
type TerminalEncodingChangedCallback =
    IO ()

noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback
noTerminalEncodingChangedCallback = Nothing

type C_TerminalEncodingChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalEncodingChangedCallback :: C_TerminalEncodingChangedCallback -> IO (FunPtr C_TerminalEncodingChangedCallback)

genClosure_TerminalEncodingChanged :: TerminalEncodingChangedCallback -> IO Closure
genClosure_TerminalEncodingChanged cb = do
    let cb' = wrap_TerminalEncodingChangedCallback cb
    mk_TerminalEncodingChangedCallback cb' >>= newCClosure


wrap_TerminalEncodingChangedCallback ::
    TerminalEncodingChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalEncodingChangedCallback _cb _ _ = do
    _cb 


onTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
onTerminalEncodingChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalEncodingChangedCallback cb
    cb'' <- mk_TerminalEncodingChangedCallback cb'
    connectSignalFunPtr obj "encoding-changed" cb'' SignalConnectBefore

afterTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId
afterTerminalEncodingChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalEncodingChangedCallback cb
    cb'' <- mk_TerminalEncodingChangedCallback cb'
    connectSignalFunPtr obj "encoding-changed" cb'' SignalConnectAfter


-- signal Terminal::eof
type TerminalEofCallback =
    IO ()

noTerminalEofCallback :: Maybe TerminalEofCallback
noTerminalEofCallback = Nothing

type C_TerminalEofCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalEofCallback :: C_TerminalEofCallback -> IO (FunPtr C_TerminalEofCallback)

genClosure_TerminalEof :: TerminalEofCallback -> IO Closure
genClosure_TerminalEof cb = do
    let cb' = wrap_TerminalEofCallback cb
    mk_TerminalEofCallback cb' >>= newCClosure


wrap_TerminalEofCallback ::
    TerminalEofCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalEofCallback _cb _ _ = do
    _cb 


onTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
onTerminalEof obj cb = liftIO $ do
    let cb' = wrap_TerminalEofCallback cb
    cb'' <- mk_TerminalEofCallback cb'
    connectSignalFunPtr obj "eof" cb'' SignalConnectBefore

afterTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId
afterTerminalEof obj cb = liftIO $ do
    let cb' = wrap_TerminalEofCallback cb
    cb'' <- mk_TerminalEofCallback cb'
    connectSignalFunPtr obj "eof" cb'' SignalConnectAfter


-- signal Terminal::icon-title-changed
type TerminalIconTitleChangedCallback =
    IO ()

noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback
noTerminalIconTitleChangedCallback = Nothing

type C_TerminalIconTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalIconTitleChangedCallback :: C_TerminalIconTitleChangedCallback -> IO (FunPtr C_TerminalIconTitleChangedCallback)

genClosure_TerminalIconTitleChanged :: TerminalIconTitleChangedCallback -> IO Closure
genClosure_TerminalIconTitleChanged cb = do
    let cb' = wrap_TerminalIconTitleChangedCallback cb
    mk_TerminalIconTitleChangedCallback cb' >>= newCClosure


wrap_TerminalIconTitleChangedCallback ::
    TerminalIconTitleChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalIconTitleChangedCallback _cb _ _ = do
    _cb 


onTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
onTerminalIconTitleChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalIconTitleChangedCallback cb
    cb'' <- mk_TerminalIconTitleChangedCallback cb'
    connectSignalFunPtr obj "icon-title-changed" cb'' SignalConnectBefore

afterTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId
afterTerminalIconTitleChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalIconTitleChangedCallback cb
    cb'' <- mk_TerminalIconTitleChangedCallback cb'
    connectSignalFunPtr obj "icon-title-changed" cb'' SignalConnectAfter


-- signal Terminal::iconify-window
type TerminalIconifyWindowCallback =
    IO ()

noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback
noTerminalIconifyWindowCallback = Nothing

type C_TerminalIconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalIconifyWindowCallback :: C_TerminalIconifyWindowCallback -> IO (FunPtr C_TerminalIconifyWindowCallback)

genClosure_TerminalIconifyWindow :: TerminalIconifyWindowCallback -> IO Closure
genClosure_TerminalIconifyWindow cb = do
    let cb' = wrap_TerminalIconifyWindowCallback cb
    mk_TerminalIconifyWindowCallback cb' >>= newCClosure


wrap_TerminalIconifyWindowCallback ::
    TerminalIconifyWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalIconifyWindowCallback _cb _ _ = do
    _cb 


onTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
onTerminalIconifyWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalIconifyWindowCallback cb
    cb'' <- mk_TerminalIconifyWindowCallback cb'
    connectSignalFunPtr obj "iconify-window" cb'' SignalConnectBefore

afterTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId
afterTerminalIconifyWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalIconifyWindowCallback cb
    cb'' <- mk_TerminalIconifyWindowCallback cb'
    connectSignalFunPtr obj "iconify-window" cb'' SignalConnectAfter


-- signal Terminal::increase-font-size
type TerminalIncreaseFontSizeCallback =
    IO ()

noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback
noTerminalIncreaseFontSizeCallback = Nothing

type C_TerminalIncreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalIncreaseFontSizeCallback :: C_TerminalIncreaseFontSizeCallback -> IO (FunPtr C_TerminalIncreaseFontSizeCallback)

genClosure_TerminalIncreaseFontSize :: TerminalIncreaseFontSizeCallback -> IO Closure
genClosure_TerminalIncreaseFontSize cb = do
    let cb' = wrap_TerminalIncreaseFontSizeCallback cb
    mk_TerminalIncreaseFontSizeCallback cb' >>= newCClosure


wrap_TerminalIncreaseFontSizeCallback ::
    TerminalIncreaseFontSizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalIncreaseFontSizeCallback _cb _ _ = do
    _cb 


onTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
onTerminalIncreaseFontSize obj cb = liftIO $ do
    let cb' = wrap_TerminalIncreaseFontSizeCallback cb
    cb'' <- mk_TerminalIncreaseFontSizeCallback cb'
    connectSignalFunPtr obj "increase-font-size" cb'' SignalConnectBefore

afterTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId
afterTerminalIncreaseFontSize obj cb = liftIO $ do
    let cb' = wrap_TerminalIncreaseFontSizeCallback cb
    cb'' <- mk_TerminalIncreaseFontSizeCallback cb'
    connectSignalFunPtr obj "increase-font-size" cb'' SignalConnectAfter


-- signal Terminal::lower-window
type TerminalLowerWindowCallback =
    IO ()

noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback
noTerminalLowerWindowCallback = Nothing

type C_TerminalLowerWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalLowerWindowCallback :: C_TerminalLowerWindowCallback -> IO (FunPtr C_TerminalLowerWindowCallback)

genClosure_TerminalLowerWindow :: TerminalLowerWindowCallback -> IO Closure
genClosure_TerminalLowerWindow cb = do
    let cb' = wrap_TerminalLowerWindowCallback cb
    mk_TerminalLowerWindowCallback cb' >>= newCClosure


wrap_TerminalLowerWindowCallback ::
    TerminalLowerWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalLowerWindowCallback _cb _ _ = do
    _cb 


onTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
onTerminalLowerWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalLowerWindowCallback cb
    cb'' <- mk_TerminalLowerWindowCallback cb'
    connectSignalFunPtr obj "lower-window" cb'' SignalConnectBefore

afterTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId
afterTerminalLowerWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalLowerWindowCallback cb
    cb'' <- mk_TerminalLowerWindowCallback cb'
    connectSignalFunPtr obj "lower-window" cb'' SignalConnectAfter


-- signal Terminal::maximize-window
type TerminalMaximizeWindowCallback =
    IO ()

noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback
noTerminalMaximizeWindowCallback = Nothing

type C_TerminalMaximizeWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalMaximizeWindowCallback :: C_TerminalMaximizeWindowCallback -> IO (FunPtr C_TerminalMaximizeWindowCallback)

genClosure_TerminalMaximizeWindow :: TerminalMaximizeWindowCallback -> IO Closure
genClosure_TerminalMaximizeWindow cb = do
    let cb' = wrap_TerminalMaximizeWindowCallback cb
    mk_TerminalMaximizeWindowCallback cb' >>= newCClosure


wrap_TerminalMaximizeWindowCallback ::
    TerminalMaximizeWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalMaximizeWindowCallback _cb _ _ = do
    _cb 


onTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
onTerminalMaximizeWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalMaximizeWindowCallback cb
    cb'' <- mk_TerminalMaximizeWindowCallback cb'
    connectSignalFunPtr obj "maximize-window" cb'' SignalConnectBefore

afterTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId
afterTerminalMaximizeWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalMaximizeWindowCallback cb
    cb'' <- mk_TerminalMaximizeWindowCallback cb'
    connectSignalFunPtr obj "maximize-window" cb'' SignalConnectAfter


-- signal Terminal::move-window
type TerminalMoveWindowCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback
noTerminalMoveWindowCallback = Nothing

type C_TerminalMoveWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalMoveWindowCallback :: C_TerminalMoveWindowCallback -> IO (FunPtr C_TerminalMoveWindowCallback)

genClosure_TerminalMoveWindow :: TerminalMoveWindowCallback -> IO Closure
genClosure_TerminalMoveWindow cb = do
    let cb' = wrap_TerminalMoveWindowCallback cb
    mk_TerminalMoveWindowCallback cb' >>= newCClosure


wrap_TerminalMoveWindowCallback ::
    TerminalMoveWindowCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_TerminalMoveWindowCallback _cb _ x y _ = do
    _cb  x y


onTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
onTerminalMoveWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalMoveWindowCallback cb
    cb'' <- mk_TerminalMoveWindowCallback cb'
    connectSignalFunPtr obj "move-window" cb'' SignalConnectBefore

afterTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId
afterTerminalMoveWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalMoveWindowCallback cb
    cb'' <- mk_TerminalMoveWindowCallback cb'
    connectSignalFunPtr obj "move-window" cb'' SignalConnectAfter


-- signal Terminal::notification-received
type TerminalNotificationReceivedCallback =
    T.Text ->
    Maybe T.Text ->
    IO ()

noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback
noTerminalNotificationReceivedCallback = Nothing

type C_TerminalNotificationReceivedCallback =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalNotificationReceivedCallback :: C_TerminalNotificationReceivedCallback -> IO (FunPtr C_TerminalNotificationReceivedCallback)

genClosure_TerminalNotificationReceived :: TerminalNotificationReceivedCallback -> IO Closure
genClosure_TerminalNotificationReceived cb = do
    let cb' = wrap_TerminalNotificationReceivedCallback cb
    mk_TerminalNotificationReceivedCallback cb' >>= newCClosure


wrap_TerminalNotificationReceivedCallback ::
    TerminalNotificationReceivedCallback ->
    Ptr () ->
    CString ->
    CString ->
    Ptr () ->
    IO ()
wrap_TerminalNotificationReceivedCallback _cb _ summary body _ = do
    summary' <- cstringToText summary
    maybeBody <-
        if body == nullPtr
        then return Nothing
        else do
            body' <- cstringToText body
            return $ Just body'
    _cb  summary' maybeBody


onTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
onTerminalNotificationReceived obj cb = liftIO $ do
    let cb' = wrap_TerminalNotificationReceivedCallback cb
    cb'' <- mk_TerminalNotificationReceivedCallback cb'
    connectSignalFunPtr obj "notification-received" cb'' SignalConnectBefore

afterTerminalNotificationReceived :: (IsTerminal a, MonadIO m) => a -> TerminalNotificationReceivedCallback -> m SignalHandlerId
afterTerminalNotificationReceived obj cb = liftIO $ do
    let cb' = wrap_TerminalNotificationReceivedCallback cb
    cb'' <- mk_TerminalNotificationReceivedCallback cb'
    connectSignalFunPtr obj "notification-received" cb'' SignalConnectAfter


-- signal Terminal::paste-clipboard
type TerminalPasteClipboardCallback =
    IO ()

noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback
noTerminalPasteClipboardCallback = Nothing

type C_TerminalPasteClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalPasteClipboardCallback :: C_TerminalPasteClipboardCallback -> IO (FunPtr C_TerminalPasteClipboardCallback)

genClosure_TerminalPasteClipboard :: TerminalPasteClipboardCallback -> IO Closure
genClosure_TerminalPasteClipboard cb = do
    let cb' = wrap_TerminalPasteClipboardCallback cb
    mk_TerminalPasteClipboardCallback cb' >>= newCClosure


wrap_TerminalPasteClipboardCallback ::
    TerminalPasteClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalPasteClipboardCallback _cb _ _ = do
    _cb 


onTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
onTerminalPasteClipboard obj cb = liftIO $ do
    let cb' = wrap_TerminalPasteClipboardCallback cb
    cb'' <- mk_TerminalPasteClipboardCallback cb'
    connectSignalFunPtr obj "paste-clipboard" cb'' SignalConnectBefore

afterTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId
afterTerminalPasteClipboard obj cb = liftIO $ do
    let cb' = wrap_TerminalPasteClipboardCallback cb
    cb'' <- mk_TerminalPasteClipboardCallback cb'
    connectSignalFunPtr obj "paste-clipboard" cb'' SignalConnectAfter


-- signal Terminal::raise-window
type TerminalRaiseWindowCallback =
    IO ()

noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback
noTerminalRaiseWindowCallback = Nothing

type C_TerminalRaiseWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalRaiseWindowCallback :: C_TerminalRaiseWindowCallback -> IO (FunPtr C_TerminalRaiseWindowCallback)

genClosure_TerminalRaiseWindow :: TerminalRaiseWindowCallback -> IO Closure
genClosure_TerminalRaiseWindow cb = do
    let cb' = wrap_TerminalRaiseWindowCallback cb
    mk_TerminalRaiseWindowCallback cb' >>= newCClosure


wrap_TerminalRaiseWindowCallback ::
    TerminalRaiseWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalRaiseWindowCallback _cb _ _ = do
    _cb 


onTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
onTerminalRaiseWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRaiseWindowCallback cb
    cb'' <- mk_TerminalRaiseWindowCallback cb'
    connectSignalFunPtr obj "raise-window" cb'' SignalConnectBefore

afterTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId
afterTerminalRaiseWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRaiseWindowCallback cb
    cb'' <- mk_TerminalRaiseWindowCallback cb'
    connectSignalFunPtr obj "raise-window" cb'' SignalConnectAfter


-- signal Terminal::refresh-window
type TerminalRefreshWindowCallback =
    IO ()

noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback
noTerminalRefreshWindowCallback = Nothing

type C_TerminalRefreshWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalRefreshWindowCallback :: C_TerminalRefreshWindowCallback -> IO (FunPtr C_TerminalRefreshWindowCallback)

genClosure_TerminalRefreshWindow :: TerminalRefreshWindowCallback -> IO Closure
genClosure_TerminalRefreshWindow cb = do
    let cb' = wrap_TerminalRefreshWindowCallback cb
    mk_TerminalRefreshWindowCallback cb' >>= newCClosure


wrap_TerminalRefreshWindowCallback ::
    TerminalRefreshWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalRefreshWindowCallback _cb _ _ = do
    _cb 


onTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
onTerminalRefreshWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRefreshWindowCallback cb
    cb'' <- mk_TerminalRefreshWindowCallback cb'
    connectSignalFunPtr obj "refresh-window" cb'' SignalConnectBefore

afterTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId
afterTerminalRefreshWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRefreshWindowCallback cb
    cb'' <- mk_TerminalRefreshWindowCallback cb'
    connectSignalFunPtr obj "refresh-window" cb'' SignalConnectAfter


-- signal Terminal::resize-window
type TerminalResizeWindowCallback =
    Word32 ->
    Word32 ->
    IO ()

noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback
noTerminalResizeWindowCallback = Nothing

type C_TerminalResizeWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalResizeWindowCallback :: C_TerminalResizeWindowCallback -> IO (FunPtr C_TerminalResizeWindowCallback)

genClosure_TerminalResizeWindow :: TerminalResizeWindowCallback -> IO Closure
genClosure_TerminalResizeWindow cb = do
    let cb' = wrap_TerminalResizeWindowCallback cb
    mk_TerminalResizeWindowCallback cb' >>= newCClosure


wrap_TerminalResizeWindowCallback ::
    TerminalResizeWindowCallback ->
    Ptr () ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_TerminalResizeWindowCallback _cb _ width height _ = do
    _cb  width height


onTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
onTerminalResizeWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalResizeWindowCallback cb
    cb'' <- mk_TerminalResizeWindowCallback cb'
    connectSignalFunPtr obj "resize-window" cb'' SignalConnectBefore

afterTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId
afterTerminalResizeWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalResizeWindowCallback cb
    cb'' <- mk_TerminalResizeWindowCallback cb'
    connectSignalFunPtr obj "resize-window" cb'' SignalConnectAfter


-- signal Terminal::restore-window
type TerminalRestoreWindowCallback =
    IO ()

noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback
noTerminalRestoreWindowCallback = Nothing

type C_TerminalRestoreWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalRestoreWindowCallback :: C_TerminalRestoreWindowCallback -> IO (FunPtr C_TerminalRestoreWindowCallback)

genClosure_TerminalRestoreWindow :: TerminalRestoreWindowCallback -> IO Closure
genClosure_TerminalRestoreWindow cb = do
    let cb' = wrap_TerminalRestoreWindowCallback cb
    mk_TerminalRestoreWindowCallback cb' >>= newCClosure


wrap_TerminalRestoreWindowCallback ::
    TerminalRestoreWindowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalRestoreWindowCallback _cb _ _ = do
    _cb 


onTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
onTerminalRestoreWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRestoreWindowCallback cb
    cb'' <- mk_TerminalRestoreWindowCallback cb'
    connectSignalFunPtr obj "restore-window" cb'' SignalConnectBefore

afterTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId
afterTerminalRestoreWindow obj cb = liftIO $ do
    let cb' = wrap_TerminalRestoreWindowCallback cb
    cb'' <- mk_TerminalRestoreWindowCallback cb'
    connectSignalFunPtr obj "restore-window" cb'' SignalConnectAfter


-- signal Terminal::selection-changed
type TerminalSelectionChangedCallback =
    IO ()

noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback
noTerminalSelectionChangedCallback = Nothing

type C_TerminalSelectionChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalSelectionChangedCallback :: C_TerminalSelectionChangedCallback -> IO (FunPtr C_TerminalSelectionChangedCallback)

genClosure_TerminalSelectionChanged :: TerminalSelectionChangedCallback -> IO Closure
genClosure_TerminalSelectionChanged cb = do
    let cb' = wrap_TerminalSelectionChangedCallback cb
    mk_TerminalSelectionChangedCallback cb' >>= newCClosure


wrap_TerminalSelectionChangedCallback ::
    TerminalSelectionChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalSelectionChangedCallback _cb _ _ = do
    _cb 


onTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
onTerminalSelectionChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalSelectionChangedCallback cb
    cb'' <- mk_TerminalSelectionChangedCallback cb'
    connectSignalFunPtr obj "selection-changed" cb'' SignalConnectBefore

afterTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId
afterTerminalSelectionChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalSelectionChangedCallback cb
    cb'' <- mk_TerminalSelectionChangedCallback cb'
    connectSignalFunPtr obj "selection-changed" cb'' SignalConnectAfter


-- signal Terminal::text-deleted
type TerminalTextDeletedCallback =
    IO ()

noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback
noTerminalTextDeletedCallback = Nothing

type C_TerminalTextDeletedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalTextDeletedCallback :: C_TerminalTextDeletedCallback -> IO (FunPtr C_TerminalTextDeletedCallback)

genClosure_TerminalTextDeleted :: TerminalTextDeletedCallback -> IO Closure
genClosure_TerminalTextDeleted cb = do
    let cb' = wrap_TerminalTextDeletedCallback cb
    mk_TerminalTextDeletedCallback cb' >>= newCClosure


wrap_TerminalTextDeletedCallback ::
    TerminalTextDeletedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalTextDeletedCallback _cb _ _ = do
    _cb 


onTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
onTerminalTextDeleted obj cb = liftIO $ do
    let cb' = wrap_TerminalTextDeletedCallback cb
    cb'' <- mk_TerminalTextDeletedCallback cb'
    connectSignalFunPtr obj "text-deleted" cb'' SignalConnectBefore

afterTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId
afterTerminalTextDeleted obj cb = liftIO $ do
    let cb' = wrap_TerminalTextDeletedCallback cb
    cb'' <- mk_TerminalTextDeletedCallback cb'
    connectSignalFunPtr obj "text-deleted" cb'' SignalConnectAfter


-- signal Terminal::text-inserted
type TerminalTextInsertedCallback =
    IO ()

noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback
noTerminalTextInsertedCallback = Nothing

type C_TerminalTextInsertedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalTextInsertedCallback :: C_TerminalTextInsertedCallback -> IO (FunPtr C_TerminalTextInsertedCallback)

genClosure_TerminalTextInserted :: TerminalTextInsertedCallback -> IO Closure
genClosure_TerminalTextInserted cb = do
    let cb' = wrap_TerminalTextInsertedCallback cb
    mk_TerminalTextInsertedCallback cb' >>= newCClosure


wrap_TerminalTextInsertedCallback ::
    TerminalTextInsertedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalTextInsertedCallback _cb _ _ = do
    _cb 


onTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
onTerminalTextInserted obj cb = liftIO $ do
    let cb' = wrap_TerminalTextInsertedCallback cb
    cb'' <- mk_TerminalTextInsertedCallback cb'
    connectSignalFunPtr obj "text-inserted" cb'' SignalConnectBefore

afterTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId
afterTerminalTextInserted obj cb = liftIO $ do
    let cb' = wrap_TerminalTextInsertedCallback cb
    cb'' <- mk_TerminalTextInsertedCallback cb'
    connectSignalFunPtr obj "text-inserted" cb'' SignalConnectAfter


-- signal Terminal::text-modified
type TerminalTextModifiedCallback =
    IO ()

noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback
noTerminalTextModifiedCallback = Nothing

type C_TerminalTextModifiedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalTextModifiedCallback :: C_TerminalTextModifiedCallback -> IO (FunPtr C_TerminalTextModifiedCallback)

genClosure_TerminalTextModified :: TerminalTextModifiedCallback -> IO Closure
genClosure_TerminalTextModified cb = do
    let cb' = wrap_TerminalTextModifiedCallback cb
    mk_TerminalTextModifiedCallback cb' >>= newCClosure


wrap_TerminalTextModifiedCallback ::
    TerminalTextModifiedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalTextModifiedCallback _cb _ _ = do
    _cb 


onTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
onTerminalTextModified obj cb = liftIO $ do
    let cb' = wrap_TerminalTextModifiedCallback cb
    cb'' <- mk_TerminalTextModifiedCallback cb'
    connectSignalFunPtr obj "text-modified" cb'' SignalConnectBefore

afterTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId
afterTerminalTextModified obj cb = liftIO $ do
    let cb' = wrap_TerminalTextModifiedCallback cb
    cb'' <- mk_TerminalTextModifiedCallback cb'
    connectSignalFunPtr obj "text-modified" cb'' SignalConnectAfter


-- signal Terminal::text-scrolled
type TerminalTextScrolledCallback =
    Int32 ->
    IO ()

noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback
noTerminalTextScrolledCallback = Nothing

type C_TerminalTextScrolledCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalTextScrolledCallback :: C_TerminalTextScrolledCallback -> IO (FunPtr C_TerminalTextScrolledCallback)

genClosure_TerminalTextScrolled :: TerminalTextScrolledCallback -> IO Closure
genClosure_TerminalTextScrolled cb = do
    let cb' = wrap_TerminalTextScrolledCallback cb
    mk_TerminalTextScrolledCallback cb' >>= newCClosure


wrap_TerminalTextScrolledCallback ::
    TerminalTextScrolledCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_TerminalTextScrolledCallback _cb _ delta _ = do
    _cb  delta


onTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
onTerminalTextScrolled obj cb = liftIO $ do
    let cb' = wrap_TerminalTextScrolledCallback cb
    cb'' <- mk_TerminalTextScrolledCallback cb'
    connectSignalFunPtr obj "text-scrolled" cb'' SignalConnectBefore

afterTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId
afterTerminalTextScrolled obj cb = liftIO $ do
    let cb' = wrap_TerminalTextScrolledCallback cb
    cb'' <- mk_TerminalTextScrolledCallback cb'
    connectSignalFunPtr obj "text-scrolled" cb'' SignalConnectAfter


-- signal Terminal::window-title-changed
type TerminalWindowTitleChangedCallback =
    IO ()

noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback
noTerminalWindowTitleChangedCallback = Nothing

type C_TerminalWindowTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_TerminalWindowTitleChangedCallback :: C_TerminalWindowTitleChangedCallback -> IO (FunPtr C_TerminalWindowTitleChangedCallback)

genClosure_TerminalWindowTitleChanged :: TerminalWindowTitleChangedCallback -> IO Closure
genClosure_TerminalWindowTitleChanged cb = do
    let cb' = wrap_TerminalWindowTitleChangedCallback cb
    mk_TerminalWindowTitleChangedCallback cb' >>= newCClosure


wrap_TerminalWindowTitleChangedCallback ::
    TerminalWindowTitleChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_TerminalWindowTitleChangedCallback _cb _ _ = do
    _cb 


onTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
onTerminalWindowTitleChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalWindowTitleChangedCallback cb
    cb'' <- mk_TerminalWindowTitleChangedCallback cb'
    connectSignalFunPtr obj "window-title-changed" cb'' SignalConnectBefore

afterTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId
afterTerminalWindowTitleChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalWindowTitleChangedCallback cb
    cb'' <- mk_TerminalWindowTitleChangedCallback cb'
    connectSignalFunPtr obj "window-title-changed" cb'' SignalConnectAfter


-- VVV Prop "allow-bold"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowBold obj = liftIO $ getObjectPropertyBool obj "allow-bold"

setTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAllowBold obj val = liftIO $ setObjectPropertyBool obj "allow-bold" val

constructTerminalAllowBold :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAllowBold val = constructObjectPropertyBool "allow-bold" val

data TerminalAllowBoldPropertyInfo
instance AttrInfo TerminalAllowBoldPropertyInfo where
    type AttrAllowedOps TerminalAllowBoldPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalAllowBoldPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalAllowBoldPropertyInfo = IsTerminal
    type AttrGetType TerminalAllowBoldPropertyInfo = Bool
    type AttrLabel TerminalAllowBoldPropertyInfo = "allow-bold"
    type AttrOrigin TerminalAllowBoldPropertyInfo = Terminal
    attrGet _ = getTerminalAllowBold
    attrSet _ = setTerminalAllowBold
    attrConstruct _ = constructTerminalAllowBold
    attrClear _ = undefined

-- VVV Prop "audible-bell"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAudibleBell obj = liftIO $ getObjectPropertyBool obj "audible-bell"

setTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAudibleBell obj val = liftIO $ setObjectPropertyBool obj "audible-bell" val

constructTerminalAudibleBell :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAudibleBell val = constructObjectPropertyBool "audible-bell" val

data TerminalAudibleBellPropertyInfo
instance AttrInfo TerminalAudibleBellPropertyInfo where
    type AttrAllowedOps TerminalAudibleBellPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalAudibleBellPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalAudibleBellPropertyInfo = IsTerminal
    type AttrGetType TerminalAudibleBellPropertyInfo = Bool
    type AttrLabel TerminalAudibleBellPropertyInfo = "audible-bell"
    type AttrOrigin TerminalAudibleBellPropertyInfo = Terminal
    attrGet _ = getTerminalAudibleBell
    attrSet _ = setTerminalAudibleBell
    attrConstruct _ = constructTerminalAudibleBell
    attrClear _ = undefined

-- VVV Prop "backspace-binding"
   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalBackspaceBinding obj = liftIO $ getObjectPropertyEnum obj "backspace-binding"

setTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalBackspaceBinding obj val = liftIO $ setObjectPropertyEnum obj "backspace-binding" val

constructTerminalBackspaceBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalBackspaceBinding val = constructObjectPropertyEnum "backspace-binding" val

data TerminalBackspaceBindingPropertyInfo
instance AttrInfo TerminalBackspaceBindingPropertyInfo where
    type AttrAllowedOps TerminalBackspaceBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalBackspaceBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrBaseTypeConstraint TerminalBackspaceBindingPropertyInfo = IsTerminal
    type AttrGetType TerminalBackspaceBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalBackspaceBindingPropertyInfo = "backspace-binding"
    type AttrOrigin TerminalBackspaceBindingPropertyInfo = Terminal
    attrGet _ = getTerminalBackspaceBinding
    attrSet _ = setTerminalBackspaceBinding
    attrConstruct _ = constructTerminalBackspaceBinding
    attrClear _ = undefined

-- VVV Prop "cjk-ambiguous-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> m Int32
getTerminalCjkAmbiguousWidth obj = liftIO $ getObjectPropertyInt32 obj "cjk-ambiguous-width"

setTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> Int32 -> m ()
setTerminalCjkAmbiguousWidth obj val = liftIO $ setObjectPropertyInt32 obj "cjk-ambiguous-width" val

constructTerminalCjkAmbiguousWidth :: (IsTerminal o) => Int32 -> IO (GValueConstruct o)
constructTerminalCjkAmbiguousWidth val = constructObjectPropertyInt32 "cjk-ambiguous-width" val

data TerminalCjkAmbiguousWidthPropertyInfo
instance AttrInfo TerminalCjkAmbiguousWidthPropertyInfo where
    type AttrAllowedOps TerminalCjkAmbiguousWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint TerminalCjkAmbiguousWidthPropertyInfo = IsTerminal
    type AttrGetType TerminalCjkAmbiguousWidthPropertyInfo = Int32
    type AttrLabel TerminalCjkAmbiguousWidthPropertyInfo = "cjk-ambiguous-width"
    type AttrOrigin TerminalCjkAmbiguousWidthPropertyInfo = Terminal
    attrGet _ = getTerminalCjkAmbiguousWidth
    attrSet _ = setTerminalCjkAmbiguousWidth
    attrConstruct _ = constructTerminalCjkAmbiguousWidth
    attrClear _ = undefined

-- VVV Prop "current-directory-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getTerminalCurrentDirectoryUri :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalCurrentDirectoryUri obj = liftIO $ checkUnexpectedNothing "getTerminalCurrentDirectoryUri" $ getObjectPropertyString obj "current-directory-uri"

data TerminalCurrentDirectoryUriPropertyInfo
instance AttrInfo TerminalCurrentDirectoryUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentDirectoryUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalCurrentDirectoryUriPropertyInfo = IsTerminal
    type AttrGetType TerminalCurrentDirectoryUriPropertyInfo = T.Text
    type AttrLabel TerminalCurrentDirectoryUriPropertyInfo = "current-directory-uri"
    type AttrOrigin TerminalCurrentDirectoryUriPropertyInfo = Terminal
    attrGet _ = getTerminalCurrentDirectoryUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "current-file-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getTerminalCurrentFileUri :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalCurrentFileUri obj = liftIO $ checkUnexpectedNothing "getTerminalCurrentFileUri" $ getObjectPropertyString obj "current-file-uri"

data TerminalCurrentFileUriPropertyInfo
instance AttrInfo TerminalCurrentFileUriPropertyInfo where
    type AttrAllowedOps TerminalCurrentFileUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalCurrentFileUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalCurrentFileUriPropertyInfo = IsTerminal
    type AttrGetType TerminalCurrentFileUriPropertyInfo = T.Text
    type AttrLabel TerminalCurrentFileUriPropertyInfo = "current-file-uri"
    type AttrOrigin TerminalCurrentFileUriPropertyInfo = Terminal
    attrGet _ = getTerminalCurrentFileUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "cursor-blink-mode"
   -- Type: TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorBlinkMode
getTerminalCursorBlinkMode obj = liftIO $ getObjectPropertyEnum obj "cursor-blink-mode"

setTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorBlinkMode -> m ()
setTerminalCursorBlinkMode obj val = liftIO $ setObjectPropertyEnum obj "cursor-blink-mode" val

constructTerminalCursorBlinkMode :: (IsTerminal o) => Vte.Enums.CursorBlinkMode -> IO (GValueConstruct o)
constructTerminalCursorBlinkMode val = constructObjectPropertyEnum "cursor-blink-mode" val

data TerminalCursorBlinkModePropertyInfo
instance AttrInfo TerminalCursorBlinkModePropertyInfo where
    type AttrAllowedOps TerminalCursorBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalCursorBlinkModePropertyInfo = (~) Vte.Enums.CursorBlinkMode
    type AttrBaseTypeConstraint TerminalCursorBlinkModePropertyInfo = IsTerminal
    type AttrGetType TerminalCursorBlinkModePropertyInfo = Vte.Enums.CursorBlinkMode
    type AttrLabel TerminalCursorBlinkModePropertyInfo = "cursor-blink-mode"
    type AttrOrigin TerminalCursorBlinkModePropertyInfo = Terminal
    attrGet _ = getTerminalCursorBlinkMode
    attrSet _ = setTerminalCursorBlinkMode
    attrConstruct _ = constructTerminalCursorBlinkMode
    attrClear _ = undefined

-- VVV Prop "cursor-shape"
   -- Type: TInterface (Name {namespace = "Vte", name = "CursorShape"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorShape
getTerminalCursorShape obj = liftIO $ getObjectPropertyEnum obj "cursor-shape"

setTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorShape -> m ()
setTerminalCursorShape obj val = liftIO $ setObjectPropertyEnum obj "cursor-shape" val

constructTerminalCursorShape :: (IsTerminal o) => Vte.Enums.CursorShape -> IO (GValueConstruct o)
constructTerminalCursorShape val = constructObjectPropertyEnum "cursor-shape" val

data TerminalCursorShapePropertyInfo
instance AttrInfo TerminalCursorShapePropertyInfo where
    type AttrAllowedOps TerminalCursorShapePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalCursorShapePropertyInfo = (~) Vte.Enums.CursorShape
    type AttrBaseTypeConstraint TerminalCursorShapePropertyInfo = IsTerminal
    type AttrGetType TerminalCursorShapePropertyInfo = Vte.Enums.CursorShape
    type AttrLabel TerminalCursorShapePropertyInfo = "cursor-shape"
    type AttrOrigin TerminalCursorShapePropertyInfo = Terminal
    attrGet _ = getTerminalCursorShape
    attrSet _ = setTerminalCursorShape
    attrConstruct _ = constructTerminalCursorShape
    attrClear _ = undefined

-- VVV Prop "delete-binding"
   -- Type: TInterface (Name {namespace = "Vte", name = "EraseBinding"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalDeleteBinding obj = liftIO $ getObjectPropertyEnum obj "delete-binding"

setTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalDeleteBinding obj val = liftIO $ setObjectPropertyEnum obj "delete-binding" val

constructTerminalDeleteBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalDeleteBinding val = constructObjectPropertyEnum "delete-binding" val

data TerminalDeleteBindingPropertyInfo
instance AttrInfo TerminalDeleteBindingPropertyInfo where
    type AttrAllowedOps TerminalDeleteBindingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalDeleteBindingPropertyInfo = (~) Vte.Enums.EraseBinding
    type AttrBaseTypeConstraint TerminalDeleteBindingPropertyInfo = IsTerminal
    type AttrGetType TerminalDeleteBindingPropertyInfo = Vte.Enums.EraseBinding
    type AttrLabel TerminalDeleteBindingPropertyInfo = "delete-binding"
    type AttrOrigin TerminalDeleteBindingPropertyInfo = Terminal
    attrGet _ = getTerminalDeleteBinding
    attrSet _ = setTerminalDeleteBinding
    attrConstruct _ = constructTerminalDeleteBinding
    attrClear _ = undefined

-- VVV Prop "encoding"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

getTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalEncoding obj = liftIO $ checkUnexpectedNothing "getTerminalEncoding" $ getObjectPropertyString obj "encoding"

setTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> T.Text -> m ()
setTerminalEncoding obj val = liftIO $ setObjectPropertyString obj "encoding" (Just val)

constructTerminalEncoding :: (IsTerminal o) => T.Text -> IO (GValueConstruct o)
constructTerminalEncoding val = constructObjectPropertyString "encoding" (Just val)

clearTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalEncoding obj = liftIO $ setObjectPropertyString obj "encoding" (Nothing :: Maybe T.Text)

data TerminalEncodingPropertyInfo
instance AttrInfo TerminalEncodingPropertyInfo where
    type AttrAllowedOps TerminalEncodingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalEncodingPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint TerminalEncodingPropertyInfo = IsTerminal
    type AttrGetType TerminalEncodingPropertyInfo = T.Text
    type AttrLabel TerminalEncodingPropertyInfo = "encoding"
    type AttrOrigin TerminalEncodingPropertyInfo = Terminal
    attrGet _ = getTerminalEncoding
    attrSet _ = setTerminalEncoding
    attrConstruct _ = constructTerminalEncoding
    attrClear _ = clearTerminalEncoding

-- VVV Prop "font-desc"
   -- Type: TInterface (Name {namespace = "Pango", name = "FontDescription"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m (Maybe Pango.FontDescription.FontDescription)
getTerminalFontDesc obj = liftIO $ getObjectPropertyBoxed obj "font-desc" Pango.FontDescription.FontDescription

setTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> Pango.FontDescription.FontDescription -> m ()
setTerminalFontDesc obj val = liftIO $ setObjectPropertyBoxed obj "font-desc" (Just val)

constructTerminalFontDesc :: (IsTerminal o) => Pango.FontDescription.FontDescription -> IO (GValueConstruct o)
constructTerminalFontDesc val = constructObjectPropertyBoxed "font-desc" (Just val)

clearTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalFontDesc obj = liftIO $ setObjectPropertyBoxed obj "font-desc" (Nothing :: Maybe Pango.FontDescription.FontDescription)

data TerminalFontDescPropertyInfo
instance AttrInfo TerminalFontDescPropertyInfo where
    type AttrAllowedOps TerminalFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrBaseTypeConstraint TerminalFontDescPropertyInfo = IsTerminal
    type AttrGetType TerminalFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription)
    type AttrLabel TerminalFontDescPropertyInfo = "font-desc"
    type AttrOrigin TerminalFontDescPropertyInfo = Terminal
    attrGet _ = getTerminalFontDesc
    attrSet _ = setTerminalFontDesc
    attrConstruct _ = constructTerminalFontDesc
    attrClear _ = clearTerminalFontDesc

-- VVV Prop "font-scale"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalFontScale obj = liftIO $ getObjectPropertyDouble obj "font-scale"

setTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalFontScale obj val = liftIO $ setObjectPropertyDouble obj "font-scale" val

constructTerminalFontScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalFontScale val = constructObjectPropertyDouble "font-scale" val

data TerminalFontScalePropertyInfo
instance AttrInfo TerminalFontScalePropertyInfo where
    type AttrAllowedOps TerminalFontScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalFontScalePropertyInfo = (~) Double
    type AttrBaseTypeConstraint TerminalFontScalePropertyInfo = IsTerminal
    type AttrGetType TerminalFontScalePropertyInfo = Double
    type AttrLabel TerminalFontScalePropertyInfo = "font-scale"
    type AttrOrigin TerminalFontScalePropertyInfo = Terminal
    attrGet _ = getTerminalFontScale
    attrSet _ = setTerminalFontScale
    attrConstruct _ = constructTerminalFontScale
    attrClear _ = undefined

-- VVV Prop "icon-title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getTerminalIconTitle :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalIconTitle obj = liftIO $ checkUnexpectedNothing "getTerminalIconTitle" $ getObjectPropertyString obj "icon-title"

data TerminalIconTitlePropertyInfo
instance AttrInfo TerminalIconTitlePropertyInfo where
    type AttrAllowedOps TerminalIconTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalIconTitlePropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalIconTitlePropertyInfo = IsTerminal
    type AttrGetType TerminalIconTitlePropertyInfo = T.Text
    type AttrLabel TerminalIconTitlePropertyInfo = "icon-title"
    type AttrOrigin TerminalIconTitlePropertyInfo = Terminal
    attrGet _ = getTerminalIconTitle
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "input-enabled"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalInputEnabled obj = liftIO $ getObjectPropertyBool obj "input-enabled"

setTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalInputEnabled obj val = liftIO $ setObjectPropertyBool obj "input-enabled" val

constructTerminalInputEnabled :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalInputEnabled val = constructObjectPropertyBool "input-enabled" val

data TerminalInputEnabledPropertyInfo
instance AttrInfo TerminalInputEnabledPropertyInfo where
    type AttrAllowedOps TerminalInputEnabledPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalInputEnabledPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalInputEnabledPropertyInfo = IsTerminal
    type AttrGetType TerminalInputEnabledPropertyInfo = Bool
    type AttrLabel TerminalInputEnabledPropertyInfo = "input-enabled"
    type AttrOrigin TerminalInputEnabledPropertyInfo = Terminal
    attrGet _ = getTerminalInputEnabled
    attrSet _ = setTerminalInputEnabled
    attrConstruct _ = constructTerminalInputEnabled
    attrClear _ = undefined

-- VVV Prop "pointer-autohide"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalPointerAutohide obj = liftIO $ getObjectPropertyBool obj "pointer-autohide"

setTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalPointerAutohide obj val = liftIO $ setObjectPropertyBool obj "pointer-autohide" val

constructTerminalPointerAutohide :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalPointerAutohide val = constructObjectPropertyBool "pointer-autohide" val

data TerminalPointerAutohidePropertyInfo
instance AttrInfo TerminalPointerAutohidePropertyInfo where
    type AttrAllowedOps TerminalPointerAutohidePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalPointerAutohidePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalPointerAutohidePropertyInfo = IsTerminal
    type AttrGetType TerminalPointerAutohidePropertyInfo = Bool
    type AttrLabel TerminalPointerAutohidePropertyInfo = "pointer-autohide"
    type AttrOrigin TerminalPointerAutohidePropertyInfo = Terminal
    attrGet _ = getTerminalPointerAutohide
    attrSet _ = setTerminalPointerAutohide
    attrConstruct _ = constructTerminalPointerAutohide
    attrClear _ = undefined

-- VVV Prop "pty"
   -- Type: TInterface (Name {namespace = "Vte", name = "Pty"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

getTerminalPty :: (MonadIO m, IsTerminal o) => o -> m Vte.Pty.Pty
getTerminalPty obj = liftIO $ checkUnexpectedNothing "getTerminalPty" $ getObjectPropertyObject obj "pty" Vte.Pty.Pty

setTerminalPty :: (MonadIO m, IsTerminal o, Vte.Pty.IsPty a) => o -> a -> m ()
setTerminalPty obj val = liftIO $ setObjectPropertyObject obj "pty" (Just val)

constructTerminalPty :: (IsTerminal o, Vte.Pty.IsPty a) => a -> IO (GValueConstruct o)
constructTerminalPty val = constructObjectPropertyObject "pty" (Just val)

clearTerminalPty :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalPty obj = liftIO $ setObjectPropertyObject obj "pty" (Nothing :: Maybe Vte.Pty.Pty)

data TerminalPtyPropertyInfo
instance AttrInfo TerminalPtyPropertyInfo where
    type AttrAllowedOps TerminalPtyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalPtyPropertyInfo = Vte.Pty.IsPty
    type AttrBaseTypeConstraint TerminalPtyPropertyInfo = IsTerminal
    type AttrGetType TerminalPtyPropertyInfo = Vte.Pty.Pty
    type AttrLabel TerminalPtyPropertyInfo = "pty"
    type AttrOrigin TerminalPtyPropertyInfo = Terminal
    attrGet _ = getTerminalPty
    attrSet _ = setTerminalPty
    attrConstruct _ = constructTerminalPty
    attrClear _ = clearTerminalPty

-- VVV Prop "rewrap-on-resize"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalRewrapOnResize obj = liftIO $ getObjectPropertyBool obj "rewrap-on-resize"

setTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalRewrapOnResize obj val = liftIO $ setObjectPropertyBool obj "rewrap-on-resize" val

constructTerminalRewrapOnResize :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalRewrapOnResize val = constructObjectPropertyBool "rewrap-on-resize" val

data TerminalRewrapOnResizePropertyInfo
instance AttrInfo TerminalRewrapOnResizePropertyInfo where
    type AttrAllowedOps TerminalRewrapOnResizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalRewrapOnResizePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalRewrapOnResizePropertyInfo = IsTerminal
    type AttrGetType TerminalRewrapOnResizePropertyInfo = Bool
    type AttrLabel TerminalRewrapOnResizePropertyInfo = "rewrap-on-resize"
    type AttrOrigin TerminalRewrapOnResizePropertyInfo = Terminal
    attrGet _ = getTerminalRewrapOnResize
    attrSet _ = setTerminalRewrapOnResize
    attrConstruct _ = constructTerminalRewrapOnResize
    attrClear _ = undefined

-- VVV Prop "scroll-on-keystroke"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnKeystroke obj = liftIO $ getObjectPropertyBool obj "scroll-on-keystroke"

setTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnKeystroke obj val = liftIO $ setObjectPropertyBool obj "scroll-on-keystroke" val

constructTerminalScrollOnKeystroke :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnKeystroke val = constructObjectPropertyBool "scroll-on-keystroke" val

data TerminalScrollOnKeystrokePropertyInfo
instance AttrInfo TerminalScrollOnKeystrokePropertyInfo where
    type AttrAllowedOps TerminalScrollOnKeystrokePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalScrollOnKeystrokePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalScrollOnKeystrokePropertyInfo = IsTerminal
    type AttrGetType TerminalScrollOnKeystrokePropertyInfo = Bool
    type AttrLabel TerminalScrollOnKeystrokePropertyInfo = "scroll-on-keystroke"
    type AttrOrigin TerminalScrollOnKeystrokePropertyInfo = Terminal
    attrGet _ = getTerminalScrollOnKeystroke
    attrSet _ = setTerminalScrollOnKeystroke
    attrConstruct _ = constructTerminalScrollOnKeystroke
    attrClear _ = undefined

-- VVV Prop "scroll-on-output"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnOutput obj = liftIO $ getObjectPropertyBool obj "scroll-on-output"

setTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnOutput obj val = liftIO $ setObjectPropertyBool obj "scroll-on-output" val

constructTerminalScrollOnOutput :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnOutput val = constructObjectPropertyBool "scroll-on-output" val

data TerminalScrollOnOutputPropertyInfo
instance AttrInfo TerminalScrollOnOutputPropertyInfo where
    type AttrAllowedOps TerminalScrollOnOutputPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalScrollOnOutputPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalScrollOnOutputPropertyInfo = IsTerminal
    type AttrGetType TerminalScrollOnOutputPropertyInfo = Bool
    type AttrLabel TerminalScrollOnOutputPropertyInfo = "scroll-on-output"
    type AttrOrigin TerminalScrollOnOutputPropertyInfo = Terminal
    attrGet _ = getTerminalScrollOnOutput
    attrSet _ = setTerminalScrollOnOutput
    attrConstruct _ = constructTerminalScrollOnOutput
    attrClear _ = undefined

-- VVV Prop "scroll-speed"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollSpeed obj = liftIO $ getObjectPropertyUInt32 obj "scroll-speed"

setTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollSpeed obj val = liftIO $ setObjectPropertyUInt32 obj "scroll-speed" val

constructTerminalScrollSpeed :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollSpeed val = constructObjectPropertyUInt32 "scroll-speed" val

data TerminalScrollSpeedPropertyInfo
instance AttrInfo TerminalScrollSpeedPropertyInfo where
    type AttrAllowedOps TerminalScrollSpeedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalScrollSpeedPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint TerminalScrollSpeedPropertyInfo = IsTerminal
    type AttrGetType TerminalScrollSpeedPropertyInfo = Word32
    type AttrLabel TerminalScrollSpeedPropertyInfo = "scroll-speed"
    type AttrOrigin TerminalScrollSpeedPropertyInfo = Terminal
    attrGet _ = getTerminalScrollSpeed
    attrSet _ = setTerminalScrollSpeed
    attrConstruct _ = constructTerminalScrollSpeed
    attrClear _ = undefined

-- VVV Prop "scrollback-lines"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollbackLines obj = liftIO $ getObjectPropertyUInt32 obj "scrollback-lines"

setTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollbackLines obj val = liftIO $ setObjectPropertyUInt32 obj "scrollback-lines" val

constructTerminalScrollbackLines :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollbackLines val = constructObjectPropertyUInt32 "scrollback-lines" val

data TerminalScrollbackLinesPropertyInfo
instance AttrInfo TerminalScrollbackLinesPropertyInfo where
    type AttrAllowedOps TerminalScrollbackLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalScrollbackLinesPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint TerminalScrollbackLinesPropertyInfo = IsTerminal
    type AttrGetType TerminalScrollbackLinesPropertyInfo = Word32
    type AttrLabel TerminalScrollbackLinesPropertyInfo = "scrollback-lines"
    type AttrOrigin TerminalScrollbackLinesPropertyInfo = Terminal
    attrGet _ = getTerminalScrollbackLines
    attrSet _ = setTerminalScrollbackLines
    attrConstruct _ = constructTerminalScrollbackLines
    attrClear _ = undefined

-- VVV Prop "window-title"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getTerminalWindowTitle :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalWindowTitle obj = liftIO $ checkUnexpectedNothing "getTerminalWindowTitle" $ getObjectPropertyString obj "window-title"

data TerminalWindowTitlePropertyInfo
instance AttrInfo TerminalWindowTitlePropertyInfo where
    type AttrAllowedOps TerminalWindowTitlePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalWindowTitlePropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalWindowTitlePropertyInfo = IsTerminal
    type AttrGetType TerminalWindowTitlePropertyInfo = T.Text
    type AttrLabel TerminalWindowTitlePropertyInfo = "window-title"
    type AttrOrigin TerminalWindowTitlePropertyInfo = Terminal
    attrGet _ = getTerminalWindowTitle
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "word-char-exceptions"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Just False)

getTerminalWordCharExceptions :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalWordCharExceptions obj = liftIO $ checkUnexpectedNothing "getTerminalWordCharExceptions" $ getObjectPropertyString obj "word-char-exceptions"

data TerminalWordCharExceptionsPropertyInfo
instance AttrInfo TerminalWordCharExceptionsPropertyInfo where
    type AttrAllowedOps TerminalWordCharExceptionsPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint TerminalWordCharExceptionsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalWordCharExceptionsPropertyInfo = IsTerminal
    type AttrGetType TerminalWordCharExceptionsPropertyInfo = T.Text
    type AttrLabel TerminalWordCharExceptionsPropertyInfo = "word-char-exceptions"
    type AttrOrigin TerminalWordCharExceptionsPropertyInfo = Terminal
    attrGet _ = getTerminalWordCharExceptions
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList Terminal
type instance O.AttributeList Terminal = TerminalAttributeList
type TerminalAttributeList = ('[ '("allowBold", TerminalAllowBoldPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("audibleBell", TerminalAudibleBellPropertyInfo), '("backspaceBinding", TerminalBackspaceBindingPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("cjkAmbiguousWidth", TerminalCjkAmbiguousWidthPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("currentDirectoryUri", TerminalCurrentDirectoryUriPropertyInfo), '("currentFileUri", TerminalCurrentFileUriPropertyInfo), '("cursorBlinkMode", TerminalCursorBlinkModePropertyInfo), '("cursorShape", TerminalCursorShapePropertyInfo), '("deleteBinding", TerminalDeleteBindingPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("encoding", TerminalEncodingPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("fontDesc", TerminalFontDescPropertyInfo), '("fontScale", TerminalFontScalePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("iconTitle", TerminalIconTitlePropertyInfo), '("inputEnabled", TerminalInputEnabledPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pointerAutohide", TerminalPointerAutohidePropertyInfo), '("pty", TerminalPtyPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rewrapOnResize", TerminalRewrapOnResizePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("scrollOnKeystroke", TerminalScrollOnKeystrokePropertyInfo), '("scrollOnOutput", TerminalScrollOnOutputPropertyInfo), '("scrollSpeed", TerminalScrollSpeedPropertyInfo), '("scrollbackLines", TerminalScrollbackLinesPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("windowTitle", TerminalWindowTitlePropertyInfo), '("wordCharExceptions", TerminalWordCharExceptionsPropertyInfo)] :: [(Symbol, *)])

terminalAllowBold :: AttrLabelProxy "allowBold"
terminalAllowBold = AttrLabelProxy

terminalAudibleBell :: AttrLabelProxy "audibleBell"
terminalAudibleBell = AttrLabelProxy

terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"
terminalBackspaceBinding = AttrLabelProxy

terminalCjkAmbiguousWidth :: AttrLabelProxy "cjkAmbiguousWidth"
terminalCjkAmbiguousWidth = AttrLabelProxy

terminalCurrentDirectoryUri :: AttrLabelProxy "currentDirectoryUri"
terminalCurrentDirectoryUri = AttrLabelProxy

terminalCurrentFileUri :: AttrLabelProxy "currentFileUri"
terminalCurrentFileUri = AttrLabelProxy

terminalCursorBlinkMode :: AttrLabelProxy "cursorBlinkMode"
terminalCursorBlinkMode = AttrLabelProxy

terminalCursorShape :: AttrLabelProxy "cursorShape"
terminalCursorShape = AttrLabelProxy

terminalDeleteBinding :: AttrLabelProxy "deleteBinding"
terminalDeleteBinding = AttrLabelProxy

terminalEncoding :: AttrLabelProxy "encoding"
terminalEncoding = AttrLabelProxy

terminalFontDesc :: AttrLabelProxy "fontDesc"
terminalFontDesc = AttrLabelProxy

terminalFontScale :: AttrLabelProxy "fontScale"
terminalFontScale = AttrLabelProxy

terminalIconTitle :: AttrLabelProxy "iconTitle"
terminalIconTitle = AttrLabelProxy

terminalInputEnabled :: AttrLabelProxy "inputEnabled"
terminalInputEnabled = AttrLabelProxy

terminalPointerAutohide :: AttrLabelProxy "pointerAutohide"
terminalPointerAutohide = AttrLabelProxy

terminalPty :: AttrLabelProxy "pty"
terminalPty = AttrLabelProxy

terminalRewrapOnResize :: AttrLabelProxy "rewrapOnResize"
terminalRewrapOnResize = AttrLabelProxy

terminalScrollOnKeystroke :: AttrLabelProxy "scrollOnKeystroke"
terminalScrollOnKeystroke = AttrLabelProxy

terminalScrollOnOutput :: AttrLabelProxy "scrollOnOutput"
terminalScrollOnOutput = AttrLabelProxy

terminalScrollSpeed :: AttrLabelProxy "scrollSpeed"
terminalScrollSpeed = AttrLabelProxy

terminalScrollbackLines :: AttrLabelProxy "scrollbackLines"
terminalScrollbackLines = AttrLabelProxy

terminalWindowTitle :: AttrLabelProxy "windowTitle"
terminalWindowTitle = AttrLabelProxy

terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"
terminalWordCharExceptions = AttrLabelProxy

data TerminalBellSignalInfo
instance SignalInfo TerminalBellSignalInfo where
    type HaskellCallbackType TerminalBellSignalInfo = TerminalBellCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalBellCallback cb
        cb'' <- mk_TerminalBellCallback cb'
        connectSignalFunPtr obj "bell" cb'' connectMode

data TerminalCharSizeChangedSignalInfo
instance SignalInfo TerminalCharSizeChangedSignalInfo where
    type HaskellCallbackType TerminalCharSizeChangedSignalInfo = TerminalCharSizeChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCharSizeChangedCallback cb
        cb'' <- mk_TerminalCharSizeChangedCallback cb'
        connectSignalFunPtr obj "char-size-changed" cb'' connectMode

data TerminalChildExitedSignalInfo
instance SignalInfo TerminalChildExitedSignalInfo where
    type HaskellCallbackType TerminalChildExitedSignalInfo = TerminalChildExitedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalChildExitedCallback cb
        cb'' <- mk_TerminalChildExitedCallback cb'
        connectSignalFunPtr obj "child-exited" cb'' connectMode

data TerminalCommitSignalInfo
instance SignalInfo TerminalCommitSignalInfo where
    type HaskellCallbackType TerminalCommitSignalInfo = TerminalCommitCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCommitCallback cb
        cb'' <- mk_TerminalCommitCallback cb'
        connectSignalFunPtr obj "commit" cb'' connectMode

data TerminalContentsChangedSignalInfo
instance SignalInfo TerminalContentsChangedSignalInfo where
    type HaskellCallbackType TerminalContentsChangedSignalInfo = TerminalContentsChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalContentsChangedCallback cb
        cb'' <- mk_TerminalContentsChangedCallback cb'
        connectSignalFunPtr obj "contents-changed" cb'' connectMode

data TerminalCopyClipboardSignalInfo
instance SignalInfo TerminalCopyClipboardSignalInfo where
    type HaskellCallbackType TerminalCopyClipboardSignalInfo = TerminalCopyClipboardCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCopyClipboardCallback cb
        cb'' <- mk_TerminalCopyClipboardCallback cb'
        connectSignalFunPtr obj "copy-clipboard" cb'' connectMode

data TerminalCurrentDirectoryUriChangedSignalInfo
instance SignalInfo TerminalCurrentDirectoryUriChangedSignalInfo where
    type HaskellCallbackType TerminalCurrentDirectoryUriChangedSignalInfo = TerminalCurrentDirectoryUriChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
        cb'' <- mk_TerminalCurrentDirectoryUriChangedCallback cb'
        connectSignalFunPtr obj "current-directory-uri-changed" cb'' connectMode

data TerminalCurrentFileUriChangedSignalInfo
instance SignalInfo TerminalCurrentFileUriChangedSignalInfo where
    type HaskellCallbackType TerminalCurrentFileUriChangedSignalInfo = TerminalCurrentFileUriChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
        cb'' <- mk_TerminalCurrentFileUriChangedCallback cb'
        connectSignalFunPtr obj "current-file-uri-changed" cb'' connectMode

data TerminalCursorMovedSignalInfo
instance SignalInfo TerminalCursorMovedSignalInfo where
    type HaskellCallbackType TerminalCursorMovedSignalInfo = TerminalCursorMovedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalCursorMovedCallback cb
        cb'' <- mk_TerminalCursorMovedCallback cb'
        connectSignalFunPtr obj "cursor-moved" cb'' connectMode

data TerminalDecreaseFontSizeSignalInfo
instance SignalInfo TerminalDecreaseFontSizeSignalInfo where
    type HaskellCallbackType TerminalDecreaseFontSizeSignalInfo = TerminalDecreaseFontSizeCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalDecreaseFontSizeCallback cb
        cb'' <- mk_TerminalDecreaseFontSizeCallback cb'
        connectSignalFunPtr obj "decrease-font-size" cb'' connectMode

data TerminalDeiconifyWindowSignalInfo
instance SignalInfo TerminalDeiconifyWindowSignalInfo where
    type HaskellCallbackType TerminalDeiconifyWindowSignalInfo = TerminalDeiconifyWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalDeiconifyWindowCallback cb
        cb'' <- mk_TerminalDeiconifyWindowCallback cb'
        connectSignalFunPtr obj "deiconify-window" cb'' connectMode

data TerminalEncodingChangedSignalInfo
instance SignalInfo TerminalEncodingChangedSignalInfo where
    type HaskellCallbackType TerminalEncodingChangedSignalInfo = TerminalEncodingChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalEncodingChangedCallback cb
        cb'' <- mk_TerminalEncodingChangedCallback cb'
        connectSignalFunPtr obj "encoding-changed" cb'' connectMode

data TerminalEofSignalInfo
instance SignalInfo TerminalEofSignalInfo where
    type HaskellCallbackType TerminalEofSignalInfo = TerminalEofCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalEofCallback cb
        cb'' <- mk_TerminalEofCallback cb'
        connectSignalFunPtr obj "eof" cb'' connectMode

data TerminalIconTitleChangedSignalInfo
instance SignalInfo TerminalIconTitleChangedSignalInfo where
    type HaskellCallbackType TerminalIconTitleChangedSignalInfo = TerminalIconTitleChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalIconTitleChangedCallback cb
        cb'' <- mk_TerminalIconTitleChangedCallback cb'
        connectSignalFunPtr obj "icon-title-changed" cb'' connectMode

data TerminalIconifyWindowSignalInfo
instance SignalInfo TerminalIconifyWindowSignalInfo where
    type HaskellCallbackType TerminalIconifyWindowSignalInfo = TerminalIconifyWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalIconifyWindowCallback cb
        cb'' <- mk_TerminalIconifyWindowCallback cb'
        connectSignalFunPtr obj "iconify-window" cb'' connectMode

data TerminalIncreaseFontSizeSignalInfo
instance SignalInfo TerminalIncreaseFontSizeSignalInfo where
    type HaskellCallbackType TerminalIncreaseFontSizeSignalInfo = TerminalIncreaseFontSizeCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalIncreaseFontSizeCallback cb
        cb'' <- mk_TerminalIncreaseFontSizeCallback cb'
        connectSignalFunPtr obj "increase-font-size" cb'' connectMode

data TerminalLowerWindowSignalInfo
instance SignalInfo TerminalLowerWindowSignalInfo where
    type HaskellCallbackType TerminalLowerWindowSignalInfo = TerminalLowerWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalLowerWindowCallback cb
        cb'' <- mk_TerminalLowerWindowCallback cb'
        connectSignalFunPtr obj "lower-window" cb'' connectMode

data TerminalMaximizeWindowSignalInfo
instance SignalInfo TerminalMaximizeWindowSignalInfo where
    type HaskellCallbackType TerminalMaximizeWindowSignalInfo = TerminalMaximizeWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalMaximizeWindowCallback cb
        cb'' <- mk_TerminalMaximizeWindowCallback cb'
        connectSignalFunPtr obj "maximize-window" cb'' connectMode

data TerminalMoveWindowSignalInfo
instance SignalInfo TerminalMoveWindowSignalInfo where
    type HaskellCallbackType TerminalMoveWindowSignalInfo = TerminalMoveWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalMoveWindowCallback cb
        cb'' <- mk_TerminalMoveWindowCallback cb'
        connectSignalFunPtr obj "move-window" cb'' connectMode

data TerminalNotificationReceivedSignalInfo
instance SignalInfo TerminalNotificationReceivedSignalInfo where
    type HaskellCallbackType TerminalNotificationReceivedSignalInfo = TerminalNotificationReceivedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalNotificationReceivedCallback cb
        cb'' <- mk_TerminalNotificationReceivedCallback cb'
        connectSignalFunPtr obj "notification-received" cb'' connectMode

data TerminalPasteClipboardSignalInfo
instance SignalInfo TerminalPasteClipboardSignalInfo where
    type HaskellCallbackType TerminalPasteClipboardSignalInfo = TerminalPasteClipboardCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalPasteClipboardCallback cb
        cb'' <- mk_TerminalPasteClipboardCallback cb'
        connectSignalFunPtr obj "paste-clipboard" cb'' connectMode

data TerminalRaiseWindowSignalInfo
instance SignalInfo TerminalRaiseWindowSignalInfo where
    type HaskellCallbackType TerminalRaiseWindowSignalInfo = TerminalRaiseWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalRaiseWindowCallback cb
        cb'' <- mk_TerminalRaiseWindowCallback cb'
        connectSignalFunPtr obj "raise-window" cb'' connectMode

data TerminalRefreshWindowSignalInfo
instance SignalInfo TerminalRefreshWindowSignalInfo where
    type HaskellCallbackType TerminalRefreshWindowSignalInfo = TerminalRefreshWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalRefreshWindowCallback cb
        cb'' <- mk_TerminalRefreshWindowCallback cb'
        connectSignalFunPtr obj "refresh-window" cb'' connectMode

data TerminalResizeWindowSignalInfo
instance SignalInfo TerminalResizeWindowSignalInfo where
    type HaskellCallbackType TerminalResizeWindowSignalInfo = TerminalResizeWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalResizeWindowCallback cb
        cb'' <- mk_TerminalResizeWindowCallback cb'
        connectSignalFunPtr obj "resize-window" cb'' connectMode

data TerminalRestoreWindowSignalInfo
instance SignalInfo TerminalRestoreWindowSignalInfo where
    type HaskellCallbackType TerminalRestoreWindowSignalInfo = TerminalRestoreWindowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalRestoreWindowCallback cb
        cb'' <- mk_TerminalRestoreWindowCallback cb'
        connectSignalFunPtr obj "restore-window" cb'' connectMode

data TerminalSelectionChangedSignalInfo
instance SignalInfo TerminalSelectionChangedSignalInfo where
    type HaskellCallbackType TerminalSelectionChangedSignalInfo = TerminalSelectionChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalSelectionChangedCallback cb
        cb'' <- mk_TerminalSelectionChangedCallback cb'
        connectSignalFunPtr obj "selection-changed" cb'' connectMode

data TerminalTextDeletedSignalInfo
instance SignalInfo TerminalTextDeletedSignalInfo where
    type HaskellCallbackType TerminalTextDeletedSignalInfo = TerminalTextDeletedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalTextDeletedCallback cb
        cb'' <- mk_TerminalTextDeletedCallback cb'
        connectSignalFunPtr obj "text-deleted" cb'' connectMode

data TerminalTextInsertedSignalInfo
instance SignalInfo TerminalTextInsertedSignalInfo where
    type HaskellCallbackType TerminalTextInsertedSignalInfo = TerminalTextInsertedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalTextInsertedCallback cb
        cb'' <- mk_TerminalTextInsertedCallback cb'
        connectSignalFunPtr obj "text-inserted" cb'' connectMode

data TerminalTextModifiedSignalInfo
instance SignalInfo TerminalTextModifiedSignalInfo where
    type HaskellCallbackType TerminalTextModifiedSignalInfo = TerminalTextModifiedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalTextModifiedCallback cb
        cb'' <- mk_TerminalTextModifiedCallback cb'
        connectSignalFunPtr obj "text-modified" cb'' connectMode

data TerminalTextScrolledSignalInfo
instance SignalInfo TerminalTextScrolledSignalInfo where
    type HaskellCallbackType TerminalTextScrolledSignalInfo = TerminalTextScrolledCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalTextScrolledCallback cb
        cb'' <- mk_TerminalTextScrolledCallback cb'
        connectSignalFunPtr obj "text-scrolled" cb'' connectMode

data TerminalWindowTitleChangedSignalInfo
instance SignalInfo TerminalWindowTitleChangedSignalInfo where
    type HaskellCallbackType TerminalWindowTitleChangedSignalInfo = TerminalWindowTitleChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalWindowTitleChangedCallback cb
        cb'' <- mk_TerminalWindowTitleChangedCallback cb'
        connectSignalFunPtr obj "window-title-changed" cb'' connectMode

type instance O.SignalList Terminal = TerminalSignalList
type TerminalSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("bell", TerminalBellSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("charSizeChanged", TerminalCharSizeChangedSignalInfo), '("childExited", TerminalChildExitedSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("commit", TerminalCommitSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("contentsChanged", TerminalContentsChangedSignalInfo), '("copyClipboard", TerminalCopyClipboardSignalInfo), '("currentDirectoryUriChanged", TerminalCurrentDirectoryUriChangedSignalInfo), '("currentFileUriChanged", TerminalCurrentFileUriChangedSignalInfo), '("cursorMoved", TerminalCursorMovedSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("decreaseFontSize", TerminalDecreaseFontSizeSignalInfo), '("deiconifyWindow", TerminalDeiconifyWindowSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("encodingChanged", TerminalEncodingChangedSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("eof", TerminalEofSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("iconTitleChanged", TerminalIconTitleChangedSignalInfo), '("iconifyWindow", TerminalIconifyWindowSignalInfo), '("increaseFontSize", TerminalIncreaseFontSizeSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("lowerWindow", TerminalLowerWindowSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("maximizeWindow", TerminalMaximizeWindowSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveWindow", TerminalMoveWindowSignalInfo), '("notificationReceived", TerminalNotificationReceivedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", TerminalPasteClipboardSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("raiseWindow", TerminalRaiseWindowSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("refreshWindow", TerminalRefreshWindowSignalInfo), '("resizeWindow", TerminalResizeWindowSignalInfo), '("restoreWindow", TerminalRestoreWindowSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionChanged", TerminalSelectionChangedSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("textDeleted", TerminalTextDeletedSignalInfo), '("textInserted", TerminalTextInsertedSignalInfo), '("textModified", TerminalTextModifiedSignalInfo), '("textScrolled", TerminalTextScrolledSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo), '("windowTitleChanged", TerminalWindowTitleChangedSignalInfo)] :: [(Symbol, *)])

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

foreign import ccall "vte_terminal_new" vte_terminal_new :: 
    IO (Ptr Terminal)

{- |
Creates a new terminal widget.
-}
terminalNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Terminal
    {- ^ __Returns:__ a new 'GI.Vte.Objects.Terminal.Terminal' object -}
terminalNew  = liftIO $ do
    result <- vte_terminal_new
    checkUnexpectedReturnNULL "terminalNew" result
    result' <- (newObject Terminal) result
    return result'

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

foreign import ccall "vte_terminal_copy_clipboard" vte_terminal_copy_clipboard :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@
selection.
-}
terminalCopyClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalCopyClipboard terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_copy_clipboard terminal'
    touchManagedPtr terminal
    return ()

data TerminalCopyClipboardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardMethodInfo a signature where
    overloadedMethod _ = terminalCopyClipboard

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

foreign import ccall "vte_terminal_copy_primary" vte_terminal_copy_primary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Places the selected text in the terminal in the @/GDK_SELECTION_PRIMARY/@
selection.
-}
terminalCopyPrimary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalCopyPrimary terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_copy_primary terminal'
    touchManagedPtr terminal
    return ()

data TerminalCopyPrimaryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyPrimaryMethodInfo a signature where
    overloadedMethod _ = terminalCopyPrimary

-- method Terminal::feed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a string in the terminal's current encoding", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the string, or -1 to use the full length or a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the string, or -1 to use the full length or a nul-terminated string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed" vte_terminal_feed :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

{- |
Interprets /@data@/ as if it were data received from a child process.  This
can either be used to drive the terminal without a child process, or just
to mess with your users.
-}
terminalFeed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (ByteString)
    {- ^ /@data@/: a string in the terminal\'s current encoding -}
    -> m ()
terminalFeed terminal data_ = liftIO $ do
    let length_ = case data_ of
            Nothing -> 0
            Just jData_ -> fromIntegral $ B.length jData_
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeData_ <- case data_ of
        Nothing -> return nullPtr
        Just jData_ -> do
            jData_' <- packByteString jData_
            return jData_'
    vte_terminal_feed terminal' maybeData_ length_
    touchManagedPtr terminal
    freeMem maybeData_
    return ()

data TerminalFeedMethodInfo
instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedMethodInfo a signature where
    overloadedMethod _ = terminalFeed

-- method Terminal::feed_child
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the child", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @text in bytes, or -1 if @text is NUL-terminated", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child" vte_terminal_feed_child :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- text : TBasicType TUTF8
    Int64 ->                                -- length : TBasicType TInt64
    IO ()

{- |
Sends a block of UTF-8 text to the child as if it were entered by the user
at the keyboard.
-}
terminalFeedChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (T.Text)
    {- ^ /@text@/: data to send to the child -}
    -> Int64
    {- ^ /@length@/: length of /@text@/ in bytes, or -1 if /@text@/ is NUL-terminated -}
    -> m ()
terminalFeedChild terminal text length_ = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeText <- case text of
        Nothing -> return nullPtr
        Just jText -> do
            jText' <- textToCString jText
            return jText'
    vte_terminal_feed_child terminal' maybeText length_
    touchManagedPtr terminal
    freeMem maybeText
    return ()

data TerminalFeedChildMethodInfo
instance (signature ~ (Maybe (T.Text) -> Int64 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildMethodInfo a signature where
    overloadedMethod _ = terminalFeedChild

-- method Terminal::feed_child_binary
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to send to the child", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_feed_child_binary" vte_terminal_feed_child_binary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    IO ()

{- |
Sends a block of binary data to the child.
-}
terminalFeedChildBinary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (ByteString)
    {- ^ /@data@/: data to send to the child -}
    -> m ()
terminalFeedChildBinary terminal data_ = liftIO $ do
    let length_ = case data_ of
            Nothing -> 0
            Just jData_ -> fromIntegral $ B.length jData_
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeData_ <- case data_ of
        Nothing -> return nullPtr
        Just jData_ -> do
            jData_' <- packByteString jData_
            return jData_'
    vte_terminal_feed_child_binary terminal' maybeData_ length_
    touchManagedPtr terminal
    freeMem maybeData_
    return ()

data TerminalFeedChildBinaryMethodInfo
instance (signature ~ (Maybe (ByteString) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildBinaryMethodInfo a signature where
    overloadedMethod _ = terminalFeedChildBinary

-- method Terminal::get_allow_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_allow_bold" vte_terminal_get_allow_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks whether or not the terminal will attempt to draw bold text by
repainting text with a one-pixel offset.
-}
terminalGetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if bolding is enabled, 'False' if not -}
terminalGetAllowBold terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_allow_bold terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetAllowBoldMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowBoldMethodInfo a signature where
    overloadedMethod _ = terminalGetAllowBold

-- method Terminal::get_audible_bell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_audible_bell" vte_terminal_get_audible_bell :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks whether or not the terminal will beep when the child outputs the
\"bl\" sequence.
-}
terminalGetAudibleBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if audible bell is enabled, 'False' if not -}
terminalGetAudibleBell terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_audible_bell terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetAudibleBellMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAudibleBellMethodInfo a signature where
    overloadedMethod _ = terminalGetAudibleBell

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

foreign import ccall "vte_terminal_get_char_height" vte_terminal_get_char_height :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

{- |
/No description available in the introspection data./
-}
terminalGetCharHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m CLong
    {- ^ __Returns:__ the height of a character cell -}
terminalGetCharHeight terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_char_height terminal'
    touchManagedPtr terminal
    return result

data TerminalGetCharHeightMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharHeightMethodInfo a signature where
    overloadedMethod _ = terminalGetCharHeight

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

foreign import ccall "vte_terminal_get_char_width" vte_terminal_get_char_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

{- |
/No description available in the introspection data./
-}
terminalGetCharWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m CLong
    {- ^ __Returns:__ the width of a character cell -}
terminalGetCharWidth terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_char_width terminal'
    touchManagedPtr terminal
    return result

data TerminalGetCharWidthMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCharWidthMethodInfo a signature where
    overloadedMethod _ = terminalGetCharWidth

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

foreign import ccall "vte_terminal_get_cjk_ambiguous_width" vte_terminal_get_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO Int32

{- |
Returns whether ambiguous-width characters are narrow or wide when using
the UTF-8 encoding ('GI.Vte.Objects.Terminal.terminalSetEncoding').
-}
terminalGetCjkAmbiguousWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Int32
    {- ^ __Returns:__ 1 if ambiguous-width characters are narrow, or 2 if they are wide -}
terminalGetCjkAmbiguousWidth terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_cjk_ambiguous_width terminal'
    touchManagedPtr terminal
    return result

data TerminalGetCjkAmbiguousWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod _ = terminalGetCjkAmbiguousWidth

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

foreign import ccall "vte_terminal_get_column_count" vte_terminal_get_column_count :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

{- |
/No description available in the introspection data./
-}
terminalGetColumnCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m CLong
    {- ^ __Returns:__ the number of columns -}
terminalGetColumnCount terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_column_count terminal'
    touchManagedPtr terminal
    return result

data TerminalGetColumnCountMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetColumnCountMethodInfo a signature where
    overloadedMethod _ = terminalGetColumnCount

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

foreign import ccall "vte_terminal_get_current_directory_uri" vte_terminal_get_current_directory_uri :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
/No description available in the introspection data./
-}
terminalGetCurrentDirectoryUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ the URI of the current directory of the
  process running in the terminal, or 'Nothing' -}
terminalGetCurrentDirectoryUri terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_current_directory_uri terminal'
    checkUnexpectedReturnNULL "terminalGetCurrentDirectoryUri" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetCurrentDirectoryUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentDirectoryUriMethodInfo a signature where
    overloadedMethod _ = terminalGetCurrentDirectoryUri

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

foreign import ccall "vte_terminal_get_current_file_uri" vte_terminal_get_current_file_uri :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
/No description available in the introspection data./
-}
terminalGetCurrentFileUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ the URI of the current file the
  process running in the terminal is operating on, or 'Nothing' if
  not set -}
terminalGetCurrentFileUri terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_current_file_uri terminal'
    checkUnexpectedReturnNULL "terminalGetCurrentFileUri" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetCurrentFileUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCurrentFileUriMethodInfo a signature where
    overloadedMethod _ = terminalGetCurrentFileUri

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

foreign import ccall "vte_terminal_get_cursor_blink_mode" vte_terminal_get_cursor_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CUInt

{- |
Returns the currently set cursor blink mode.
-}
terminalGetCursorBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Vte.Enums.CursorBlinkMode
    {- ^ __Returns:__ cursor blink mode. -}
terminalGetCursorBlinkMode terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_cursor_blink_mode terminal'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr terminal
    return result'

data TerminalGetCursorBlinkModeMethodInfo
instance (signature ~ (m Vte.Enums.CursorBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorBlinkModeMethodInfo a signature where
    overloadedMethod _ = terminalGetCursorBlinkMode

-- method Terminal::get_cursor_position
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the column, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the row, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_cursor_position" vte_terminal_get_cursor_position :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr CLong ->                            -- column : TBasicType TLong
    Ptr CLong ->                            -- row : TBasicType TLong
    IO ()

{- |
Reads the location of the insertion cursor and returns it.  The row
coordinate is absolute.
-}
terminalGetCursorPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m (CLong,CLong)
terminalGetCursorPosition terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    column <- allocMem :: IO (Ptr CLong)
    row <- allocMem :: IO (Ptr CLong)
    vte_terminal_get_cursor_position terminal' column row
    column' <- peek column
    row' <- peek row
    touchManagedPtr terminal
    freeMem column
    freeMem row
    return (column', row')

data TerminalGetCursorPositionMethodInfo
instance (signature ~ (m (CLong,CLong)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorPositionMethodInfo a signature where
    overloadedMethod _ = terminalGetCursorPosition

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

foreign import ccall "vte_terminal_get_cursor_shape" vte_terminal_get_cursor_shape :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CUInt

{- |
Returns the currently set cursor shape.
-}
terminalGetCursorShape ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Vte.Enums.CursorShape
    {- ^ __Returns:__ cursor shape. -}
terminalGetCursorShape terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_cursor_shape terminal'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr terminal
    return result'

data TerminalGetCursorShapeMethodInfo
instance (signature ~ (m Vte.Enums.CursorShape), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCursorShapeMethodInfo a signature where
    overloadedMethod _ = terminalGetCursorShape

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

foreign import ccall "vte_terminal_get_encoding" vte_terminal_get_encoding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
Determines the name of the encoding in which the terminal expects data to be
encoded.
-}
terminalGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ the current encoding for the terminal -}
terminalGetEncoding terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_encoding terminal'
    checkUnexpectedReturnNULL "terminalGetEncoding" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetEncodingMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetEncodingMethodInfo a signature where
    overloadedMethod _ = terminalGetEncoding

-- method Terminal::get_font
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "FontDescription"}))
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_font" vte_terminal_get_font :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Pango.FontDescription.FontDescription)

{- |
Queries the terminal for information about the fonts which will be
used to draw text in the terminal.  The actual font takes the font scale
into account, this is not reflected in the return value, the unscaled
font is returned.
-}
terminalGetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Pango.FontDescription.FontDescription
    {- ^ __Returns:__ a 'GI.Pango.Structs.FontDescription.FontDescription' describing the font the
terminal uses to render text at the default font scale of 1.0. -}
terminalGetFont terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_font terminal'
    checkUnexpectedReturnNULL "terminalGetFont" result
    result' <- (newBoxed Pango.FontDescription.FontDescription) result
    touchManagedPtr terminal
    return result'

data TerminalGetFontMethodInfo
instance (signature ~ (m Pango.FontDescription.FontDescription), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontMethodInfo a signature where
    overloadedMethod _ = terminalGetFont

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

foreign import ccall "vte_terminal_get_font_scale" vte_terminal_get_font_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
terminalGetFontScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Double
    {- ^ __Returns:__ the terminal\'s font scale -}
terminalGetFontScale terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_font_scale terminal'
    let result' = realToFrac result
    touchManagedPtr terminal
    return result'

data TerminalGetFontScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetFontScaleMethodInfo a signature where
    overloadedMethod _ = terminalGetFontScale

-- method Terminal::get_geometry_hints
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hints", argType = TInterface (Name {namespace = "Gdk", name = "Geometry"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkGeometry to fill in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "min_rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of rows to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_columns", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the minimum number of columns to request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_geometry_hints" vte_terminal_get_geometry_hints :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Geometry.Geometry ->            -- hints : TInterface (Name {namespace = "Gdk", name = "Geometry"})
    Int32 ->                                -- min_rows : TBasicType TInt
    Int32 ->                                -- min_columns : TBasicType TInt
    IO ()

{- |
Fills in some /@hints@/ from /@terminal@/\'s geometry. The hints
filled are those covered by the 'GI.Gdk.Flags.WindowHintsResizeInc',
'GI.Gdk.Flags.WindowHintsMinSize' and 'GI.Gdk.Flags.WindowHintsBaseSize' flags.

See 'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.

/@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').
-}
terminalGetGeometryHints ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@minRows@/: the minimum number of rows to request -}
    -> Int32
    {- ^ /@minColumns@/: the minimum number of columns to request -}
    -> m (Gdk.Geometry.Geometry)
terminalGetGeometryHints terminal minRows minColumns = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    hints <- callocBytes 56 :: IO (Ptr Gdk.Geometry.Geometry)
    vte_terminal_get_geometry_hints terminal' hints minRows minColumns
    hints' <- (wrapPtr Gdk.Geometry.Geometry) hints
    touchManagedPtr terminal
    return hints'

data TerminalGetGeometryHintsMethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Gdk.Geometry.Geometry)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetGeometryHintsMethodInfo a signature where
    overloadedMethod _ = terminalGetGeometryHints

-- method Terminal::get_has_selection
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_has_selection" vte_terminal_get_has_selection :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks if the terminal currently contains selected text.  Note that this
is different from determining if the terminal is the owner of any
'GI.Gtk.Objects.Clipboard.Clipboard' items.
-}
terminalGetHasSelection ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if part of the text in the terminal is selected. -}
terminalGetHasSelection terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_has_selection terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetHasSelectionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetHasSelectionMethodInfo a signature where
    overloadedMethod _ = terminalGetHasSelection

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

foreign import ccall "vte_terminal_get_icon_title" vte_terminal_get_icon_title :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
/No description available in the introspection data./
-}
terminalGetIconTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ the icon title -}
terminalGetIconTitle terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_icon_title terminal'
    checkUnexpectedReturnNULL "terminalGetIconTitle" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetIconTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetIconTitleMethodInfo a signature where
    overloadedMethod _ = terminalGetIconTitle

-- method Terminal::get_input_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_input_enabled" vte_terminal_get_input_enabled :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Returns whether the terminal allow user input.
-}
terminalGetInputEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
terminalGetInputEnabled terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_input_enabled terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetInputEnabledMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetInputEnabledMethodInfo a signature where
    overloadedMethod _ = terminalGetInputEnabled

-- method Terminal::get_mouse_autohide
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_mouse_autohide" vte_terminal_get_mouse_autohide :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Determines the value of the terminal\'s mouse autohide setting.  When
autohiding is enabled, the mouse cursor will be hidden when the user presses
a key and shown when the user moves the mouse.  This setting can be changed
using 'GI.Vte.Objects.Terminal.terminalSetMouseAutohide'.
-}
terminalGetMouseAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if autohiding is enabled, 'False' if not -}
terminalGetMouseAutohide terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_mouse_autohide terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetMouseAutohideMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetMouseAutohideMethodInfo a signature where
    overloadedMethod _ = terminalGetMouseAutohide

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

foreign import ccall "vte_terminal_get_pty" vte_terminal_get_pty :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Vte.Pty.Pty)

{- |
Returns the 'GI.Vte.Objects.Pty.Pty' of /@terminal@/.
-}
terminalGetPty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Vte.Pty.Pty
    {- ^ __Returns:__ a 'GI.Vte.Objects.Pty.Pty', or 'Nothing' -}
terminalGetPty terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_pty terminal'
    checkUnexpectedReturnNULL "terminalGetPty" result
    result' <- (newObject Vte.Pty.Pty) result
    touchManagedPtr terminal
    return result'

data TerminalGetPtyMethodInfo
instance (signature ~ (m Vte.Pty.Pty), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetPtyMethodInfo a signature where
    overloadedMethod _ = terminalGetPty

-- method Terminal::get_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_get_rewrap_on_resize" vte_terminal_get_rewrap_on_resize :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks whether or not the terminal will rewrap its contents upon resize.
-}
terminalGetRewrapOnResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if rewrapping is enabled, 'False' if not -}
terminalGetRewrapOnResize terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_rewrap_on_resize terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalGetRewrapOnResizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRewrapOnResizeMethodInfo a signature where
    overloadedMethod _ = terminalGetRewrapOnResize

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

foreign import ccall "vte_terminal_get_row_count" vte_terminal_get_row_count :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CLong

{- |
/No description available in the introspection data./
-}
terminalGetRowCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m CLong
    {- ^ __Returns:__ the number of rows -}
terminalGetRowCount terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_row_count terminal'
    touchManagedPtr terminal
    return result

data TerminalGetRowCountMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetRowCountMethodInfo a signature where
    overloadedMethod _ = terminalGetRowCount

-- XXX Could not generate method Terminal::get_text
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextMethodInfo
instance (p ~ (), o ~ O.MethodResolutionFailed "getText" Terminal) => O.MethodInfo TerminalGetTextMethodInfo o p where
    overloadedMethod _ = undefined
-- XXX Could not generate method Terminal::get_text_include_trailing_spaces
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextIncludeTrailingSpacesMethodInfo
instance (p ~ (), o ~ O.MethodResolutionFailed "getTextIncludeTrailingSpaces" Terminal) => O.MethodInfo TerminalGetTextIncludeTrailingSpacesMethodInfo o p where
    overloadedMethod _ = undefined
-- XXX Could not generate method Terminal::get_text_range
-- Error was : Not implemented: "Don't know how to allocate \"attributes\" of type TGArray (TInterface (Name {namespace = \"Vte\", name = \"CharAttributes\"}))"
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data TerminalGetTextRangeMethodInfo
instance (p ~ (), o ~ O.MethodResolutionFailed "getTextRange" Terminal) => O.MethodInfo TerminalGetTextRangeMethodInfo o p where
    overloadedMethod _ = undefined
-- method Terminal::get_window_title
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_get_window_title" vte_terminal_get_window_title :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
/No description available in the introspection data./
-}
terminalGetWindowTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ the window title -}
terminalGetWindowTitle terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_window_title terminal'
    checkUnexpectedReturnNULL "terminalGetWindowTitle" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetWindowTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWindowTitleMethodInfo a signature where
    overloadedMethod _ = terminalGetWindowTitle

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

foreign import ccall "vte_terminal_get_word_char_exceptions" vte_terminal_get_word_char_exceptions :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CString

{- |
Returns the set of characters which will be considered parts of a word
when doing word-wise selection, in addition to the default which only
considers alphanumeric characters part of a word.

If 'Nothing', a built-in set is used.

@since 0.40
-}
terminalGetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m T.Text
    {- ^ __Returns:__ a string, or 'Nothing' -}
terminalGetWordCharExceptions terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_word_char_exceptions terminal'
    checkUnexpectedReturnNULL "terminalGetWordCharExceptions" result
    result' <- cstringToText result
    touchManagedPtr terminal
    return result'

data TerminalGetWordCharExceptionsMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetWordCharExceptionsMethodInfo a signature where
    overloadedMethod _ = terminalGetWordCharExceptions

-- method Terminal::match_add_gregex
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gregex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GRegex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gflags", argType = TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GRegexMatchFlags to use when matching the regex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_gregex" vte_terminal_match_add_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO Int32

{-# DEPRECATED terminalMatchAddGregex ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' or @/vte_terminal_match_add_regex_full()/@ instead."] #-}
{- |
Adds the regular expression /@regex@/ to the list of matching expressions.  When the
user moves the mouse cursor over a section of displayed text which matches
this expression, the text will be highlighted.
-}
terminalMatchAddGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> GLib.Regex.Regex
    {- ^ /@gregex@/: a 'GI.GLib.Structs.Regex.Regex' -}
    -> [GLib.Flags.RegexMatchFlags]
    {- ^ /@gflags@/: the 'GI.GLib.Flags.RegexMatchFlags' to use when matching the regex -}
    -> m Int32
    {- ^ __Returns:__ an integer associated with this expression, or -1 if /@gregex@/ could not be
  transformed into a 'GI.Vte.Structs.Regex.Regex' or /@gflags@/ were incompatible -}
terminalMatchAddGregex terminal gregex gflags = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    gregex' <- unsafeManagedPtrGetPtr gregex
    let gflags' = gflagsToWord gflags
    result <- vte_terminal_match_add_gregex terminal' gregex' gflags'
    touchManagedPtr terminal
    touchManagedPtr gregex
    return result

data TerminalMatchAddGregexMethodInfo
instance (signature ~ (GLib.Regex.Regex -> [GLib.Flags.RegexMatchFlags] -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddGregexMethodInfo a signature where
    overloadedMethod _ = terminalMatchAddGregex

-- method Terminal::match_add_regex
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteRegex", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "PCRE2 match flags, or 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_add_regex" vte_terminal_match_add_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO Int32

{- |
Adds the regular expression /@regex@/ to the list of matching expressions.  When the
user moves the mouse cursor over a section of displayed text which matches
this expression, the text will be highlighted.

@since 0.46
-}
terminalMatchAddRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Regex.Regex
    {- ^ /@regex@/: a 'GI.Vte.Structs.Regex.Regex' -}
    -> Word32
    {- ^ /@flags@/: PCRE2 match flags, or 0 -}
    -> m Int32
    {- ^ __Returns:__ an integer associated with this expression -}
terminalMatchAddRegex terminal regex flags = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    regex' <- unsafeManagedPtrGetPtr regex
    result <- vte_terminal_match_add_regex terminal' regex' flags
    touchManagedPtr terminal
    touchManagedPtr regex
    return result

data TerminalMatchAddRegexMethodInfo
instance (signature ~ (Vte.Regex.Regex -> Word32 -> m Int32), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchAddRegexMethodInfo a signature where
    overloadedMethod _ = terminalMatchAddRegex

-- method Terminal::match_check
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "column", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text column", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "row", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text row", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the tag, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check" vte_terminal_match_check :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- column : TBasicType TLong
    CLong ->                                -- row : TBasicType TLong
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

{-# DEPRECATED terminalMatchCheck ["(Since version 0.46)","Use 'GI.Vte.Objects.Terminal.terminalMatchCheckEvent' instead."] #-}
{- |
Checks if the text in and around the specified position matches any of the
regular expressions previously set using @/vte_terminal_match_add()/@.  If a
match exists, the text string is returned and if /@tag@/ is not 'Nothing', the number
associated with the matched regular expression will be stored in /@tag@/.

If more than one regular expression has been set with
@/vte_terminal_match_add()/@, then expressions are checked in the order in
which they were added.
-}
terminalMatchCheck ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> CLong
    {- ^ /@column@/: the text column -}
    -> CLong
    {- ^ /@row@/: the text row -}
    -> m (T.Text,Int32)
    {- ^ __Returns:__ a newly allocated string which matches one of the previously
  set regular expressions -}
terminalMatchCheck terminal column row = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    tag <- allocMem :: IO (Ptr Int32)
    result <- vte_terminal_match_check terminal' column row tag
    checkUnexpectedReturnNULL "terminalMatchCheck" result
    result' <- cstringToText result
    freeMem result
    tag' <- peek tag
    touchManagedPtr terminal
    freeMem tag
    return (result', tag')

data TerminalMatchCheckMethodInfo
instance (signature ~ (CLong -> CLong -> m (T.Text,Int32)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckMethodInfo a signature where
    overloadedMethod _ = terminalMatchCheck

-- method Terminal::match_check_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the tag, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_check_event" vte_terminal_match_check_event :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Ptr Int32 ->                            -- tag : TBasicType TInt
    IO CString

{- |
Checks if the text in and around the position of the event matches any of the
regular expressions previously set using @/vte_terminal_match_add()/@.  If a
match exists, the text string is returned and if /@tag@/ is not 'Nothing', the number
associated with the matched regular expression will be stored in /@tag@/.

If more than one regular expression has been set with
@/vte_terminal_match_add()/@, then expressions are checked in the order in
which they were added.
-}
terminalMatchCheckEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -}
    -> m (T.Text,Int32)
    {- ^ __Returns:__ a newly allocated string which matches one of the previously
  set regular expressions -}
terminalMatchCheckEvent terminal event = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    event' <- unsafeManagedPtrGetPtr event
    tag <- allocMem :: IO (Ptr Int32)
    result <- vte_terminal_match_check_event terminal' event' tag
    checkUnexpectedReturnNULL "terminalMatchCheckEvent" result
    result' <- cstringToText result
    freeMem result
    tag' <- peek tag
    touchManagedPtr terminal
    touchManagedPtr event
    freeMem tag
    return (result', tag')

data TerminalMatchCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m (T.Text,Int32)), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchCheckEventMethodInfo a signature where
    overloadedMethod _ = terminalMatchCheckEvent

-- method Terminal::match_remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex 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 "vte_terminal_match_remove" vte_terminal_match_remove :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    IO ()

{- |
Removes the regular expression which is associated with the given /@tag@/ from
the list of expressions which the terminal will highlight when the user
moves the mouse cursor over matching text.
-}
terminalMatchRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@tag@/: the tag of the regex to remove -}
    -> m ()
terminalMatchRemove terminal tag = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_match_remove terminal' tag
    touchManagedPtr terminal
    return ()

data TerminalMatchRemoveMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveMethodInfo a signature where
    overloadedMethod _ = terminalMatchRemove

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

foreign import ccall "vte_terminal_match_remove_all" vte_terminal_match_remove_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Clears the list of regular expressions the terminal uses to highlight text
when the user moves the mouse cursor.
-}
terminalMatchRemoveAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalMatchRemoveAll terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_match_remove_all terminal'
    touchManagedPtr terminal
    return ()

data TerminalMatchRemoveAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchRemoveAllMethodInfo a signature where
    overloadedMethod _ = terminalMatchRemoveAll

-- method Terminal::match_set_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor", argType = TInterface (Name {namespace = "Gdk", name = "Cursor"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the #GdkCursor which the terminal should use when the pattern is\n  highlighted, or %NULL to use the standard cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor" vte_terminal_match_set_cursor :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    Ptr Gdk.Cursor.Cursor ->                -- cursor : TInterface (Name {namespace = "Gdk", name = "Cursor"})
    IO ()

{-# DEPRECATED terminalMatchSetCursor ["(Since version 0.40)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorType' or @/vte_terminal_match_set_cursor_named()/@ instead."] #-}
{- |
Sets which cursor the terminal will use if the pointer is over the pattern
specified by /@tag@/.  The terminal keeps a reference to /@cursor@/.
-}
terminalMatchSetCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}
    -> Maybe (b)
    {- ^ /@cursor@/: the 'GI.Gdk.Objects.Cursor.Cursor' which the terminal should use when the pattern is
  highlighted, or 'Nothing' to use the standard cursor -}
    -> m ()
terminalMatchSetCursor terminal tag cursor = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeCursor <- case cursor of
        Nothing -> return nullPtr
        Just jCursor -> do
            jCursor' <- unsafeManagedPtrCastPtr jCursor
            return jCursor'
    vte_terminal_match_set_cursor terminal' tag maybeCursor
    touchManagedPtr terminal
    whenJust cursor touchManagedPtr
    return ()

data TerminalMatchSetCursorMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> m ()), MonadIO m, IsTerminal a, Gdk.Cursor.IsCursor b) => O.MethodInfo TerminalMatchSetCursorMethodInfo a signature where
    overloadedMethod _ = terminalMatchSetCursor

-- method Terminal::match_set_cursor_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_name" vte_terminal_match_set_cursor_name :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CString ->                              -- cursor_name : TBasicType TUTF8
    IO ()

{- |
Sets which cursor the terminal will use if the pointer is over the pattern
specified by /@tag@/.
-}
terminalMatchSetCursorName ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}
    -> T.Text
    {- ^ /@cursorName@/: the name of the cursor -}
    -> m ()
terminalMatchSetCursorName terminal tag cursorName = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    cursorName' <- textToCString cursorName
    vte_terminal_match_set_cursor_name terminal' tag cursorName'
    touchManagedPtr terminal
    freeMem cursorName'
    return ()

data TerminalMatchSetCursorNameMethodInfo
instance (signature ~ (Int32 -> T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorNameMethodInfo a signature where
    overloadedMethod _ = terminalMatchSetCursorName

-- method Terminal::match_set_cursor_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the tag of the regex which should use the specified cursor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_type", argType = TInterface (Name {namespace = "Gdk", name = "CursorType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkCursorType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_match_set_cursor_type" vte_terminal_match_set_cursor_type :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- tag : TBasicType TInt
    CUInt ->                                -- cursor_type : TInterface (Name {namespace = "Gdk", name = "CursorType"})
    IO ()

{- |
Sets which cursor the terminal will use if the pointer is over the pattern
specified by /@tag@/.
-}
terminalMatchSetCursorType ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@tag@/: the tag of the regex which should use the specified cursor -}
    -> Gdk.Enums.CursorType
    {- ^ /@cursorType@/: a 'GI.Gdk.Enums.CursorType' -}
    -> m ()
terminalMatchSetCursorType terminal tag cursorType = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let cursorType' = (fromIntegral . fromEnum) cursorType
    vte_terminal_match_set_cursor_type terminal' tag cursorType'
    touchManagedPtr terminal
    return ()

data TerminalMatchSetCursorTypeMethodInfo
instance (signature ~ (Int32 -> Gdk.Enums.CursorType -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalMatchSetCursorTypeMethodInfo a signature where
    overloadedMethod _ = terminalMatchSetCursorType

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

foreign import ccall "vte_terminal_paste_clipboard" vte_terminal_paste_clipboard :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Sends the contents of the @/GDK_SELECTION_CLIPBOARD/@ selection to the
terminal\'s child.  If necessary, the data is converted from UTF-8 to the
terminal\'s current encoding. It\'s called on paste menu item, or when
user presses Shift+Insert.
-}
terminalPasteClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalPasteClipboard terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_paste_clipboard terminal'
    touchManagedPtr terminal
    return ()

data TerminalPasteClipboardMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPasteClipboardMethodInfo a signature where
    overloadedMethod _ = terminalPasteClipboard

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

foreign import ccall "vte_terminal_paste_primary" vte_terminal_paste_primary :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Sends the contents of the @/GDK_SELECTION_PRIMARY/@ selection to the terminal\'s
child.  If necessary, the data is converted from UTF-8 to the terminal\'s
current encoding.  The terminal will call also paste the
@/GDK_SELECTION_PRIMARY/@ selection when the user clicks with the the second
mouse button.
-}
terminalPastePrimary ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalPastePrimary terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_paste_primary terminal'
    touchManagedPtr terminal
    return ()

data TerminalPastePrimaryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalPastePrimaryMethodInfo a signature where
    overloadedMethod _ = terminalPastePrimary

-- method Terminal::pty_new_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Vte", name = "PtyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #VtePtyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Vte", name = "Pty"}))
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_pty_new_sync" vte_terminal_pty_new_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Vte.Pty.Pty)

{- |
Creates a new 'GI.Vte.Objects.Pty.Pty', and sets the emulation property
from 'GI.Vte.Objects.Terminal.Terminal':@/emulation/@.

See @/vte_pty_new()/@ for more information.
-}
terminalPtyNewSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> [Vte.Flags.PtyFlags]
    {- ^ /@flags@/: flags from 'GI.Vte.Flags.PtyFlags' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m Vte.Pty.Pty
    {- ^ __Returns:__ a new 'GI.Vte.Objects.Pty.Pty' /(Can throw 'Data.GI.Base.GError.GError')/ -}
terminalPtyNewSync terminal flags cancellable = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let flags' = gflagsToWord flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ vte_terminal_pty_new_sync terminal' flags' maybeCancellable
        checkUnexpectedReturnNULL "terminalPtyNewSync" result
        result' <- (wrapObject Vte.Pty.Pty) result
        touchManagedPtr terminal
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

data TerminalPtyNewSyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (b) -> m Vte.Pty.Pty), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalPtyNewSyncMethodInfo a signature where
    overloadedMethod _ = terminalPtyNewSync

-- method Terminal::reset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clear_tabstops", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to reset tabstops", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clear_history", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to empty the terminal's scrollback buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_reset" vte_terminal_reset :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- clear_tabstops : TBasicType TBoolean
    CInt ->                                 -- clear_history : TBasicType TBoolean
    IO ()

{- |
Resets as much of the terminal\'s internal state as possible, discarding any
unprocessed input data, resetting character attributes, cursor state,
national character set state, status line, terminal modes (insert\/delete),
selection state, and encoding.
-}
terminalReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@clearTabstops@/: whether to reset tabstops -}
    -> Bool
    {- ^ /@clearHistory@/: whether to empty the terminal\'s scrollback buffer -}
    -> m ()
terminalReset terminal clearTabstops clearHistory = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let clearTabstops' = (fromIntegral . fromEnum) clearTabstops
    let clearHistory' = (fromIntegral . fromEnum) clearHistory
    vte_terminal_reset terminal' clearTabstops' clearHistory'
    touchManagedPtr terminal
    return ()

data TerminalResetMethodInfo
instance (signature ~ (Bool -> Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalResetMethodInfo a signature where
    overloadedMethod _ = terminalReset

-- method Terminal::search_find_next
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_search_find_next" vte_terminal_search_find_next :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Searches the next string matching the search regex set with
'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
-}
terminalSearchFindNext ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a match was found -}
terminalSearchFindNext terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_search_find_next terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalSearchFindNextMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindNextMethodInfo a signature where
    overloadedMethod _ = terminalSearchFindNext

-- method Terminal::search_find_previous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_search_find_previous" vte_terminal_search_find_previous :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Searches the previous string matching the search regex set with
'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
-}
terminalSearchFindPrevious ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if a match was found -}
terminalSearchFindPrevious terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_search_find_previous terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalSearchFindPreviousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchFindPreviousMethodInfo a signature where
    overloadedMethod _ = terminalSearchFindPrevious

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

foreign import ccall "vte_terminal_search_get_gregex" vte_terminal_search_get_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr GLib.Regex.Regex)

{-# DEPRECATED terminalSearchGetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchGetRegex' instead."] #-}
{- |
/No description available in the introspection data./
-}
terminalSearchGetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m GLib.Regex.Regex
    {- ^ __Returns:__ 'Nothing' -}
terminalSearchGetGregex terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_search_get_gregex terminal'
    checkUnexpectedReturnNULL "terminalSearchGetGregex" result
    result' <- (newBoxed GLib.Regex.Regex) result
    touchManagedPtr terminal
    return result'

data TerminalSearchGetGregexMethodInfo
instance (signature ~ (m GLib.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetGregexMethodInfo a signature where
    overloadedMethod _ = terminalSearchGetGregex

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

foreign import ccall "vte_terminal_search_get_regex" vte_terminal_search_get_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO (Ptr Vte.Regex.Regex)

{- |
/No description available in the introspection data./

@since 0.46
-}
terminalSearchGetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Vte.Regex.Regex
    {- ^ __Returns:__ the search 'GI.Vte.Structs.Regex.Regex' regex set in /@terminal@/, or 'Nothing' -}
terminalSearchGetRegex terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_search_get_regex terminal'
    checkUnexpectedReturnNULL "terminalSearchGetRegex" result
    result' <- (newBoxed Vte.Regex.Regex) result
    touchManagedPtr terminal
    return result'

data TerminalSearchGetRegexMethodInfo
instance (signature ~ (m Vte.Regex.Regex), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetRegexMethodInfo a signature where
    overloadedMethod _ = terminalSearchGetRegex

-- method Terminal::search_get_wrap_around
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", 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 "vte_terminal_search_get_wrap_around" vte_terminal_search_get_wrap_around :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
/No description available in the introspection data./
-}
terminalSearchGetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ whether searching will wrap around -}
terminalSearchGetWrapAround terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_search_get_wrap_around terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

data TerminalSearchGetWrapAroundMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchGetWrapAroundMethodInfo a signature where
    overloadedMethod _ = terminalSearchGetWrapAround

-- method Terminal::search_set_gregex
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gregex", argType = TInterface (Name {namespace = "GLib", name = "Regex"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GRegex, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gflags", argType = TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #GRegexMatchFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_gregex" vte_terminal_search_set_gregex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr GLib.Regex.Regex ->                 -- gregex : TInterface (Name {namespace = "GLib", name = "Regex"})
    CUInt ->                                -- gflags : TInterface (Name {namespace = "GLib", name = "RegexMatchFlags"})
    IO ()

{-# DEPRECATED terminalSearchSetGregex ["(Since version 0.46)","use 'GI.Vte.Objects.Terminal.terminalSearchSetRegex' instead."] #-}
{- |
Sets the 'GI.GLib.Structs.Regex.Regex' regex to search for. Unsets the search regex when passed 'Nothing'.
-}
terminalSearchSetGregex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (GLib.Regex.Regex)
    {- ^ /@gregex@/: a 'GI.GLib.Structs.Regex.Regex', or 'Nothing' -}
    -> [GLib.Flags.RegexMatchFlags]
    {- ^ /@gflags@/: flags from 'GI.GLib.Flags.RegexMatchFlags' -}
    -> m ()
terminalSearchSetGregex terminal gregex gflags = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeGregex <- case gregex of
        Nothing -> return nullPtr
        Just jGregex -> do
            jGregex' <- unsafeManagedPtrGetPtr jGregex
            return jGregex'
    let gflags' = gflagsToWord gflags
    vte_terminal_search_set_gregex terminal' maybeGregex gflags'
    touchManagedPtr terminal
    whenJust gregex touchManagedPtr
    return ()

data TerminalSearchSetGregexMethodInfo
instance (signature ~ (Maybe (GLib.Regex.Regex) -> [GLib.Flags.RegexMatchFlags] -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetGregexMethodInfo a signature where
    overloadedMethod _ = terminalSearchSetGregex

-- method Terminal::search_set_regex
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "regex", argType = TInterface (Name {namespace = "Vte", name = "Regex"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #VteRegex, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "PCRE2 match flags, or 0", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_regex" vte_terminal_search_set_regex :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Regex.Regex ->                  -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
    Word32 ->                               -- flags : TBasicType TUInt32
    IO ()

{- |
Sets the regex to search for. Unsets the search regex when passed 'Nothing'.

@since 0.46
-}
terminalSearchSetRegex ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Vte.Regex.Regex)
    {- ^ /@regex@/: a 'GI.Vte.Structs.Regex.Regex', or 'Nothing' -}
    -> Word32
    {- ^ /@flags@/: PCRE2 match flags, or 0 -}
    -> m ()
terminalSearchSetRegex terminal regex flags = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeRegex <- case regex of
        Nothing -> return nullPtr
        Just jRegex -> do
            jRegex' <- unsafeManagedPtrGetPtr jRegex
            return jRegex'
    vte_terminal_search_set_regex terminal' maybeRegex flags
    touchManagedPtr terminal
    whenJust regex touchManagedPtr
    return ()

data TerminalSearchSetRegexMethodInfo
instance (signature ~ (Maybe (Vte.Regex.Regex) -> Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetRegexMethodInfo a signature where
    overloadedMethod _ = terminalSearchSetRegex

-- method Terminal::search_set_wrap_around
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_around", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether search should wrap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_search_set_wrap_around" vte_terminal_search_set_wrap_around :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- wrap_around : TBasicType TBoolean
    IO ()

{- |
Sets whether search should wrap around to the beginning of the
terminal content when reaching its end.
-}
terminalSearchSetWrapAround ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@wrapAround@/: whether search should wrap -}
    -> m ()
terminalSearchSetWrapAround terminal wrapAround = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let wrapAround' = (fromIntegral . fromEnum) wrapAround
    vte_terminal_search_set_wrap_around terminal' wrapAround'
    touchManagedPtr terminal
    return ()

data TerminalSearchSetWrapAroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSearchSetWrapAroundMethodInfo a signature where
    overloadedMethod _ = terminalSearchSetWrapAround

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

foreign import ccall "vte_terminal_select_all" vte_terminal_select_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Selects all text within the terminal (including the scrollback buffer).
-}
terminalSelectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalSelectAll terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_select_all terminal'
    touchManagedPtr terminal
    return ()

data TerminalSelectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSelectAllMethodInfo a signature where
    overloadedMethod _ = terminalSelectAll

-- method Terminal::set_allow_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allow_bold", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should attempt to draw bold text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_allow_bold" vte_terminal_set_allow_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- allow_bold : TBasicType TBoolean
    IO ()

{- |
Controls whether or not the terminal will attempt to draw bold text,
either by using a bold font variant or by repainting text with a different
offset.
-}
terminalSetAllowBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@allowBold@/: 'True' if the terminal should attempt to draw bold text -}
    -> m ()
terminalSetAllowBold terminal allowBold = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let allowBold' = (fromIntegral . fromEnum) allowBold
    vte_terminal_set_allow_bold terminal' allowBold'
    touchManagedPtr terminal
    return ()

data TerminalSetAllowBoldMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowBoldMethodInfo a signature where
    overloadedMethod _ = terminalSetAllowBold

-- method Terminal::set_audible_bell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_audible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should beep", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_audible_bell" vte_terminal_set_audible_bell :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- is_audible : TBasicType TBoolean
    IO ()

{- |
Controls whether or not the terminal will beep when the child outputs the
\"bl\" sequence.
-}
terminalSetAudibleBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@isAudible@/: 'True' if the terminal should beep -}
    -> m ()
terminalSetAudibleBell terminal isAudible = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let isAudible' = (fromIntegral . fromEnum) isAudible
    vte_terminal_set_audible_bell terminal' isAudible'
    touchManagedPtr terminal
    return ()

data TerminalSetAudibleBellMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAudibleBellMethodInfo a signature where
    overloadedMethod _ = terminalSetAudibleBell

-- method Terminal::set_backspace_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Vte", name = "EraseBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteEraseBinding for the backspace key", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_backspace_binding" vte_terminal_set_backspace_binding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})
    IO ()

{- |
Modifies the terminal\'s backspace key binding, which controls what
string or control sequence the terminal sends to its child when the user
presses the backspace key.
-}
terminalSetBackspaceBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.EraseBinding
    {- ^ /@binding@/: a 'GI.Vte.Enums.EraseBinding' for the backspace key -}
    -> m ()
terminalSetBackspaceBinding terminal binding = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let binding' = (fromIntegral . fromEnum) binding
    vte_terminal_set_backspace_binding terminal' binding'
    touchManagedPtr terminal
    return ()

data TerminalSetBackspaceBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBackspaceBindingMethodInfo a signature where
    overloadedMethod _ = terminalSetBackspaceBinding

-- method Terminal::set_cjk_ambiguous_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "either 1 (narrow) or 2 (wide)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cjk_ambiguous_width" vte_terminal_set_cjk_ambiguous_width :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- width : TBasicType TInt
    IO ()

{- |
This setting controls whether ambiguous-width characters are narrow or wide
when using the UTF-8 encoding ('GI.Vte.Objects.Terminal.terminalSetEncoding'). In all other encodings,
the width of ambiguous-width characters is fixed.
-}
terminalSetCjkAmbiguousWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@width@/: either 1 (narrow) or 2 (wide) -}
    -> m ()
terminalSetCjkAmbiguousWidth terminal width = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_set_cjk_ambiguous_width terminal' width
    touchManagedPtr terminal
    return ()

data TerminalSetCjkAmbiguousWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCjkAmbiguousWidthMethodInfo a signature where
    overloadedMethod _ = terminalSetCjkAmbiguousWidth

-- method Terminal::set_color_background
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_background" vte_terminal_set_color_background :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the background color for text which does not have a specific background
color assigned.  Only has effect when no background image is set and when
the terminal is not transparent.
-}
terminalSetColorBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Gdk.RGBA.RGBA
    {- ^ /@background@/: the new background color -}
    -> m ()
terminalSetColorBackground terminal background = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    background' <- unsafeManagedPtrGetPtr background
    vte_terminal_set_color_background terminal' background'
    touchManagedPtr terminal
    touchManagedPtr background
    return ()

data TerminalSetColorBackgroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBackgroundMethodInfo a signature where
    overloadedMethod _ = terminalSetColorBackground

-- method Terminal::set_color_bold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bold", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new bold color or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_bold" vte_terminal_set_color_bold :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- bold : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the color used to draw bold text in the default foreground color.
If /@bold@/ is 'Nothing' then the default color is used.
-}
terminalSetColorBold ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@bold@/: the new bold color or 'Nothing' -}
    -> m ()
terminalSetColorBold terminal bold = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeBold <- case bold of
        Nothing -> return nullPtr
        Just jBold -> do
            jBold' <- unsafeManagedPtrGetPtr jBold
            return jBold'
    vte_terminal_set_color_bold terminal' maybeBold
    touchManagedPtr terminal
    whenJust bold touchManagedPtr
    return ()

data TerminalSetColorBoldMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorBoldMethodInfo a signature where
    overloadedMethod _ = terminalSetColorBold

-- method Terminal::set_color_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for the text cursor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_cursor" vte_terminal_set_color_cursor :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- cursor_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the background color for text which is under the cursor.  If 'Nothing', text
under the cursor will be drawn with foreground and background colors
reversed.
-}
terminalSetColorCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@cursorBackground@/: the new color to use for the text cursor, or 'Nothing' -}
    -> m ()
terminalSetColorCursor terminal cursorBackground = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeCursorBackground <- case cursorBackground of
        Nothing -> return nullPtr
        Just jCursorBackground -> do
            jCursorBackground' <- unsafeManagedPtrGetPtr jCursorBackground
            return jCursorBackground'
    vte_terminal_set_color_cursor terminal' maybeCursorBackground
    touchManagedPtr terminal
    whenJust cursorBackground touchManagedPtr
    return ()

data TerminalSetColorCursorMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorMethodInfo a signature where
    overloadedMethod _ = terminalSetColorCursor

-- method Terminal::set_color_cursor_foreground
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor_foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for the text cursor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_cursor_foreground" vte_terminal_set_color_cursor_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- cursor_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the foreground color for text which is under the cursor.  If 'Nothing', text
under the cursor will be drawn with foreground and background colors
reversed.

@since 0.44
-}
terminalSetColorCursorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@cursorForeground@/: the new color to use for the text cursor, or 'Nothing' -}
    -> m ()
terminalSetColorCursorForeground terminal cursorForeground = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeCursorForeground <- case cursorForeground of
        Nothing -> return nullPtr
        Just jCursorForeground -> do
            jCursorForeground' <- unsafeManagedPtrGetPtr jCursorForeground
            return jCursorForeground'
    vte_terminal_set_color_cursor_foreground terminal' maybeCursorForeground
    touchManagedPtr terminal
    whenJust cursorForeground touchManagedPtr
    return ()

data TerminalSetColorCursorForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorCursorForegroundMethodInfo a signature where
    overloadedMethod _ = terminalSetColorCursorForeground

-- method Terminal::set_color_foreground
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new foreground color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_foreground" vte_terminal_set_color_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the foreground color used to draw normal text.
-}
terminalSetColorForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Gdk.RGBA.RGBA
    {- ^ /@foreground@/: the new foreground color -}
    -> m ()
terminalSetColorForeground terminal foreground = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    foreground' <- unsafeManagedPtrGetPtr foreground
    vte_terminal_set_color_foreground terminal' foreground'
    touchManagedPtr terminal
    touchManagedPtr foreground
    return ()

data TerminalSetColorForegroundMethodInfo
instance (signature ~ (Gdk.RGBA.RGBA -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorForegroundMethodInfo a signature where
    overloadedMethod _ = terminalSetColorForeground

-- method Terminal::set_color_highlight
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight_background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for highlighted text, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight" vte_terminal_set_color_highlight :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- highlight_background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the background color for text which is highlighted.  If 'Nothing',
it is unset.  If neither highlight background nor highlight foreground are set,
highlighted text (which is usually highlighted because it is selected) will
be drawn with foreground and background colors reversed.
-}
terminalSetColorHighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@highlightBackground@/: the new color to use for highlighted text, or 'Nothing' -}
    -> m ()
terminalSetColorHighlight terminal highlightBackground = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeHighlightBackground <- case highlightBackground of
        Nothing -> return nullPtr
        Just jHighlightBackground -> do
            jHighlightBackground' <- unsafeManagedPtrGetPtr jHighlightBackground
            return jHighlightBackground'
    vte_terminal_set_color_highlight terminal' maybeHighlightBackground
    touchManagedPtr terminal
    whenJust highlightBackground touchManagedPtr
    return ()

data TerminalSetColorHighlightMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightMethodInfo a signature where
    overloadedMethod _ = terminalSetColorHighlight

-- method Terminal::set_color_highlight_foreground
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "highlight_foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color to use for highlighted text, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_color_highlight_foreground" vte_terminal_set_color_highlight_foreground :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- highlight_foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{- |
Sets the foreground color for text which is highlighted.  If 'Nothing',
it is unset.  If neither highlight background nor highlight foreground are set,
highlighted text (which is usually highlighted because it is selected) will
be drawn with foreground and background colors reversed.
-}
terminalSetColorHighlightForeground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@highlightForeground@/: the new color to use for highlighted text, or 'Nothing' -}
    -> m ()
terminalSetColorHighlightForeground terminal highlightForeground = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeHighlightForeground <- case highlightForeground of
        Nothing -> return nullPtr
        Just jHighlightForeground -> do
            jHighlightForeground' <- unsafeManagedPtrGetPtr jHighlightForeground
            return jHighlightForeground'
    vte_terminal_set_color_highlight_foreground terminal' maybeHighlightForeground
    touchManagedPtr terminal
    whenJust highlightForeground touchManagedPtr
    return ()

data TerminalSetColorHighlightForegroundMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorHighlightForegroundMethodInfo a signature where
    overloadedMethod _ = terminalSetColorHighlightForeground

-- method Terminal::set_colors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreground", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new foreground color, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new background color, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "palette", argType = TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "palette_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @palette", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_colors" vte_terminal_set_colors :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gdk.RGBA.RGBA ->                    -- foreground : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- background : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- palette : TCArray False (-1) 4 (TInterface (Name {namespace = "Gdk", name = "RGBA"}))
    Word64 ->                               -- palette_size : TBasicType TUInt64
    IO ()

{- |
/@palette@/ specifies the new values for the 256 palette colors: 8 standard colors,
their 8 bright counterparts, 6x6x6 color cube, and 24 grayscale colors.
Omitted entries will default to a hardcoded value.

/@paletteSize@/ must be 0, 8, 16, 232 or 256.

If /@foreground@/ is 'Nothing' and /@paletteSize@/ is greater than 0, the new foreground
color is taken from /@palette@/[7].  If /@background@/ is 'Nothing' and /@paletteSize@/ is
greater than 0, the new background color is taken from /@palette@/[0].
-}
terminalSetColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@foreground@/: the new foreground color, or 'Nothing' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@background@/: the new background color, or 'Nothing' -}
    -> Maybe ([Gdk.RGBA.RGBA])
    {- ^ /@palette@/: the color palette -}
    -> m ()
terminalSetColors terminal foreground background palette = liftIO $ do
    let paletteSize = case palette of
            Nothing -> 0
            Just jPalette -> fromIntegral $ length jPalette
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeForeground <- case foreground of
        Nothing -> return nullPtr
        Just jForeground -> do
            jForeground' <- unsafeManagedPtrGetPtr jForeground
            return jForeground'
    maybeBackground <- case background of
        Nothing -> return nullPtr
        Just jBackground -> do
            jBackground' <- unsafeManagedPtrGetPtr jBackground
            return jBackground'
    maybePalette <- case palette of
        Nothing -> return nullPtr
        Just jPalette -> do
            jPalette' <- mapM unsafeManagedPtrGetPtr jPalette
            jPalette'' <- packBlockArray 32 jPalette'
            return jPalette''
    vte_terminal_set_colors terminal' maybeForeground maybeBackground maybePalette paletteSize
    touchManagedPtr terminal
    whenJust foreground touchManagedPtr
    whenJust background touchManagedPtr
    whenJust palette (mapM_ touchManagedPtr)
    freeMem maybePalette
    return ()

data TerminalSetColorsMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> Maybe (Gdk.RGBA.RGBA) -> Maybe ([Gdk.RGBA.RGBA]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetColorsMethodInfo a signature where
    overloadedMethod _ = terminalSetColors

-- method Terminal::set_cursor_blink_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteCursorBlinkMode to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_blink_mode" vte_terminal_set_cursor_blink_mode :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Vte", name = "CursorBlinkMode"})
    IO ()

{- |
Sets whether or not the cursor will blink. Using 'GI.Vte.Enums.CursorBlinkModeSystem'
will use the 'GI.Gtk.Objects.Settings.Settings'::@/gtk-cursor-blink/@ setting.
-}
terminalSetCursorBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.CursorBlinkMode
    {- ^ /@mode@/: the 'GI.Vte.Enums.CursorBlinkMode' to use -}
    -> m ()
terminalSetCursorBlinkMode terminal mode = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let mode' = (fromIntegral . fromEnum) mode
    vte_terminal_set_cursor_blink_mode terminal' mode'
    touchManagedPtr terminal
    return ()

data TerminalSetCursorBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.CursorBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorBlinkModeMethodInfo a signature where
    overloadedMethod _ = terminalSetCursorBlinkMode

-- method Terminal::set_cursor_shape
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shape", argType = TInterface (Name {namespace = "Vte", name = "CursorShape"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteCursorShape to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_cursor_shape" vte_terminal_set_cursor_shape :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- shape : TInterface (Name {namespace = "Vte", name = "CursorShape"})
    IO ()

{- |
Sets the shape of the cursor drawn.
-}
terminalSetCursorShape ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.CursorShape
    {- ^ /@shape@/: the 'GI.Vte.Enums.CursorShape' to use -}
    -> m ()
terminalSetCursorShape terminal shape = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let shape' = (fromIntegral . fromEnum) shape
    vte_terminal_set_cursor_shape terminal' shape'
    touchManagedPtr terminal
    return ()

data TerminalSetCursorShapeMethodInfo
instance (signature ~ (Vte.Enums.CursorShape -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCursorShapeMethodInfo a signature where
    overloadedMethod _ = terminalSetCursorShape

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

foreign import ccall "vte_terminal_set_default_colors" vte_terminal_set_default_colors :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Reset the terminal palette to reasonable compiled-in default color.
-}
terminalSetDefaultColors ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalSetDefaultColors terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_set_default_colors terminal'
    touchManagedPtr terminal
    return ()

data TerminalSetDefaultColorsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDefaultColorsMethodInfo a signature where
    overloadedMethod _ = terminalSetDefaultColors

-- method Terminal::set_delete_binding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface (Name {namespace = "Vte", name = "EraseBinding"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteEraseBinding for the delete key", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_delete_binding" vte_terminal_set_delete_binding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- binding : TInterface (Name {namespace = "Vte", name = "EraseBinding"})
    IO ()

{- |
Modifies the terminal\'s delete key binding, which controls what
string or control sequence the terminal sends to its child when the user
presses the delete key.
-}
terminalSetDeleteBinding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.EraseBinding
    {- ^ /@binding@/: a 'GI.Vte.Enums.EraseBinding' for the delete key -}
    -> m ()
terminalSetDeleteBinding terminal binding = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let binding' = (fromIntegral . fromEnum) binding
    vte_terminal_set_delete_binding terminal' binding'
    touchManagedPtr terminal
    return ()

data TerminalSetDeleteBindingMethodInfo
instance (signature ~ (Vte.Enums.EraseBinding -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetDeleteBindingMethodInfo a signature where
    overloadedMethod _ = terminalSetDeleteBinding

-- method Terminal::set_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "codeset", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a valid #GIConv target, or %NULL to use UTF-8", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_set_encoding" vte_terminal_set_encoding :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- codeset : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Changes the encoding the terminal will expect data from the child to
be encoded with.  For certain terminal types, applications executing in the
terminal can change the encoding. If /@codeset@/ is 'Nothing', it uses \"UTF-8\".
-}
terminalSetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (T.Text)
    {- ^ /@codeset@/: a valid 'GI.GLib.Structs.IConv.IConv' target, or 'Nothing' to use UTF-8 -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
terminalSetEncoding terminal codeset = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeCodeset <- case codeset of
        Nothing -> return nullPtr
        Just jCodeset -> do
            jCodeset' <- textToCString jCodeset
            return jCodeset'
    onException (do
        _ <- propagateGError $ vte_terminal_set_encoding terminal' maybeCodeset
        touchManagedPtr terminal
        freeMem maybeCodeset
        return ()
     ) (do
        freeMem maybeCodeset
     )

data TerminalSetEncodingMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetEncodingMethodInfo a signature where
    overloadedMethod _ = terminalSetEncoding

-- method Terminal::set_font
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_desc", argType = TInterface (Name {namespace = "Pango", name = "FontDescription"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PangoFontDescription for the desired font, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font" vte_terminal_set_font :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

{- |
Sets the font used for rendering all text displayed by the terminal,
overriding any fonts set using 'GI.Gtk.Objects.Widget.widgetModifyFont'.  The terminal
will immediately attempt to load the desired font, retrieve its
metrics, and attempt to resize itself to keep the same number of rows
and columns.  The font scale is applied to the specified font.
-}
terminalSetFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (Pango.FontDescription.FontDescription)
    {- ^ /@fontDesc@/: a 'GI.Pango.Structs.FontDescription.FontDescription' for the desired font, or 'Nothing' -}
    -> m ()
terminalSetFont terminal fontDesc = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeFontDesc <- case fontDesc of
        Nothing -> return nullPtr
        Just jFontDesc -> do
            jFontDesc' <- unsafeManagedPtrGetPtr jFontDesc
            return jFontDesc'
    vte_terminal_set_font terminal' maybeFontDesc
    touchManagedPtr terminal
    whenJust fontDesc touchManagedPtr
    return ()

data TerminalSetFontMethodInfo
instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontMethodInfo a signature where
    overloadedMethod _ = terminalSetFont

-- method Terminal::set_font_scale
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the font scale", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_font_scale" vte_terminal_set_font_scale :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

{- |
Sets the terminal\'s font scale to /@scale@/.
-}
terminalSetFontScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Double
    {- ^ /@scale@/: the font scale -}
    -> m ()
terminalSetFontScale terminal scale = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let scale' = realToFrac scale
    vte_terminal_set_font_scale terminal' scale'
    touchManagedPtr terminal
    return ()

data TerminalSetFontScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetFontScaleMethodInfo a signature where
    overloadedMethod _ = terminalSetFontScale

-- method Terminal::set_geometry_hints_for_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gtk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_geometry_hints_for_window" vte_terminal_set_geometry_hints_for_window :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gtk.Window.Window ->                -- window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

{- |
Sets /@terminal@/ as /@window@/\'s geometry widget. See
'GI.Gtk.Objects.Window.windowSetGeometryHints' for more information.

/@terminal@/ must be realized (see 'GI.Gtk.Objects.Widget.widgetGetRealized').
-}
terminalSetGeometryHintsForWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> b
    {- ^ /@window@/: a 'GI.Gtk.Objects.Window.Window' -}
    -> m ()
terminalSetGeometryHintsForWindow terminal window = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    window' <- unsafeManagedPtrCastPtr window
    vte_terminal_set_geometry_hints_for_window terminal' window'
    touchManagedPtr terminal
    touchManagedPtr window
    return ()

data TerminalSetGeometryHintsForWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTerminal a, Gtk.Window.IsWindow b) => O.MethodInfo TerminalSetGeometryHintsForWindowMethodInfo a signature where
    overloadedMethod _ = terminalSetGeometryHintsForWindow

-- method Terminal::set_input_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable user input", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_input_enabled" vte_terminal_set_input_enabled :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Enables or disables user input. When user input is disabled,
the terminal\'s child will not receive any key press, or mouse button
press or motion events sent to it.
-}
terminalSetInputEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@enabled@/: whether to enable user input -}
    -> m ()
terminalSetInputEnabled terminal enabled = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let enabled' = (fromIntegral . fromEnum) enabled
    vte_terminal_set_input_enabled terminal' enabled'
    touchManagedPtr terminal
    return ()

data TerminalSetInputEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetInputEnabledMethodInfo a signature where
    overloadedMethod _ = terminalSetInputEnabled

-- method Terminal::set_mouse_autohide
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the mouse pointer should autohide", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_mouse_autohide" vte_terminal_set_mouse_autohide :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Changes the value of the terminal\'s mouse autohide setting.  When autohiding
is enabled, the mouse cursor will be hidden when the user presses a key and
shown when the user moves the mouse.  This setting can be read using
'GI.Vte.Objects.Terminal.terminalGetMouseAutohide'.
-}
terminalSetMouseAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@setting@/: whether the mouse pointer should autohide -}
    -> m ()
terminalSetMouseAutohide terminal setting = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let setting' = (fromIntegral . fromEnum) setting
    vte_terminal_set_mouse_autohide terminal' setting'
    touchManagedPtr terminal
    return ()

data TerminalSetMouseAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetMouseAutohideMethodInfo a signature where
    overloadedMethod _ = terminalSetMouseAutohide

-- method Terminal::set_pty
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pty", argType = TInterface (Name {namespace = "Vte", name = "Pty"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #VtePty, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_pty" vte_terminal_set_pty :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Vte.Pty.Pty ->                      -- pty : TInterface (Name {namespace = "Vte", name = "Pty"})
    IO ()

{- |
Sets /@pty@/ as the PTY to use in /@terminal@/.
Use 'Nothing' to unset the PTY.
-}
terminalSetPty ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Vte.Pty.IsPty b) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Maybe (b)
    {- ^ /@pty@/: a 'GI.Vte.Objects.Pty.Pty', or 'Nothing' -}
    -> m ()
terminalSetPty terminal pty = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybePty <- case pty of
        Nothing -> return nullPtr
        Just jPty -> do
            jPty' <- unsafeManagedPtrCastPtr jPty
            return jPty'
    vte_terminal_set_pty terminal' maybePty
    touchManagedPtr terminal
    whenJust pty touchManagedPtr
    return ()

data TerminalSetPtyMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Vte.Pty.IsPty b) => O.MethodInfo TerminalSetPtyMethodInfo a signature where
    overloadedMethod _ = terminalSetPty

-- method Terminal::set_rewrap_on_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rewrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should rewrap on resize", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_rewrap_on_resize" vte_terminal_set_rewrap_on_resize :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- rewrap : TBasicType TBoolean
    IO ()

{- |
Controls whether or not the terminal will rewrap its contents, including
the scrollback history, whenever the terminal\'s width changes.
-}
terminalSetRewrapOnResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@rewrap@/: 'True' if the terminal should rewrap on resize -}
    -> m ()
terminalSetRewrapOnResize terminal rewrap = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let rewrap' = (fromIntegral . fromEnum) rewrap
    vte_terminal_set_rewrap_on_resize terminal' rewrap'
    touchManagedPtr terminal
    return ()

data TerminalSetRewrapOnResizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetRewrapOnResizeMethodInfo a signature where
    overloadedMethod _ = terminalSetRewrapOnResize

-- method Terminal::set_scroll_on_keystroke
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the terminal should scroll on keystrokes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_keystroke" vte_terminal_set_scroll_on_keystroke :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()

{- |
Controls whether or not the terminal will forcibly scroll to the bottom of
the viewable history when the user presses a key.  Modifier keys do not
trigger this behavior.
-}
terminalSetScrollOnKeystroke ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@scroll@/: whether the terminal should scroll on keystrokes -}
    -> m ()
terminalSetScrollOnKeystroke terminal scroll = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let scroll' = (fromIntegral . fromEnum) scroll
    vte_terminal_set_scroll_on_keystroke terminal' scroll'
    touchManagedPtr terminal
    return ()

data TerminalSetScrollOnKeystrokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollOnKeystroke

-- method Terminal::set_scroll_on_output
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the terminal should scroll on output", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_on_output" vte_terminal_set_scroll_on_output :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- scroll : TBasicType TBoolean
    IO ()

{- |
Controls whether or not the terminal will forcibly scroll to the bottom of
the viewable history when the new data is received from the child.
-}
terminalSetScrollOnOutput ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@scroll@/: whether the terminal should scroll on output -}
    -> m ()
terminalSetScrollOnOutput terminal scroll = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let scroll' = (fromIntegral . fromEnum) scroll
    vte_terminal_set_scroll_on_output terminal' scroll'
    touchManagedPtr terminal
    return ()

data TerminalSetScrollOnOutputMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnOutputMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollOnOutput

-- method Terminal::set_scroll_speed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll_speed", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "move the buffer by this number of lines while scrolling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scroll_speed" vte_terminal_set_scroll_speed :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Word32 ->                               -- scroll_speed : TBasicType TUInt
    IO ()

{- |
Sets the number of lines by which the buffer is moved when
scrolling with a mouse wheel. Setting it to zero will cause the
buffer to be moved by an amount depending on the number of visible
rows the widget can display.
-}
terminalSetScrollSpeed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Word32
    {- ^ /@scrollSpeed@/: move the buffer by this number of lines while scrolling -}
    -> m ()
terminalSetScrollSpeed terminal scrollSpeed = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_set_scroll_speed terminal' scrollSpeed
    touchManagedPtr terminal
    return ()

data TerminalSetScrollSpeedMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollSpeedMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollSpeed

-- method Terminal::set_scrollback_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of the history buffer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_scrollback_lines" vte_terminal_set_scrollback_lines :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- lines : TBasicType TLong
    IO ()

{- |
Sets the length of the scrollback buffer used by the terminal.  The size of
the scrollback buffer will be set to the larger of this value and the number
of visible rows the widget can display, so 0 can safely be used to disable
scrollback.

A negative value means \"infinite scrollback\".

Note that this setting only affects the normal screen buffer.
No scrollback is allowed on the alternate screen buffer.
-}
terminalSetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> CLong
    {- ^ /@lines@/: the length of the history buffer -}
    -> m ()
terminalSetScrollbackLines terminal lines = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_set_scrollback_lines terminal' lines
    touchManagedPtr terminal
    return ()

data TerminalSetScrollbackLinesMethodInfo
instance (signature ~ (CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollbackLinesMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollbackLines

-- method Terminal::set_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "columns", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of columns", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of rows", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_size" vte_terminal_set_size :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CLong ->                                -- columns : TBasicType TLong
    CLong ->                                -- rows : TBasicType TLong
    IO ()

{- |
Attempts to change the terminal\'s size in terms of rows and columns.  If
the attempt succeeds, the widget will resize itself to the proper size.
-}
terminalSetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> CLong
    {- ^ /@columns@/: the desired number of columns -}
    -> CLong
    {- ^ /@rows@/: the desired number of rows -}
    -> m ()
terminalSetSize terminal columns rows = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_set_size terminal' columns rows
    touchManagedPtr terminal
    return ()

data TerminalSetSizeMethodInfo
instance (signature ~ (CLong -> CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetSizeMethodInfo a signature where
    overloadedMethod _ = terminalSetSize

-- method Terminal::set_word_char_exceptions
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "exceptions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string of ASCII punctuation characters, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_set_word_char_exceptions" vte_terminal_set_word_char_exceptions :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CString ->                              -- exceptions : TBasicType TUTF8
    IO ()

{- |
With this function you can provide a set of characters which will
be considered parts of a word when doing word-wise selection, in
addition to the default which only considers alphanumeric characters
part of a word.

The characters in /@exceptions@/ must be non-alphanumeric, each character
must occur only once, and if /@exceptions@/ contains the character
U+002D HYPHEN-MINUS, it must be at the start of the string.

Use 'Nothing' to reset the set of exception characters to the default.

@since 0.40
-}
terminalSetWordCharExceptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> T.Text
    {- ^ /@exceptions@/: a string of ASCII punctuation characters, or 'Nothing' -}
    -> m ()
terminalSetWordCharExceptions terminal exceptions = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    exceptions' <- textToCString exceptions
    vte_terminal_set_word_char_exceptions terminal' exceptions'
    touchManagedPtr terminal
    freeMem exceptions'
    return ()

data TerminalSetWordCharExceptionsMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetWordCharExceptionsMethodInfo a signature where
    overloadedMethod _ = terminalSetWordCharExceptions

-- method Terminal::spawn_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pty_flags", argType = TInterface (Name {namespace = "Vte", name = "PtyFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #VtePtyFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "working_directory", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of a directory the command should start\n  in, or %NULL to use the current working directory", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "child's argument vector", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "envv", argType = TCArray True (-1) (-1) (TBasicType TFileName), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a list of environment\n  variables to be added to the environment before starting the process, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "spawn_flags", argType = TInterface (Name {namespace = "GLib", name = "SpawnFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags from #GSpawnFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_setup", argType = TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an extra child setup function to run in the child just before exec(), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_setup_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for @child_setup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_pid", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the child PID, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_spawn_sync" vte_terminal_spawn_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- pty_flags : TInterface (Name {namespace = "Vte", name = "PtyFlags"})
    CString ->                              -- working_directory : TBasicType TUTF8
    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TFileName)
    Ptr CString ->                          -- envv : TCArray True (-1) (-1) (TBasicType TFileName)
    CUInt ->                                -- spawn_flags : TInterface (Name {namespace = "GLib", name = "SpawnFlags"})
    FunPtr GLib.Callbacks.C_SpawnChildSetupFunc -> -- child_setup : TInterface (Name {namespace = "GLib", name = "SpawnChildSetupFunc"})
    Ptr () ->                               -- child_setup_data : TBasicType TPtr
    Ptr Int32 ->                            -- child_pid : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Starts the specified command under a newly-allocated controlling
pseudo-terminal.  The /@argv@/ and /@envv@/ lists should be 'Nothing'-terminated.
The \"TERM\" environment variable is automatically set to a default value,
but can be overridden from /@envv@/.
/@ptyFlags@/ controls logging the session to the specified system log files.

Note that 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' will always be added to /@spawnFlags@/.

Note that all open file descriptors will be closed in the child. If you want
to keep some file descriptor open for use in the child process, you need to
use a child setup function that unsets the FD_CLOEXEC flag on that file
descriptor.

See @/vte_pty_new()/@, 'GI.GLib.Functions.spawnAsync' and 'GI.Vte.Objects.Terminal.terminalWatchChild' for more information.
-}
terminalSpawnSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> [Vte.Flags.PtyFlags]
    {- ^ /@ptyFlags@/: flags from 'GI.Vte.Flags.PtyFlags' -}
    -> Maybe (T.Text)
    {- ^ /@workingDirectory@/: the name of a directory the command should start
  in, or 'Nothing' to use the current working directory -}
    -> [[Char]]
    {- ^ /@argv@/: child\'s argument vector -}
    -> Maybe ([[Char]])
    {- ^ /@envv@/: a list of environment
  variables to be added to the environment before starting the process, or 'Nothing' -}
    -> [GLib.Flags.SpawnFlags]
    {- ^ /@spawnFlags@/: flags from 'GI.GLib.Flags.SpawnFlags' -}
    -> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
    {- ^ /@childSetup@/: an extra child setup function to run in the child just before @/exec()/@, or 'Nothing' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m (Int32)
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
terminalSpawnSync terminal ptyFlags workingDirectory argv envv spawnFlags childSetup cancellable = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let ptyFlags' = gflagsToWord ptyFlags
    maybeWorkingDirectory <- case workingDirectory of
        Nothing -> return nullPtr
        Just jWorkingDirectory -> do
            jWorkingDirectory' <- textToCString jWorkingDirectory
            return jWorkingDirectory'
    argv' <- packZeroTerminatedFileNameArray argv
    maybeEnvv <- case envv of
        Nothing -> return nullPtr
        Just jEnvv -> do
            jEnvv' <- packZeroTerminatedFileNameArray jEnvv
            return jEnvv'
    let spawnFlags' = gflagsToWord spawnFlags
    maybeChildSetup <- case childSetup of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jChildSetup -> do
            jChildSetup' <- GLib.Callbacks.mk_SpawnChildSetupFunc (GLib.Callbacks.wrap_SpawnChildSetupFunc Nothing (GLib.Callbacks.drop_closures_SpawnChildSetupFunc jChildSetup))
            return jChildSetup'
    childPid <- allocMem :: IO (Ptr Int32)
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    let childSetupData = nullPtr
    onException (do
        _ <- propagateGError $ vte_terminal_spawn_sync terminal' ptyFlags' maybeWorkingDirectory argv' maybeEnvv spawnFlags' maybeChildSetup childSetupData childPid maybeCancellable
        childPid' <- peek childPid
        safeFreeFunPtr $ castFunPtrToPtr maybeChildSetup
        touchManagedPtr terminal
        whenJust cancellable touchManagedPtr
        freeMem maybeWorkingDirectory
        mapZeroTerminatedCArray freeMem argv'
        freeMem argv'
        mapZeroTerminatedCArray freeMem maybeEnvv
        freeMem maybeEnvv
        freeMem childPid
        return childPid'
     ) (do
        safeFreeFunPtr $ castFunPtrToPtr maybeChildSetup
        freeMem maybeWorkingDirectory
        mapZeroTerminatedCArray freeMem argv'
        freeMem argv'
        mapZeroTerminatedCArray freeMem maybeEnvv
        freeMem maybeEnvv
        freeMem childPid
     )

data TerminalSpawnSyncMethodInfo
instance (signature ~ ([Vte.Flags.PtyFlags] -> Maybe (T.Text) -> [[Char]] -> Maybe ([[Char]]) -> [GLib.Flags.SpawnFlags] -> Maybe (GLib.Callbacks.SpawnChildSetupFunc) -> Maybe (b) -> m (Int32)), MonadIO m, IsTerminal a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TerminalSpawnSyncMethodInfo a signature where
    overloadedMethod _ = terminalSpawnSync

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

foreign import ccall "vte_terminal_unselect_all" vte_terminal_unselect_all :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO ()

{- |
Clears the current selection.
-}
terminalUnselectAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m ()
terminalUnselectAll terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_unselect_all terminal'
    touchManagedPtr terminal
    return ()

data TerminalUnselectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalUnselectAllMethodInfo a signature where
    overloadedMethod _ = terminalUnselectAll

-- method Terminal::watch_child
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_pid", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GPid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "vte_terminal_watch_child" vte_terminal_watch_child :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Int32 ->                                -- child_pid : TBasicType TInt
    IO ()

{- |
Watches /@childPid@/. When the process exists, the 'GI.Vte.Objects.Terminal.Terminal'::@/child-exited/@
signal will be called with the child\'s exit status.

Prior to calling this function, a 'GI.Vte.Objects.Pty.Pty' must have been set in /@terminal@/
using 'GI.Vte.Objects.Terminal.terminalSetPty'.
When the child exits, the terminal\'s 'GI.Vte.Objects.Pty.Pty' will be set to 'Nothing'.

Note: @/g_child_watch_add()/@ or 'GI.GLib.Functions.childWatchAdd' must not have
been called for /@childPid@/, nor a 'GI.GLib.Structs.Source.Source' for it been created with
'GI.GLib.Functions.childWatchSourceNew'.

Note: when using the 'GI.GLib.Functions.spawnAsync' family of functions,
the 'GI.GLib.Flags.SpawnFlagsDoNotReapChild' flag MUST have been passed.
-}
terminalWatchChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Int32
    {- ^ /@childPid@/: a @/GPid/@ -}
    -> m ()
terminalWatchChild terminal childPid = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    vte_terminal_watch_child terminal' childPid
    touchManagedPtr terminal
    return ()

data TerminalWatchChildMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalWatchChildMethodInfo a signature where
    overloadedMethod _ = terminalWatchChild

-- method Terminal::write_contents_sync
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "terminal", argType = TInterface (Name {namespace = "Vte", name = "Terminal"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteTerminal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "OutputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GOutputStream to write to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Vte", name = "WriteFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #VteWriteFlags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "vte_terminal_write_contents_sync" vte_terminal_write_contents_sync :: 
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    Ptr Gio.OutputStream.OutputStream ->    -- stream : TInterface (Name {namespace = "Gio", name = "OutputStream"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Vte", name = "WriteFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Write contents of the current contents of /@terminal@/ (including any
scrollback history) to /@stream@/ according to /@flags@/.

If /@cancellable@/ is not 'Nothing', then the operation can be cancelled by triggering
the cancellable object from another thread. If the operation was cancelled,
the error 'GI.Gio.Enums.IOErrorEnumCancelled' will be returned in /@error@/.

This is a synchronous operation and will make the widget (and input
processing) during the write operation, which may take a long time
depending on scrollback history and /@stream@/ availability for writing.
-}
terminalWriteContentsSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> b
    {- ^ /@stream@/: a 'GI.Gio.Objects.OutputStream.OutputStream' to write to -}
    -> Vte.Enums.WriteFlags
    {- ^ /@flags@/: a set of 'GI.Vte.Enums.WriteFlags' -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' object, or 'Nothing' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
terminalWriteContentsSync terminal stream flags cancellable = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    stream' <- unsafeManagedPtrCastPtr stream
    let flags' = (fromIntegral . fromEnum) flags
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        _ <- propagateGError $ vte_terminal_write_contents_sync terminal' stream' flags' maybeCancellable
        touchManagedPtr terminal
        touchManagedPtr stream
        whenJust cancellable touchManagedPtr
        return ()
     ) (do
        return ()
     )

data TerminalWriteContentsSyncMethodInfo
instance (signature ~ (b -> Vte.Enums.WriteFlags -> Maybe (c) -> m ()), MonadIO m, IsTerminal a, Gio.OutputStream.IsOutputStream b, Gio.Cancellable.IsCancellable c) => O.MethodInfo TerminalWriteContentsSyncMethodInfo a signature where
    overloadedMethod _ = terminalWriteContentsSync