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

/No description available in the introspection data./
-}

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

module GI.Vte.Objects.Terminal
    (
#if ENABLE_OVERLOADING
    TerminalGetTextMethodInfo               ,
#endif
#if ENABLE_OVERLOADING
    TerminalGetTextIncludeTrailingSpacesMethodInfo,
#endif
#if ENABLE_OVERLOADING
    TerminalGetTextRangeMethodInfo          ,
#endif

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


 -- * Methods
-- ** copyClipboard #method:copyClipboard#

#if ENABLE_OVERLOADING
    TerminalCopyClipboardMethodInfo         ,
#endif
    terminalCopyClipboard                   ,


-- ** copyClipboardFormat #method:copyClipboardFormat#

#if ENABLE_OVERLOADING
    TerminalCopyClipboardFormatMethodInfo   ,
#endif
    terminalCopyClipboardFormat             ,


-- ** copyPrimary #method:copyPrimary#

#if ENABLE_OVERLOADING
    TerminalCopyPrimaryMethodInfo           ,
#endif
    terminalCopyPrimary                     ,


-- ** feed #method:feed#

#if ENABLE_OVERLOADING
    TerminalFeedMethodInfo                  ,
#endif
    terminalFeed                            ,


-- ** feedChild #method:feedChild#

#if ENABLE_OVERLOADING
    TerminalFeedChildMethodInfo             ,
#endif
    terminalFeedChild                       ,


-- ** feedChildBinary #method:feedChildBinary#

#if ENABLE_OVERLOADING
    TerminalFeedChildBinaryMethodInfo       ,
#endif
    terminalFeedChildBinary                 ,


-- ** getAllowBold #method:getAllowBold#

#if ENABLE_OVERLOADING
    TerminalGetAllowBoldMethodInfo          ,
#endif
    terminalGetAllowBold                    ,


-- ** getAllowHyperlink #method:getAllowHyperlink#

#if ENABLE_OVERLOADING
    TerminalGetAllowHyperlinkMethodInfo     ,
#endif
    terminalGetAllowHyperlink               ,


-- ** getAudibleBell #method:getAudibleBell#

#if ENABLE_OVERLOADING
    TerminalGetAudibleBellMethodInfo        ,
#endif
    terminalGetAudibleBell                  ,


-- ** getBoldIsBright #method:getBoldIsBright#

#if ENABLE_OVERLOADING
    TerminalGetBoldIsBrightMethodInfo       ,
#endif
    terminalGetBoldIsBright                 ,


-- ** getCellHeightScale #method:getCellHeightScale#

#if ENABLE_OVERLOADING
    TerminalGetCellHeightScaleMethodInfo    ,
#endif
    terminalGetCellHeightScale              ,


-- ** getCellWidthScale #method:getCellWidthScale#

#if ENABLE_OVERLOADING
    TerminalGetCellWidthScaleMethodInfo     ,
#endif
    terminalGetCellWidthScale               ,


-- ** getCharHeight #method:getCharHeight#

#if ENABLE_OVERLOADING
    TerminalGetCharHeightMethodInfo         ,
#endif
    terminalGetCharHeight                   ,


-- ** getCharWidth #method:getCharWidth#

#if ENABLE_OVERLOADING
    TerminalGetCharWidthMethodInfo          ,
#endif
    terminalGetCharWidth                    ,


-- ** getCjkAmbiguousWidth #method:getCjkAmbiguousWidth#

#if ENABLE_OVERLOADING
    TerminalGetCjkAmbiguousWidthMethodInfo  ,
#endif
    terminalGetCjkAmbiguousWidth            ,


-- ** getColumnCount #method:getColumnCount#

#if ENABLE_OVERLOADING
    TerminalGetColumnCountMethodInfo        ,
#endif
    terminalGetColumnCount                  ,


-- ** getCurrentDirectoryUri #method:getCurrentDirectoryUri#

#if ENABLE_OVERLOADING
    TerminalGetCurrentDirectoryUriMethodInfo,
#endif
    terminalGetCurrentDirectoryUri          ,


-- ** getCurrentFileUri #method:getCurrentFileUri#

#if ENABLE_OVERLOADING
    TerminalGetCurrentFileUriMethodInfo     ,
#endif
    terminalGetCurrentFileUri               ,


-- ** getCursorBlinkMode #method:getCursorBlinkMode#

#if ENABLE_OVERLOADING
    TerminalGetCursorBlinkModeMethodInfo    ,
#endif
    terminalGetCursorBlinkMode              ,


-- ** getCursorPosition #method:getCursorPosition#

#if ENABLE_OVERLOADING
    TerminalGetCursorPositionMethodInfo     ,
#endif
    terminalGetCursorPosition               ,


-- ** getCursorShape #method:getCursorShape#

#if ENABLE_OVERLOADING
    TerminalGetCursorShapeMethodInfo        ,
#endif
    terminalGetCursorShape                  ,


-- ** getEncoding #method:getEncoding#

#if ENABLE_OVERLOADING
    TerminalGetEncodingMethodInfo           ,
#endif
    terminalGetEncoding                     ,


-- ** getFont #method:getFont#

#if ENABLE_OVERLOADING
    TerminalGetFontMethodInfo               ,
#endif
    terminalGetFont                         ,


-- ** getFontScale #method:getFontScale#

#if ENABLE_OVERLOADING
    TerminalGetFontScaleMethodInfo          ,
#endif
    terminalGetFontScale                    ,


-- ** getGeometryHints #method:getGeometryHints#

#if ENABLE_OVERLOADING
    TerminalGetGeometryHintsMethodInfo      ,
#endif
    terminalGetGeometryHints                ,


-- ** getHasSelection #method:getHasSelection#

#if ENABLE_OVERLOADING
    TerminalGetHasSelectionMethodInfo       ,
#endif
    terminalGetHasSelection                 ,


-- ** getIconTitle #method:getIconTitle#

#if ENABLE_OVERLOADING
    TerminalGetIconTitleMethodInfo          ,
#endif
    terminalGetIconTitle                    ,


-- ** getInputEnabled #method:getInputEnabled#

#if ENABLE_OVERLOADING
    TerminalGetInputEnabledMethodInfo       ,
#endif
    terminalGetInputEnabled                 ,


-- ** getMouseAutohide #method:getMouseAutohide#

#if ENABLE_OVERLOADING
    TerminalGetMouseAutohideMethodInfo      ,
#endif
    terminalGetMouseAutohide                ,


-- ** getPty #method:getPty#

#if ENABLE_OVERLOADING
    TerminalGetPtyMethodInfo                ,
#endif
    terminalGetPty                          ,


-- ** getRewrapOnResize #method:getRewrapOnResize#

#if ENABLE_OVERLOADING
    TerminalGetRewrapOnResizeMethodInfo     ,
#endif
    terminalGetRewrapOnResize               ,


-- ** getRowCount #method:getRowCount#

#if ENABLE_OVERLOADING
    TerminalGetRowCountMethodInfo           ,
#endif
    terminalGetRowCount                     ,


-- ** getScrollOnKeystroke #method:getScrollOnKeystroke#

#if ENABLE_OVERLOADING
    TerminalGetScrollOnKeystrokeMethodInfo  ,
#endif
    terminalGetScrollOnKeystroke            ,


-- ** getScrollOnOutput #method:getScrollOnOutput#

#if ENABLE_OVERLOADING
    TerminalGetScrollOnOutputMethodInfo     ,
#endif
    terminalGetScrollOnOutput               ,


-- ** getScrollbackLines #method:getScrollbackLines#

#if ENABLE_OVERLOADING
    TerminalGetScrollbackLinesMethodInfo    ,
#endif
    terminalGetScrollbackLines              ,


-- ** getTextBlinkMode #method:getTextBlinkMode#

#if ENABLE_OVERLOADING
    TerminalGetTextBlinkModeMethodInfo      ,
#endif
    terminalGetTextBlinkMode                ,


-- ** getWindowTitle #method:getWindowTitle#

#if ENABLE_OVERLOADING
    TerminalGetWindowTitleMethodInfo        ,
#endif
    terminalGetWindowTitle                  ,


-- ** getWordCharExceptions #method:getWordCharExceptions#

#if ENABLE_OVERLOADING
    TerminalGetWordCharExceptionsMethodInfo ,
#endif
    terminalGetWordCharExceptions           ,


-- ** hyperlinkCheckEvent #method:hyperlinkCheckEvent#

#if ENABLE_OVERLOADING
    TerminalHyperlinkCheckEventMethodInfo   ,
#endif
    terminalHyperlinkCheckEvent             ,


-- ** matchAddGregex #method:matchAddGregex#

#if ENABLE_OVERLOADING
    TerminalMatchAddGregexMethodInfo        ,
#endif
    terminalMatchAddGregex                  ,


-- ** matchAddRegex #method:matchAddRegex#

#if ENABLE_OVERLOADING
    TerminalMatchAddRegexMethodInfo         ,
#endif
    terminalMatchAddRegex                   ,


-- ** matchCheck #method:matchCheck#

#if ENABLE_OVERLOADING
    TerminalMatchCheckMethodInfo            ,
#endif
    terminalMatchCheck                      ,


-- ** matchCheckEvent #method:matchCheckEvent#

#if ENABLE_OVERLOADING
    TerminalMatchCheckEventMethodInfo       ,
#endif
    terminalMatchCheckEvent                 ,


-- ** matchRemove #method:matchRemove#

#if ENABLE_OVERLOADING
    TerminalMatchRemoveMethodInfo           ,
#endif
    terminalMatchRemove                     ,


-- ** matchRemoveAll #method:matchRemoveAll#

#if ENABLE_OVERLOADING
    TerminalMatchRemoveAllMethodInfo        ,
#endif
    terminalMatchRemoveAll                  ,


-- ** matchSetCursor #method:matchSetCursor#

#if ENABLE_OVERLOADING
    TerminalMatchSetCursorMethodInfo        ,
#endif
    terminalMatchSetCursor                  ,


-- ** matchSetCursorName #method:matchSetCursorName#

#if ENABLE_OVERLOADING
    TerminalMatchSetCursorNameMethodInfo    ,
#endif
    terminalMatchSetCursorName              ,


-- ** matchSetCursorType #method:matchSetCursorType#

#if ENABLE_OVERLOADING
    TerminalMatchSetCursorTypeMethodInfo    ,
#endif
    terminalMatchSetCursorType              ,


-- ** new #method:new#

    terminalNew                             ,


-- ** pasteClipboard #method:pasteClipboard#

#if ENABLE_OVERLOADING
    TerminalPasteClipboardMethodInfo        ,
#endif
    terminalPasteClipboard                  ,


-- ** pastePrimary #method:pastePrimary#

#if ENABLE_OVERLOADING
    TerminalPastePrimaryMethodInfo          ,
#endif
    terminalPastePrimary                    ,


-- ** ptyNewSync #method:ptyNewSync#

#if ENABLE_OVERLOADING
    TerminalPtyNewSyncMethodInfo            ,
#endif
    terminalPtyNewSync                      ,


-- ** reset #method:reset#

#if ENABLE_OVERLOADING
    TerminalResetMethodInfo                 ,
#endif
    terminalReset                           ,


-- ** searchFindNext #method:searchFindNext#

#if ENABLE_OVERLOADING
    TerminalSearchFindNextMethodInfo        ,
#endif
    terminalSearchFindNext                  ,


-- ** searchFindPrevious #method:searchFindPrevious#

#if ENABLE_OVERLOADING
    TerminalSearchFindPreviousMethodInfo    ,
#endif
    terminalSearchFindPrevious              ,


-- ** searchGetGregex #method:searchGetGregex#

#if ENABLE_OVERLOADING
    TerminalSearchGetGregexMethodInfo       ,
#endif
    terminalSearchGetGregex                 ,


-- ** searchGetRegex #method:searchGetRegex#

#if ENABLE_OVERLOADING
    TerminalSearchGetRegexMethodInfo        ,
#endif
    terminalSearchGetRegex                  ,


-- ** searchGetWrapAround #method:searchGetWrapAround#

#if ENABLE_OVERLOADING
    TerminalSearchGetWrapAroundMethodInfo   ,
#endif
    terminalSearchGetWrapAround             ,


-- ** searchSetGregex #method:searchSetGregex#

#if ENABLE_OVERLOADING
    TerminalSearchSetGregexMethodInfo       ,
#endif
    terminalSearchSetGregex                 ,


-- ** searchSetRegex #method:searchSetRegex#

#if ENABLE_OVERLOADING
    TerminalSearchSetRegexMethodInfo        ,
#endif
    terminalSearchSetRegex                  ,


-- ** searchSetWrapAround #method:searchSetWrapAround#

#if ENABLE_OVERLOADING
    TerminalSearchSetWrapAroundMethodInfo   ,
#endif
    terminalSearchSetWrapAround             ,


-- ** selectAll #method:selectAll#

#if ENABLE_OVERLOADING
    TerminalSelectAllMethodInfo             ,
#endif
    terminalSelectAll                       ,


-- ** setAllowBold #method:setAllowBold#

#if ENABLE_OVERLOADING
    TerminalSetAllowBoldMethodInfo          ,
#endif
    terminalSetAllowBold                    ,


-- ** setAllowHyperlink #method:setAllowHyperlink#

#if ENABLE_OVERLOADING
    TerminalSetAllowHyperlinkMethodInfo     ,
#endif
    terminalSetAllowHyperlink               ,


-- ** setAudibleBell #method:setAudibleBell#

#if ENABLE_OVERLOADING
    TerminalSetAudibleBellMethodInfo        ,
#endif
    terminalSetAudibleBell                  ,


-- ** setBackspaceBinding #method:setBackspaceBinding#

#if ENABLE_OVERLOADING
    TerminalSetBackspaceBindingMethodInfo   ,
#endif
    terminalSetBackspaceBinding             ,


-- ** setBoldIsBright #method:setBoldIsBright#

#if ENABLE_OVERLOADING
    TerminalSetBoldIsBrightMethodInfo       ,
#endif
    terminalSetBoldIsBright                 ,


-- ** setCellHeightScale #method:setCellHeightScale#

#if ENABLE_OVERLOADING
    TerminalSetCellHeightScaleMethodInfo    ,
#endif
    terminalSetCellHeightScale              ,


-- ** setCellWidthScale #method:setCellWidthScale#

#if ENABLE_OVERLOADING
    TerminalSetCellWidthScaleMethodInfo     ,
#endif
    terminalSetCellWidthScale               ,


-- ** setCjkAmbiguousWidth #method:setCjkAmbiguousWidth#

#if ENABLE_OVERLOADING
    TerminalSetCjkAmbiguousWidthMethodInfo  ,
#endif
    terminalSetCjkAmbiguousWidth            ,


-- ** setClearBackground #method:setClearBackground#

#if ENABLE_OVERLOADING
    TerminalSetClearBackgroundMethodInfo    ,
#endif
    terminalSetClearBackground              ,


-- ** setColorBackground #method:setColorBackground#

#if ENABLE_OVERLOADING
    TerminalSetColorBackgroundMethodInfo    ,
#endif
    terminalSetColorBackground              ,


-- ** setColorBold #method:setColorBold#

#if ENABLE_OVERLOADING
    TerminalSetColorBoldMethodInfo          ,
#endif
    terminalSetColorBold                    ,


-- ** setColorCursor #method:setColorCursor#

#if ENABLE_OVERLOADING
    TerminalSetColorCursorMethodInfo        ,
#endif
    terminalSetColorCursor                  ,


-- ** setColorCursorForeground #method:setColorCursorForeground#

#if ENABLE_OVERLOADING
    TerminalSetColorCursorForegroundMethodInfo,
#endif
    terminalSetColorCursorForeground        ,


-- ** setColorForeground #method:setColorForeground#

#if ENABLE_OVERLOADING
    TerminalSetColorForegroundMethodInfo    ,
#endif
    terminalSetColorForeground              ,


-- ** setColorHighlight #method:setColorHighlight#

#if ENABLE_OVERLOADING
    TerminalSetColorHighlightMethodInfo     ,
#endif
    terminalSetColorHighlight               ,


-- ** setColorHighlightForeground #method:setColorHighlightForeground#

#if ENABLE_OVERLOADING
    TerminalSetColorHighlightForegroundMethodInfo,
#endif
    terminalSetColorHighlightForeground     ,


-- ** setColors #method:setColors#

#if ENABLE_OVERLOADING
    TerminalSetColorsMethodInfo             ,
#endif
    terminalSetColors                       ,


-- ** setCursorBlinkMode #method:setCursorBlinkMode#

#if ENABLE_OVERLOADING
    TerminalSetCursorBlinkModeMethodInfo    ,
#endif
    terminalSetCursorBlinkMode              ,


-- ** setCursorShape #method:setCursorShape#

#if ENABLE_OVERLOADING
    TerminalSetCursorShapeMethodInfo        ,
#endif
    terminalSetCursorShape                  ,


-- ** setDefaultColors #method:setDefaultColors#

#if ENABLE_OVERLOADING
    TerminalSetDefaultColorsMethodInfo      ,
#endif
    terminalSetDefaultColors                ,


-- ** setDeleteBinding #method:setDeleteBinding#

#if ENABLE_OVERLOADING
    TerminalSetDeleteBindingMethodInfo      ,
#endif
    terminalSetDeleteBinding                ,


-- ** setEncoding #method:setEncoding#

#if ENABLE_OVERLOADING
    TerminalSetEncodingMethodInfo           ,
#endif
    terminalSetEncoding                     ,


-- ** setFont #method:setFont#

#if ENABLE_OVERLOADING
    TerminalSetFontMethodInfo               ,
#endif
    terminalSetFont                         ,


-- ** setFontScale #method:setFontScale#

#if ENABLE_OVERLOADING
    TerminalSetFontScaleMethodInfo          ,
#endif
    terminalSetFontScale                    ,


-- ** setGeometryHintsForWindow #method:setGeometryHintsForWindow#

#if ENABLE_OVERLOADING
    TerminalSetGeometryHintsForWindowMethodInfo,
#endif
    terminalSetGeometryHintsForWindow       ,


-- ** setInputEnabled #method:setInputEnabled#

#if ENABLE_OVERLOADING
    TerminalSetInputEnabledMethodInfo       ,
#endif
    terminalSetInputEnabled                 ,


-- ** setMouseAutohide #method:setMouseAutohide#

#if ENABLE_OVERLOADING
    TerminalSetMouseAutohideMethodInfo      ,
#endif
    terminalSetMouseAutohide                ,


-- ** setPty #method:setPty#

#if ENABLE_OVERLOADING
    TerminalSetPtyMethodInfo                ,
#endif
    terminalSetPty                          ,


-- ** setRewrapOnResize #method:setRewrapOnResize#

#if ENABLE_OVERLOADING
    TerminalSetRewrapOnResizeMethodInfo     ,
#endif
    terminalSetRewrapOnResize               ,


-- ** setScrollOnKeystroke #method:setScrollOnKeystroke#

#if ENABLE_OVERLOADING
    TerminalSetScrollOnKeystrokeMethodInfo  ,
#endif
    terminalSetScrollOnKeystroke            ,


-- ** setScrollOnOutput #method:setScrollOnOutput#

#if ENABLE_OVERLOADING
    TerminalSetScrollOnOutputMethodInfo     ,
#endif
    terminalSetScrollOnOutput               ,


-- ** setScrollSpeed #method:setScrollSpeed#

#if ENABLE_OVERLOADING
    TerminalSetScrollSpeedMethodInfo        ,
#endif
    terminalSetScrollSpeed                  ,


-- ** setScrollbackLines #method:setScrollbackLines#

#if ENABLE_OVERLOADING
    TerminalSetScrollbackLinesMethodInfo    ,
#endif
    terminalSetScrollbackLines              ,


-- ** setSize #method:setSize#

#if ENABLE_OVERLOADING
    TerminalSetSizeMethodInfo               ,
#endif
    terminalSetSize                         ,


-- ** setTextBlinkMode #method:setTextBlinkMode#

#if ENABLE_OVERLOADING
    TerminalSetTextBlinkModeMethodInfo      ,
#endif
    terminalSetTextBlinkMode                ,


-- ** setWordCharExceptions #method:setWordCharExceptions#

#if ENABLE_OVERLOADING
    TerminalSetWordCharExceptionsMethodInfo ,
#endif
    terminalSetWordCharExceptions           ,


-- ** spawnSync #method:spawnSync#

#if ENABLE_OVERLOADING
    TerminalSpawnSyncMethodInfo             ,
#endif
    terminalSpawnSync                       ,


-- ** unselectAll #method:unselectAll#

#if ENABLE_OVERLOADING
    TerminalUnselectAllMethodInfo           ,
#endif
    terminalUnselectAll                     ,


-- ** watchChild #method:watchChild#

#if ENABLE_OVERLOADING
    TerminalWatchChildMethodInfo            ,
#endif
    terminalWatchChild                      ,


-- ** writeContentsSync #method:writeContentsSync#

#if ENABLE_OVERLOADING
    TerminalWriteContentsSyncMethodInfo     ,
#endif
    terminalWriteContentsSync               ,




 -- * Properties
-- ** allowBold #attr:allowBold#
{- | Controls whether or not the terminal will attempt to draw bold text.
This may happen either by using a bold font variant, or by
repainting text with a different offset.
-}
#if ENABLE_OVERLOADING
    TerminalAllowBoldPropertyInfo           ,
#endif
    constructTerminalAllowBold              ,
    getTerminalAllowBold                    ,
    setTerminalAllowBold                    ,
#if ENABLE_OVERLOADING
    terminalAllowBold                       ,
#endif


-- ** allowHyperlink #attr:allowHyperlink#
{- | Controls whether or not hyperlinks (OSC 8 escape sequence) are recognized and displayed.

/Since: 0.50/
-}
#if ENABLE_OVERLOADING
    TerminalAllowHyperlinkPropertyInfo      ,
#endif
    constructTerminalAllowHyperlink         ,
    getTerminalAllowHyperlink               ,
    setTerminalAllowHyperlink               ,
#if ENABLE_OVERLOADING
    terminalAllowHyperlink                  ,
#endif


-- ** audibleBell #attr:audibleBell#
{- | Controls whether or not the terminal will beep when the child outputs the
\"bl\" sequence.
-}
#if ENABLE_OVERLOADING
    TerminalAudibleBellPropertyInfo         ,
#endif
    constructTerminalAudibleBell            ,
    getTerminalAudibleBell                  ,
    setTerminalAudibleBell                  ,
#if ENABLE_OVERLOADING
    terminalAudibleBell                     ,
#endif


-- ** backspaceBinding #attr:backspaceBinding#
{- | Controls what string or control sequence the terminal sends to its child
when the user presses the backspace key.
-}
#if ENABLE_OVERLOADING
    TerminalBackspaceBindingPropertyInfo    ,
#endif
    constructTerminalBackspaceBinding       ,
    getTerminalBackspaceBinding             ,
    setTerminalBackspaceBinding             ,
#if ENABLE_OVERLOADING
    terminalBackspaceBinding                ,
#endif


-- ** boldIsBright #attr:boldIsBright#
{- | Whether the SGR 1 attribute also switches to the bright counterpart
of the first 8 palette colors, in addition to making them bold (legacy behavior)
or if SGR 1 only enables bold and leaves the color intact.

/Since: 0.52/
-}
#if ENABLE_OVERLOADING
    TerminalBoldIsBrightPropertyInfo        ,
#endif
    constructTerminalBoldIsBright           ,
    getTerminalBoldIsBright                 ,
    setTerminalBoldIsBright                 ,
#if ENABLE_OVERLOADING
    terminalBoldIsBright                    ,
#endif


-- ** cellHeightScale #attr:cellHeightScale#
{- | Scale factor for the cell height, to increase line spacing. (The font\'s height is not affected.)

/Since: 0.52/
-}
#if ENABLE_OVERLOADING
    TerminalCellHeightScalePropertyInfo     ,
#endif
    constructTerminalCellHeightScale        ,
    getTerminalCellHeightScale              ,
    setTerminalCellHeightScale              ,
#if ENABLE_OVERLOADING
    terminalCellHeightScale                 ,
#endif


-- ** cellWidthScale #attr:cellWidthScale#
{- | Scale factor for the cell width, to increase letter spacing. (The font\'s width is not affected.)

/Since: 0.52/
-}
#if ENABLE_OVERLOADING
    TerminalCellWidthScalePropertyInfo      ,
#endif
    constructTerminalCellWidthScale         ,
    getTerminalCellWidthScale               ,
    setTerminalCellWidthScale               ,
#if ENABLE_OVERLOADING
    terminalCellWidthScale                  ,
#endif


-- ** cjkAmbiguousWidth #attr:cjkAmbiguousWidth#
{- | 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.

This setting only takes effect the next time the terminal is reset, either
via escape sequence or with 'GI.Vte.Objects.Terminal.terminalReset'.
-}
#if ENABLE_OVERLOADING
    TerminalCjkAmbiguousWidthPropertyInfo   ,
#endif
    constructTerminalCjkAmbiguousWidth      ,
    getTerminalCjkAmbiguousWidth            ,
    setTerminalCjkAmbiguousWidth            ,
#if ENABLE_OVERLOADING
    terminalCjkAmbiguousWidth               ,
#endif


-- ** currentDirectoryUri #attr:currentDirectoryUri#
{- | The current directory URI, or 'Nothing' if unset.
-}
#if ENABLE_OVERLOADING
    TerminalCurrentDirectoryUriPropertyInfo ,
#endif
    getTerminalCurrentDirectoryUri          ,
#if ENABLE_OVERLOADING
    terminalCurrentDirectoryUri             ,
#endif


-- ** currentFileUri #attr:currentFileUri#
{- | The current file URI, or 'Nothing' if unset.
-}
#if ENABLE_OVERLOADING
    TerminalCurrentFileUriPropertyInfo      ,
#endif
    getTerminalCurrentFileUri               ,
#if ENABLE_OVERLOADING
    terminalCurrentFileUri                  ,
#endif


-- ** cursorBlinkMode #attr:cursorBlinkMode#
{- | 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.
-}
#if ENABLE_OVERLOADING
    TerminalCursorBlinkModePropertyInfo     ,
#endif
    constructTerminalCursorBlinkMode        ,
    getTerminalCursorBlinkMode              ,
    setTerminalCursorBlinkMode              ,
#if ENABLE_OVERLOADING
    terminalCursorBlinkMode                 ,
#endif


-- ** cursorShape #attr:cursorShape#
{- | Controls the shape of the cursor.
-}
#if ENABLE_OVERLOADING
    TerminalCursorShapePropertyInfo         ,
#endif
    constructTerminalCursorShape            ,
    getTerminalCursorShape                  ,
    setTerminalCursorShape                  ,
#if ENABLE_OVERLOADING
    terminalCursorShape                     ,
#endif


-- ** deleteBinding #attr:deleteBinding#
{- | Controls what string or control sequence the terminal sends to its child
when the user presses the delete key.
-}
#if ENABLE_OVERLOADING
    TerminalDeleteBindingPropertyInfo       ,
#endif
    constructTerminalDeleteBinding          ,
    getTerminalDeleteBinding                ,
    setTerminalDeleteBinding                ,
#if ENABLE_OVERLOADING
    terminalDeleteBinding                   ,
#endif


-- ** encoding #attr:encoding#
{- | Controls 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.  The default is defined by the
application\'s locale settings.
-}
#if ENABLE_OVERLOADING
    TerminalEncodingPropertyInfo            ,
#endif
    clearTerminalEncoding                   ,
    constructTerminalEncoding               ,
    getTerminalEncoding                     ,
    setTerminalEncoding                     ,
#if ENABLE_OVERLOADING
    terminalEncoding                        ,
#endif


-- ** fontDesc #attr:fontDesc#
{- | Specifies 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.
-}
#if ENABLE_OVERLOADING
    TerminalFontDescPropertyInfo            ,
#endif
    clearTerminalFontDesc                   ,
    constructTerminalFontDesc               ,
    getTerminalFontDesc                     ,
    setTerminalFontDesc                     ,
#if ENABLE_OVERLOADING
    terminalFontDesc                        ,
#endif


-- ** fontScale #attr:fontScale#
{- | The terminal\'s font scale.
-}
#if ENABLE_OVERLOADING
    TerminalFontScalePropertyInfo           ,
#endif
    constructTerminalFontScale              ,
    getTerminalFontScale                    ,
    setTerminalFontScale                    ,
#if ENABLE_OVERLOADING
    terminalFontScale                       ,
#endif


-- ** hyperlinkHoverUri #attr:hyperlinkHoverUri#
{- | The currently hovered hyperlink URI, or 'Nothing' if unset.

/Since: 0.50/
-}
#if ENABLE_OVERLOADING
    TerminalHyperlinkHoverUriPropertyInfo   ,
#endif
    getTerminalHyperlinkHoverUri            ,
#if ENABLE_OVERLOADING
    terminalHyperlinkHoverUri               ,
#endif


-- ** iconTitle #attr:iconTitle#
{- | The terminal\'s so-called icon title, or 'Nothing' if no icon title has been set.
-}
#if ENABLE_OVERLOADING
    TerminalIconTitlePropertyInfo           ,
#endif
    getTerminalIconTitle                    ,
#if ENABLE_OVERLOADING
    terminalIconTitle                       ,
#endif


-- ** inputEnabled #attr:inputEnabled#
{- | Controls whether the terminal allows user input. When user input is disabled,
key press and mouse button press and motion events are not sent to the
terminal\'s child.
-}
#if ENABLE_OVERLOADING
    TerminalInputEnabledPropertyInfo        ,
#endif
    constructTerminalInputEnabled           ,
    getTerminalInputEnabled                 ,
    setTerminalInputEnabled                 ,
#if ENABLE_OVERLOADING
    terminalInputEnabled                    ,
#endif


-- ** pointerAutohide #attr:pointerAutohide#
{- | Controls 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.
-}
#if ENABLE_OVERLOADING
    TerminalPointerAutohidePropertyInfo     ,
#endif
    constructTerminalPointerAutohide        ,
    getTerminalPointerAutohide              ,
    setTerminalPointerAutohide              ,
#if ENABLE_OVERLOADING
    terminalPointerAutohide                 ,
#endif


-- ** pty #attr:pty#
{- | The PTY object for the terminal.
-}
#if ENABLE_OVERLOADING
    TerminalPtyPropertyInfo                 ,
#endif
    clearTerminalPty                        ,
    constructTerminalPty                    ,
    getTerminalPty                          ,
    setTerminalPty                          ,
#if ENABLE_OVERLOADING
    terminalPty                             ,
#endif


-- ** rewrapOnResize #attr:rewrapOnResize#
{- | Controls whether or not the terminal will rewrap its contents, including
the scrollback buffer, whenever the terminal\'s width changes.
-}
#if ENABLE_OVERLOADING
    TerminalRewrapOnResizePropertyInfo      ,
#endif
    constructTerminalRewrapOnResize         ,
    getTerminalRewrapOnResize               ,
    setTerminalRewrapOnResize               ,
#if ENABLE_OVERLOADING
    terminalRewrapOnResize                  ,
#endif


-- ** scrollOnKeystroke #attr:scrollOnKeystroke#
{- | 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.
-}
#if ENABLE_OVERLOADING
    TerminalScrollOnKeystrokePropertyInfo   ,
#endif
    constructTerminalScrollOnKeystroke      ,
    getTerminalScrollOnKeystroke            ,
    setTerminalScrollOnKeystroke            ,
#if ENABLE_OVERLOADING
    terminalScrollOnKeystroke               ,
#endif


-- ** scrollOnOutput #attr:scrollOnOutput#
{- | 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.
-}
#if ENABLE_OVERLOADING
    TerminalScrollOnOutputPropertyInfo      ,
#endif
    constructTerminalScrollOnOutput         ,
    getTerminalScrollOnOutput               ,
    setTerminalScrollOnOutput               ,
#if ENABLE_OVERLOADING
    terminalScrollOnOutput                  ,
#endif


-- ** scrollSpeed #attr:scrollSpeed#
{- | The number of lines by which the buffer is moved when
scrolling with a mouse wheel on top of the terminal
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.
-}
#if ENABLE_OVERLOADING
    TerminalScrollSpeedPropertyInfo         ,
#endif
    constructTerminalScrollSpeed            ,
    getTerminalScrollSpeed                  ,
    setTerminalScrollSpeed                  ,
#if ENABLE_OVERLOADING
    terminalScrollSpeed                     ,
#endif


-- ** scrollbackLines #attr:scrollbackLines#
{- | 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.  Note that this setting only affects the normal screen buffer.
For terminal types which have an alternate screen buffer, no scrollback is
allowed on the alternate screen buffer.
-}
#if ENABLE_OVERLOADING
    TerminalScrollbackLinesPropertyInfo     ,
#endif
    constructTerminalScrollbackLines        ,
    getTerminalScrollbackLines              ,
    setTerminalScrollbackLines              ,
#if ENABLE_OVERLOADING
    terminalScrollbackLines                 ,
#endif


-- ** textBlinkMode #attr:textBlinkMode#
{- | Controls whether or not the terminal will allow blinking text.

/Since: 0.52/
-}
#if ENABLE_OVERLOADING
    TerminalTextBlinkModePropertyInfo       ,
#endif
    constructTerminalTextBlinkMode          ,
    getTerminalTextBlinkMode                ,
    setTerminalTextBlinkMode                ,
#if ENABLE_OVERLOADING
    terminalTextBlinkMode                   ,
#endif


-- ** windowTitle #attr:windowTitle#
{- | The terminal\'s title.
-}
#if ENABLE_OVERLOADING
    TerminalWindowTitlePropertyInfo         ,
#endif
    getTerminalWindowTitle                  ,
#if ENABLE_OVERLOADING
    terminalWindowTitle                     ,
#endif


-- ** wordCharExceptions #attr:wordCharExceptions#
{- | 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/
-}
#if ENABLE_OVERLOADING
    TerminalWordCharExceptionsPropertyInfo  ,
#endif
    getTerminalWordCharExceptions           ,
#if ENABLE_OVERLOADING
    terminalWordCharExceptions              ,
#endif




 -- * Signals
-- ** bell #signal:bell#

    C_TerminalBellCallback                  ,
    TerminalBellCallback                    ,
#if ENABLE_OVERLOADING
    TerminalBellSignalInfo                  ,
#endif
    afterTerminalBell                       ,
    genClosure_TerminalBell                 ,
    mk_TerminalBellCallback                 ,
    noTerminalBellCallback                  ,
    onTerminalBell                          ,
    wrap_TerminalBellCallback               ,


-- ** charSizeChanged #signal:charSizeChanged#

    C_TerminalCharSizeChangedCallback       ,
    TerminalCharSizeChangedCallback         ,
#if ENABLE_OVERLOADING
    TerminalCharSizeChangedSignalInfo       ,
#endif
    afterTerminalCharSizeChanged            ,
    genClosure_TerminalCharSizeChanged      ,
    mk_TerminalCharSizeChangedCallback      ,
    noTerminalCharSizeChangedCallback       ,
    onTerminalCharSizeChanged               ,
    wrap_TerminalCharSizeChangedCallback    ,


-- ** childExited #signal:childExited#

    C_TerminalChildExitedCallback           ,
    TerminalChildExitedCallback             ,
#if ENABLE_OVERLOADING
    TerminalChildExitedSignalInfo           ,
#endif
    afterTerminalChildExited                ,
    genClosure_TerminalChildExited          ,
    mk_TerminalChildExitedCallback          ,
    noTerminalChildExitedCallback           ,
    onTerminalChildExited                   ,
    wrap_TerminalChildExitedCallback        ,


-- ** commit #signal:commit#

    C_TerminalCommitCallback                ,
    TerminalCommitCallback                  ,
#if ENABLE_OVERLOADING
    TerminalCommitSignalInfo                ,
#endif
    afterTerminalCommit                     ,
    genClosure_TerminalCommit               ,
    mk_TerminalCommitCallback               ,
    noTerminalCommitCallback                ,
    onTerminalCommit                        ,
    wrap_TerminalCommitCallback             ,


-- ** contentsChanged #signal:contentsChanged#

    C_TerminalContentsChangedCallback       ,
    TerminalContentsChangedCallback         ,
#if ENABLE_OVERLOADING
    TerminalContentsChangedSignalInfo       ,
#endif
    afterTerminalContentsChanged            ,
    genClosure_TerminalContentsChanged      ,
    mk_TerminalContentsChangedCallback      ,
    noTerminalContentsChangedCallback       ,
    onTerminalContentsChanged               ,
    wrap_TerminalContentsChangedCallback    ,


-- ** copyClipboard #signal:copyClipboard#

    C_TerminalCopyClipboardCallback         ,
    TerminalCopyClipboardCallback           ,
#if ENABLE_OVERLOADING
    TerminalCopyClipboardSignalInfo         ,
#endif
    afterTerminalCopyClipboard              ,
    genClosure_TerminalCopyClipboard        ,
    mk_TerminalCopyClipboardCallback        ,
    noTerminalCopyClipboardCallback         ,
    onTerminalCopyClipboard                 ,
    wrap_TerminalCopyClipboardCallback      ,


-- ** currentDirectoryUriChanged #signal:currentDirectoryUriChanged#

    C_TerminalCurrentDirectoryUriChangedCallback,
    TerminalCurrentDirectoryUriChangedCallback,
#if ENABLE_OVERLOADING
    TerminalCurrentDirectoryUriChangedSignalInfo,
#endif
    afterTerminalCurrentDirectoryUriChanged ,
    genClosure_TerminalCurrentDirectoryUriChanged,
    mk_TerminalCurrentDirectoryUriChangedCallback,
    noTerminalCurrentDirectoryUriChangedCallback,
    onTerminalCurrentDirectoryUriChanged    ,
    wrap_TerminalCurrentDirectoryUriChangedCallback,


-- ** currentFileUriChanged #signal:currentFileUriChanged#

    C_TerminalCurrentFileUriChangedCallback ,
    TerminalCurrentFileUriChangedCallback   ,
#if ENABLE_OVERLOADING
    TerminalCurrentFileUriChangedSignalInfo ,
#endif
    afterTerminalCurrentFileUriChanged      ,
    genClosure_TerminalCurrentFileUriChanged,
    mk_TerminalCurrentFileUriChangedCallback,
    noTerminalCurrentFileUriChangedCallback ,
    onTerminalCurrentFileUriChanged         ,
    wrap_TerminalCurrentFileUriChangedCallback,


-- ** cursorMoved #signal:cursorMoved#

    C_TerminalCursorMovedCallback           ,
    TerminalCursorMovedCallback             ,
#if ENABLE_OVERLOADING
    TerminalCursorMovedSignalInfo           ,
#endif
    afterTerminalCursorMoved                ,
    genClosure_TerminalCursorMoved          ,
    mk_TerminalCursorMovedCallback          ,
    noTerminalCursorMovedCallback           ,
    onTerminalCursorMoved                   ,
    wrap_TerminalCursorMovedCallback        ,


-- ** decreaseFontSize #signal:decreaseFontSize#

    C_TerminalDecreaseFontSizeCallback      ,
    TerminalDecreaseFontSizeCallback        ,
#if ENABLE_OVERLOADING
    TerminalDecreaseFontSizeSignalInfo      ,
#endif
    afterTerminalDecreaseFontSize           ,
    genClosure_TerminalDecreaseFontSize     ,
    mk_TerminalDecreaseFontSizeCallback     ,
    noTerminalDecreaseFontSizeCallback      ,
    onTerminalDecreaseFontSize              ,
    wrap_TerminalDecreaseFontSizeCallback   ,


-- ** deiconifyWindow #signal:deiconifyWindow#

    C_TerminalDeiconifyWindowCallback       ,
    TerminalDeiconifyWindowCallback         ,
#if ENABLE_OVERLOADING
    TerminalDeiconifyWindowSignalInfo       ,
#endif
    afterTerminalDeiconifyWindow            ,
    genClosure_TerminalDeiconifyWindow      ,
    mk_TerminalDeiconifyWindowCallback      ,
    noTerminalDeiconifyWindowCallback       ,
    onTerminalDeiconifyWindow               ,
    wrap_TerminalDeiconifyWindowCallback    ,


-- ** encodingChanged #signal:encodingChanged#

    C_TerminalEncodingChangedCallback       ,
    TerminalEncodingChangedCallback         ,
#if ENABLE_OVERLOADING
    TerminalEncodingChangedSignalInfo       ,
#endif
    afterTerminalEncodingChanged            ,
    genClosure_TerminalEncodingChanged      ,
    mk_TerminalEncodingChangedCallback      ,
    noTerminalEncodingChangedCallback       ,
    onTerminalEncodingChanged               ,
    wrap_TerminalEncodingChangedCallback    ,


-- ** eof #signal:eof#

    C_TerminalEofCallback                   ,
    TerminalEofCallback                     ,
#if ENABLE_OVERLOADING
    TerminalEofSignalInfo                   ,
#endif
    afterTerminalEof                        ,
    genClosure_TerminalEof                  ,
    mk_TerminalEofCallback                  ,
    noTerminalEofCallback                   ,
    onTerminalEof                           ,
    wrap_TerminalEofCallback                ,


-- ** hyperlinkHoverUriChanged #signal:hyperlinkHoverUriChanged#

    C_TerminalHyperlinkHoverUriChangedCallback,
    TerminalHyperlinkHoverUriChangedCallback,
#if ENABLE_OVERLOADING
    TerminalHyperlinkHoverUriChangedSignalInfo,
#endif
    afterTerminalHyperlinkHoverUriChanged   ,
    genClosure_TerminalHyperlinkHoverUriChanged,
    mk_TerminalHyperlinkHoverUriChangedCallback,
    noTerminalHyperlinkHoverUriChangedCallback,
    onTerminalHyperlinkHoverUriChanged      ,
    wrap_TerminalHyperlinkHoverUriChangedCallback,


-- ** iconTitleChanged #signal:iconTitleChanged#

    C_TerminalIconTitleChangedCallback      ,
    TerminalIconTitleChangedCallback        ,
#if ENABLE_OVERLOADING
    TerminalIconTitleChangedSignalInfo      ,
#endif
    afterTerminalIconTitleChanged           ,
    genClosure_TerminalIconTitleChanged     ,
    mk_TerminalIconTitleChangedCallback     ,
    noTerminalIconTitleChangedCallback      ,
    onTerminalIconTitleChanged              ,
    wrap_TerminalIconTitleChangedCallback   ,


-- ** iconifyWindow #signal:iconifyWindow#

    C_TerminalIconifyWindowCallback         ,
    TerminalIconifyWindowCallback           ,
#if ENABLE_OVERLOADING
    TerminalIconifyWindowSignalInfo         ,
#endif
    afterTerminalIconifyWindow              ,
    genClosure_TerminalIconifyWindow        ,
    mk_TerminalIconifyWindowCallback        ,
    noTerminalIconifyWindowCallback         ,
    onTerminalIconifyWindow                 ,
    wrap_TerminalIconifyWindowCallback      ,


-- ** increaseFontSize #signal:increaseFontSize#

    C_TerminalIncreaseFontSizeCallback      ,
    TerminalIncreaseFontSizeCallback        ,
#if ENABLE_OVERLOADING
    TerminalIncreaseFontSizeSignalInfo      ,
#endif
    afterTerminalIncreaseFontSize           ,
    genClosure_TerminalIncreaseFontSize     ,
    mk_TerminalIncreaseFontSizeCallback     ,
    noTerminalIncreaseFontSizeCallback      ,
    onTerminalIncreaseFontSize              ,
    wrap_TerminalIncreaseFontSizeCallback   ,


-- ** lowerWindow #signal:lowerWindow#

    C_TerminalLowerWindowCallback           ,
    TerminalLowerWindowCallback             ,
#if ENABLE_OVERLOADING
    TerminalLowerWindowSignalInfo           ,
#endif
    afterTerminalLowerWindow                ,
    genClosure_TerminalLowerWindow          ,
    mk_TerminalLowerWindowCallback          ,
    noTerminalLowerWindowCallback           ,
    onTerminalLowerWindow                   ,
    wrap_TerminalLowerWindowCallback        ,


-- ** maximizeWindow #signal:maximizeWindow#

    C_TerminalMaximizeWindowCallback        ,
    TerminalMaximizeWindowCallback          ,
#if ENABLE_OVERLOADING
    TerminalMaximizeWindowSignalInfo        ,
#endif
    afterTerminalMaximizeWindow             ,
    genClosure_TerminalMaximizeWindow       ,
    mk_TerminalMaximizeWindowCallback       ,
    noTerminalMaximizeWindowCallback        ,
    onTerminalMaximizeWindow                ,
    wrap_TerminalMaximizeWindowCallback     ,


-- ** moveWindow #signal:moveWindow#

    C_TerminalMoveWindowCallback            ,
    TerminalMoveWindowCallback              ,
#if ENABLE_OVERLOADING
    TerminalMoveWindowSignalInfo            ,
#endif
    afterTerminalMoveWindow                 ,
    genClosure_TerminalMoveWindow           ,
    mk_TerminalMoveWindowCallback           ,
    noTerminalMoveWindowCallback            ,
    onTerminalMoveWindow                    ,
    wrap_TerminalMoveWindowCallback         ,


-- ** notificationReceived #signal:notificationReceived#

    C_TerminalNotificationReceivedCallback  ,
    TerminalNotificationReceivedCallback    ,
#if ENABLE_OVERLOADING
    TerminalNotificationReceivedSignalInfo  ,
#endif
    afterTerminalNotificationReceived       ,
    genClosure_TerminalNotificationReceived ,
    mk_TerminalNotificationReceivedCallback ,
    noTerminalNotificationReceivedCallback  ,
    onTerminalNotificationReceived          ,
    wrap_TerminalNotificationReceivedCallback,


-- ** pasteClipboard #signal:pasteClipboard#

    C_TerminalPasteClipboardCallback        ,
    TerminalPasteClipboardCallback          ,
#if ENABLE_OVERLOADING
    TerminalPasteClipboardSignalInfo        ,
#endif
    afterTerminalPasteClipboard             ,
    genClosure_TerminalPasteClipboard       ,
    mk_TerminalPasteClipboardCallback       ,
    noTerminalPasteClipboardCallback        ,
    onTerminalPasteClipboard                ,
    wrap_TerminalPasteClipboardCallback     ,


-- ** raiseWindow #signal:raiseWindow#

    C_TerminalRaiseWindowCallback           ,
    TerminalRaiseWindowCallback             ,
#if ENABLE_OVERLOADING
    TerminalRaiseWindowSignalInfo           ,
#endif
    afterTerminalRaiseWindow                ,
    genClosure_TerminalRaiseWindow          ,
    mk_TerminalRaiseWindowCallback          ,
    noTerminalRaiseWindowCallback           ,
    onTerminalRaiseWindow                   ,
    wrap_TerminalRaiseWindowCallback        ,


-- ** refreshWindow #signal:refreshWindow#

    C_TerminalRefreshWindowCallback         ,
    TerminalRefreshWindowCallback           ,
#if ENABLE_OVERLOADING
    TerminalRefreshWindowSignalInfo         ,
#endif
    afterTerminalRefreshWindow              ,
    genClosure_TerminalRefreshWindow        ,
    mk_TerminalRefreshWindowCallback        ,
    noTerminalRefreshWindowCallback         ,
    onTerminalRefreshWindow                 ,
    wrap_TerminalRefreshWindowCallback      ,


-- ** resizeWindow #signal:resizeWindow#

    C_TerminalResizeWindowCallback          ,
    TerminalResizeWindowCallback            ,
#if ENABLE_OVERLOADING
    TerminalResizeWindowSignalInfo          ,
#endif
    afterTerminalResizeWindow               ,
    genClosure_TerminalResizeWindow         ,
    mk_TerminalResizeWindowCallback         ,
    noTerminalResizeWindowCallback          ,
    onTerminalResizeWindow                  ,
    wrap_TerminalResizeWindowCallback       ,


-- ** restoreWindow #signal:restoreWindow#

    C_TerminalRestoreWindowCallback         ,
    TerminalRestoreWindowCallback           ,
#if ENABLE_OVERLOADING
    TerminalRestoreWindowSignalInfo         ,
#endif
    afterTerminalRestoreWindow              ,
    genClosure_TerminalRestoreWindow        ,
    mk_TerminalRestoreWindowCallback        ,
    noTerminalRestoreWindowCallback         ,
    onTerminalRestoreWindow                 ,
    wrap_TerminalRestoreWindowCallback      ,


-- ** selectionChanged #signal:selectionChanged#

    C_TerminalSelectionChangedCallback      ,
    TerminalSelectionChangedCallback        ,
#if ENABLE_OVERLOADING
    TerminalSelectionChangedSignalInfo      ,
#endif
    afterTerminalSelectionChanged           ,
    genClosure_TerminalSelectionChanged     ,
    mk_TerminalSelectionChangedCallback     ,
    noTerminalSelectionChangedCallback      ,
    onTerminalSelectionChanged              ,
    wrap_TerminalSelectionChangedCallback   ,


-- ** textDeleted #signal:textDeleted#

    C_TerminalTextDeletedCallback           ,
    TerminalTextDeletedCallback             ,
#if ENABLE_OVERLOADING
    TerminalTextDeletedSignalInfo           ,
#endif
    afterTerminalTextDeleted                ,
    genClosure_TerminalTextDeleted          ,
    mk_TerminalTextDeletedCallback          ,
    noTerminalTextDeletedCallback           ,
    onTerminalTextDeleted                   ,
    wrap_TerminalTextDeletedCallback        ,


-- ** textInserted #signal:textInserted#

    C_TerminalTextInsertedCallback          ,
    TerminalTextInsertedCallback            ,
#if ENABLE_OVERLOADING
    TerminalTextInsertedSignalInfo          ,
#endif
    afterTerminalTextInserted               ,
    genClosure_TerminalTextInserted         ,
    mk_TerminalTextInsertedCallback         ,
    noTerminalTextInsertedCallback          ,
    onTerminalTextInserted                  ,
    wrap_TerminalTextInsertedCallback       ,


-- ** textModified #signal:textModified#

    C_TerminalTextModifiedCallback          ,
    TerminalTextModifiedCallback            ,
#if ENABLE_OVERLOADING
    TerminalTextModifiedSignalInfo          ,
#endif
    afterTerminalTextModified               ,
    genClosure_TerminalTextModified         ,
    mk_TerminalTextModifiedCallback         ,
    noTerminalTextModifiedCallback          ,
    onTerminalTextModified                  ,
    wrap_TerminalTextModifiedCallback       ,


-- ** textScrolled #signal:textScrolled#

    C_TerminalTextScrolledCallback          ,
    TerminalTextScrolledCallback            ,
#if ENABLE_OVERLOADING
    TerminalTextScrolledSignalInfo          ,
#endif
    afterTerminalTextScrolled               ,
    genClosure_TerminalTextScrolled         ,
    mk_TerminalTextScrolledCallback         ,
    noTerminalTextScrolledCallback          ,
    onTerminalTextScrolled                  ,
    wrap_TerminalTextScrolledCallback       ,


-- ** windowTitleChanged #signal:windowTitleChanged#

    C_TerminalWindowTitleChangedCallback    ,
    TerminalWindowTitleChangedCallback      ,
#if ENABLE_OVERLOADING
    TerminalWindowTitleChangedSignalInfo    ,
#endif
    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.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.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.Structs.Rectangle as Gdk.Rectangle
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

-- | Memory-managed wrapper type.
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


-- | Type class for types which can be safely cast to `Terminal`, for instance with `toTerminal`.
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

-- | Cast to `Terminal`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTerminal :: (MonadIO m, IsTerminal o) => o -> m Terminal
toTerminal = liftIO . unsafeCastTo Terminal

-- | A convenience alias for `Nothing` :: `Maybe` `Terminal`.
noTerminal :: Maybe Terminal
noTerminal = Nothing

#if ENABLE_OVERLOADING
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 "copyClipboardFormat" o = TerminalCopyClipboardFormatMethodInfo
    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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "hyperlinkCheckEvent" o = TerminalHyperlinkCheckEventMethodInfo
    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 "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 "getAllowHyperlink" o = TerminalGetAllowHyperlinkMethodInfo
    ResolveTerminalMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTerminalMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTerminalMethod "getAudibleBell" o = TerminalGetAudibleBellMethodInfo
    ResolveTerminalMethod "getBoldIsBright" o = TerminalGetBoldIsBrightMethodInfo
    ResolveTerminalMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveTerminalMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTerminalMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTerminalMethod "getCellHeightScale" o = TerminalGetCellHeightScaleMethodInfo
    ResolveTerminalMethod "getCellWidthScale" o = TerminalGetCellWidthScaleMethodInfo
    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 "getScrollOnKeystroke" o = TerminalGetScrollOnKeystrokeMethodInfo
    ResolveTerminalMethod "getScrollOnOutput" o = TerminalGetScrollOnOutputMethodInfo
    ResolveTerminalMethod "getScrollbackLines" o = TerminalGetScrollbackLinesMethodInfo
    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 "getTextBlinkMode" o = TerminalGetTextBlinkModeMethodInfo
    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 "setAllowHyperlink" o = TerminalSetAllowHyperlinkMethodInfo
    ResolveTerminalMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTerminalMethod "setAudibleBell" o = TerminalSetAudibleBellMethodInfo
    ResolveTerminalMethod "setBackspaceBinding" o = TerminalSetBackspaceBindingMethodInfo
    ResolveTerminalMethod "setBoldIsBright" o = TerminalSetBoldIsBrightMethodInfo
    ResolveTerminalMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTerminalMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTerminalMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTerminalMethod "setCellHeightScale" o = TerminalSetCellHeightScaleMethodInfo
    ResolveTerminalMethod "setCellWidthScale" o = TerminalSetCellWidthScaleMethodInfo
    ResolveTerminalMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTerminalMethod "setCjkAmbiguousWidth" o = TerminalSetCjkAmbiguousWidthMethodInfo
    ResolveTerminalMethod "setClearBackground" o = TerminalSetClearBackgroundMethodInfo
    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 "setTextBlinkMode" o = TerminalSetTextBlinkModeMethodInfo
    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
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal Terminal::bell
{- |
This signal is emitted when the a child sends a bell request to the
terminal.
-}
type TerminalBellCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalBellCallback`@.
noTerminalBellCallback :: Maybe TerminalBellCallback
noTerminalBellCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalBellCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalBellCallback`.
foreign import ccall "wrapper"
    mk_TerminalBellCallback :: C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalBell :: TerminalBellCallback -> IO Closure
genClosure_TerminalBell cb = do
    let cb' = wrap_TerminalBellCallback cb
    mk_TerminalBellCallback cb' >>= newCClosure


-- | Wrap a `TerminalBellCallback` into a `C_TerminalBellCallback`.
wrap_TerminalBellCallback ::
    TerminalBellCallback ->
    C_TerminalBellCallback
wrap_TerminalBellCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@bell@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #bell callback
@
-}
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

{- |
Connect a signal handler for the “@bell@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #bell callback
@
-}
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
{- |
Emitted whenever the cell size changes, e.g. due to a change in
font, font-scale or cell-width\/height-scale.

Note that this signal should rather be called \"cell-size-changed\".
-}
type TerminalCharSizeChangedCallback =
    Word32
    {- ^ /@width@/: the new character cell width -}
    -> Word32
    {- ^ /@height@/: the new character cell height -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCharSizeChangedCallback`@.
noTerminalCharSizeChangedCallback :: Maybe TerminalCharSizeChangedCallback
noTerminalCharSizeChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCharSizeChangedCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCharSizeChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCharSizeChangedCallback :: C_TerminalCharSizeChangedCallback -> IO (FunPtr C_TerminalCharSizeChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCharSizeChanged :: TerminalCharSizeChangedCallback -> IO Closure
genClosure_TerminalCharSizeChanged cb = do
    let cb' = wrap_TerminalCharSizeChangedCallback cb
    mk_TerminalCharSizeChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalCharSizeChangedCallback` into a `C_TerminalCharSizeChangedCallback`.
wrap_TerminalCharSizeChangedCallback ::
    TerminalCharSizeChangedCallback ->
    C_TerminalCharSizeChangedCallback
wrap_TerminalCharSizeChangedCallback _cb _ width height _ = do
    _cb  width height


{- |
Connect a signal handler for the “@char-size-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #charSizeChanged callback
@
-}
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

{- |
Connect a signal handler for the “@char-size-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #charSizeChanged callback
@
-}
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
{- |
This signal is emitted when the terminal detects that a child
watched using 'GI.Vte.Objects.Terminal.terminalWatchChild' has exited.
-}
type TerminalChildExitedCallback =
    Int32
    {- ^ /@status@/: the child\'s exit status -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalChildExitedCallback`@.
noTerminalChildExitedCallback :: Maybe TerminalChildExitedCallback
noTerminalChildExitedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalChildExitedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalChildExitedCallback`.
foreign import ccall "wrapper"
    mk_TerminalChildExitedCallback :: C_TerminalChildExitedCallback -> IO (FunPtr C_TerminalChildExitedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalChildExited :: TerminalChildExitedCallback -> IO Closure
genClosure_TerminalChildExited cb = do
    let cb' = wrap_TerminalChildExitedCallback cb
    mk_TerminalChildExitedCallback cb' >>= newCClosure


-- | Wrap a `TerminalChildExitedCallback` into a `C_TerminalChildExitedCallback`.
wrap_TerminalChildExitedCallback ::
    TerminalChildExitedCallback ->
    C_TerminalChildExitedCallback
wrap_TerminalChildExitedCallback _cb _ status _ = do
    _cb  status


{- |
Connect a signal handler for the “@child-exited@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #childExited callback
@
-}
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

{- |
Connect a signal handler for the “@child-exited@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #childExited callback
@
-}
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
{- |
Emitted whenever the terminal receives input from the user and
prepares to send it to the child process.  The signal is emitted even
when there is no child process.
-}
type TerminalCommitCallback =
    T.Text
    {- ^ /@text@/: a string of text -}
    -> Word32
    {- ^ /@size@/: the length of that string of text -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCommitCallback`@.
noTerminalCommitCallback :: Maybe TerminalCommitCallback
noTerminalCommitCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCommitCallback =
    Ptr () ->                               -- object
    CString ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCommitCallback`.
foreign import ccall "wrapper"
    mk_TerminalCommitCallback :: C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCommit :: TerminalCommitCallback -> IO Closure
genClosure_TerminalCommit cb = do
    let cb' = wrap_TerminalCommitCallback cb
    mk_TerminalCommitCallback cb' >>= newCClosure


-- | Wrap a `TerminalCommitCallback` into a `C_TerminalCommitCallback`.
wrap_TerminalCommitCallback ::
    TerminalCommitCallback ->
    C_TerminalCommitCallback
wrap_TerminalCommitCallback _cb _ text size _ = do
    text' <- cstringToText text
    _cb  text' size


{- |
Connect a signal handler for the “@commit@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #commit callback
@
-}
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

{- |
Connect a signal handler for the “@commit@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #commit callback
@
-}
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
{- |
Emitted whenever the visible appearance of the terminal has changed.
Used primarily by @/VteTerminalAccessible/@.
-}
type TerminalContentsChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalContentsChangedCallback`@.
noTerminalContentsChangedCallback :: Maybe TerminalContentsChangedCallback
noTerminalContentsChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalContentsChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalContentsChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalContentsChangedCallback :: C_TerminalContentsChangedCallback -> IO (FunPtr C_TerminalContentsChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalContentsChanged :: TerminalContentsChangedCallback -> IO Closure
genClosure_TerminalContentsChanged cb = do
    let cb' = wrap_TerminalContentsChangedCallback cb
    mk_TerminalContentsChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalContentsChangedCallback` into a `C_TerminalContentsChangedCallback`.
wrap_TerminalContentsChangedCallback ::
    TerminalContentsChangedCallback ->
    C_TerminalContentsChangedCallback
wrap_TerminalContentsChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@contents-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #contentsChanged callback
@
-}
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

{- |
Connect a signal handler for the “@contents-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #contentsChanged callback
@
-}
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
{- |
Emitted whenever 'GI.Vte.Objects.Terminal.terminalCopyClipboard' is called.
-}
type TerminalCopyClipboardCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCopyClipboardCallback`@.
noTerminalCopyClipboardCallback :: Maybe TerminalCopyClipboardCallback
noTerminalCopyClipboardCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCopyClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCopyClipboardCallback`.
foreign import ccall "wrapper"
    mk_TerminalCopyClipboardCallback :: C_TerminalCopyClipboardCallback -> IO (FunPtr C_TerminalCopyClipboardCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCopyClipboard :: TerminalCopyClipboardCallback -> IO Closure
genClosure_TerminalCopyClipboard cb = do
    let cb' = wrap_TerminalCopyClipboardCallback cb
    mk_TerminalCopyClipboardCallback cb' >>= newCClosure


-- | Wrap a `TerminalCopyClipboardCallback` into a `C_TerminalCopyClipboardCallback`.
wrap_TerminalCopyClipboardCallback ::
    TerminalCopyClipboardCallback ->
    C_TerminalCopyClipboardCallback
wrap_TerminalCopyClipboardCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@copy-clipboard@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #copyClipboard callback
@
-}
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

{- |
Connect a signal handler for the “@copy-clipboard@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #copyClipboard callback
@
-}
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
{- |
Emitted when the current directory URI is modified.
-}
type TerminalCurrentDirectoryUriChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentDirectoryUriChangedCallback`@.
noTerminalCurrentDirectoryUriChangedCallback :: Maybe TerminalCurrentDirectoryUriChangedCallback
noTerminalCurrentDirectoryUriChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCurrentDirectoryUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentDirectoryUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCurrentDirectoryUriChangedCallback :: C_TerminalCurrentDirectoryUriChangedCallback -> IO (FunPtr C_TerminalCurrentDirectoryUriChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCurrentDirectoryUriChanged :: TerminalCurrentDirectoryUriChangedCallback -> IO Closure
genClosure_TerminalCurrentDirectoryUriChanged cb = do
    let cb' = wrap_TerminalCurrentDirectoryUriChangedCallback cb
    mk_TerminalCurrentDirectoryUriChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalCurrentDirectoryUriChangedCallback` into a `C_TerminalCurrentDirectoryUriChangedCallback`.
wrap_TerminalCurrentDirectoryUriChangedCallback ::
    TerminalCurrentDirectoryUriChangedCallback ->
    C_TerminalCurrentDirectoryUriChangedCallback
wrap_TerminalCurrentDirectoryUriChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@current-directory-uri-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #currentDirectoryUriChanged callback
@
-}
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

{- |
Connect a signal handler for the “@current-directory-uri-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #currentDirectoryUriChanged callback
@
-}
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
{- |
Emitted when the current file URI is modified.
-}
type TerminalCurrentFileUriChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCurrentFileUriChangedCallback`@.
noTerminalCurrentFileUriChangedCallback :: Maybe TerminalCurrentFileUriChangedCallback
noTerminalCurrentFileUriChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCurrentFileUriChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCurrentFileUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCurrentFileUriChangedCallback :: C_TerminalCurrentFileUriChangedCallback -> IO (FunPtr C_TerminalCurrentFileUriChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCurrentFileUriChanged :: TerminalCurrentFileUriChangedCallback -> IO Closure
genClosure_TerminalCurrentFileUriChanged cb = do
    let cb' = wrap_TerminalCurrentFileUriChangedCallback cb
    mk_TerminalCurrentFileUriChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalCurrentFileUriChangedCallback` into a `C_TerminalCurrentFileUriChangedCallback`.
wrap_TerminalCurrentFileUriChangedCallback ::
    TerminalCurrentFileUriChangedCallback ->
    C_TerminalCurrentFileUriChangedCallback
wrap_TerminalCurrentFileUriChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@current-file-uri-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #currentFileUriChanged callback
@
-}
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

{- |
Connect a signal handler for the “@current-file-uri-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #currentFileUriChanged callback
@
-}
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
{- |
Emitted whenever the cursor moves to a new character cell.  Used
primarily by @/VteTerminalAccessible/@.
-}
type TerminalCursorMovedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalCursorMovedCallback`@.
noTerminalCursorMovedCallback :: Maybe TerminalCursorMovedCallback
noTerminalCursorMovedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalCursorMovedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalCursorMovedCallback`.
foreign import ccall "wrapper"
    mk_TerminalCursorMovedCallback :: C_TerminalCursorMovedCallback -> IO (FunPtr C_TerminalCursorMovedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalCursorMoved :: TerminalCursorMovedCallback -> IO Closure
genClosure_TerminalCursorMoved cb = do
    let cb' = wrap_TerminalCursorMovedCallback cb
    mk_TerminalCursorMovedCallback cb' >>= newCClosure


-- | Wrap a `TerminalCursorMovedCallback` into a `C_TerminalCursorMovedCallback`.
wrap_TerminalCursorMovedCallback ::
    TerminalCursorMovedCallback ->
    C_TerminalCursorMovedCallback
wrap_TerminalCursorMovedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@cursor-moved@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #cursorMoved callback
@
-}
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

{- |
Connect a signal handler for the “@cursor-moved@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #cursorMoved callback
@
-}
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
{- |
Emitted when the user hits the \'-\' key while holding the Control key.
-}
type TerminalDecreaseFontSizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDecreaseFontSizeCallback`@.
noTerminalDecreaseFontSizeCallback :: Maybe TerminalDecreaseFontSizeCallback
noTerminalDecreaseFontSizeCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalDecreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalDecreaseFontSizeCallback`.
foreign import ccall "wrapper"
    mk_TerminalDecreaseFontSizeCallback :: C_TerminalDecreaseFontSizeCallback -> IO (FunPtr C_TerminalDecreaseFontSizeCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalDecreaseFontSize :: TerminalDecreaseFontSizeCallback -> IO Closure
genClosure_TerminalDecreaseFontSize cb = do
    let cb' = wrap_TerminalDecreaseFontSizeCallback cb
    mk_TerminalDecreaseFontSizeCallback cb' >>= newCClosure


-- | Wrap a `TerminalDecreaseFontSizeCallback` into a `C_TerminalDecreaseFontSizeCallback`.
wrap_TerminalDecreaseFontSizeCallback ::
    TerminalDecreaseFontSizeCallback ->
    C_TerminalDecreaseFontSizeCallback
wrap_TerminalDecreaseFontSizeCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@decrease-font-size@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #decreaseFontSize callback
@
-}
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

{- |
Connect a signal handler for the “@decrease-font-size@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #decreaseFontSize callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalDeiconifyWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalDeiconifyWindowCallback`@.
noTerminalDeiconifyWindowCallback :: Maybe TerminalDeiconifyWindowCallback
noTerminalDeiconifyWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalDeiconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalDeiconifyWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalDeiconifyWindowCallback :: C_TerminalDeiconifyWindowCallback -> IO (FunPtr C_TerminalDeiconifyWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalDeiconifyWindow :: TerminalDeiconifyWindowCallback -> IO Closure
genClosure_TerminalDeiconifyWindow cb = do
    let cb' = wrap_TerminalDeiconifyWindowCallback cb
    mk_TerminalDeiconifyWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalDeiconifyWindowCallback` into a `C_TerminalDeiconifyWindowCallback`.
wrap_TerminalDeiconifyWindowCallback ::
    TerminalDeiconifyWindowCallback ->
    C_TerminalDeiconifyWindowCallback
wrap_TerminalDeiconifyWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@deiconify-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #deiconifyWindow callback
@
-}
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

{- |
Connect a signal handler for the “@deiconify-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #deiconifyWindow callback
@
-}
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
{- |
Emitted whenever the terminal\'s current encoding has changed, either
as a result of receiving a control sequence which toggled between the
local and UTF-8 encodings, or at the parent application\'s request.
-}
type TerminalEncodingChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEncodingChangedCallback`@.
noTerminalEncodingChangedCallback :: Maybe TerminalEncodingChangedCallback
noTerminalEncodingChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalEncodingChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalEncodingChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalEncodingChangedCallback :: C_TerminalEncodingChangedCallback -> IO (FunPtr C_TerminalEncodingChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalEncodingChanged :: TerminalEncodingChangedCallback -> IO Closure
genClosure_TerminalEncodingChanged cb = do
    let cb' = wrap_TerminalEncodingChangedCallback cb
    mk_TerminalEncodingChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalEncodingChangedCallback` into a `C_TerminalEncodingChangedCallback`.
wrap_TerminalEncodingChangedCallback ::
    TerminalEncodingChangedCallback ->
    C_TerminalEncodingChangedCallback
wrap_TerminalEncodingChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@encoding-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #encodingChanged callback
@
-}
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

{- |
Connect a signal handler for the “@encoding-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #encodingChanged callback
@
-}
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
{- |
Emitted when the terminal receives an end-of-file from a child which
is running in the terminal.  This signal is frequently (but not
always) emitted with a 'GI.Vte.Objects.Terminal.Terminal'::@/child-exited/@ signal.
-}
type TerminalEofCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalEofCallback`@.
noTerminalEofCallback :: Maybe TerminalEofCallback
noTerminalEofCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalEofCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalEofCallback`.
foreign import ccall "wrapper"
    mk_TerminalEofCallback :: C_TerminalEofCallback -> IO (FunPtr C_TerminalEofCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalEof :: TerminalEofCallback -> IO Closure
genClosure_TerminalEof cb = do
    let cb' = wrap_TerminalEofCallback cb
    mk_TerminalEofCallback cb' >>= newCClosure


-- | Wrap a `TerminalEofCallback` into a `C_TerminalEofCallback`.
wrap_TerminalEofCallback ::
    TerminalEofCallback ->
    C_TerminalEofCallback
wrap_TerminalEofCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@eof@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #eof callback
@
-}
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

{- |
Connect a signal handler for the “@eof@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #eof callback
@
-}
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::hyperlink-hover-uri-changed
{- |
Emitted when the hovered hyperlink changes.

/@uri@/ and /@bbox@/ are owned by VTE, must not be modified, and might
change after the signal handlers returns.

The signal is not re-emitted when the bounding box changes for the
same hyperlink. This might change in a future VTE version without notice.

/Since: 0.50/
-}
type TerminalHyperlinkHoverUriChangedCallback =
    T.Text
    {- ^ /@uri@/: the nonempty target URI under the mouse, or NULL -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@bbox@/: the bounding box of the hyperlink anchor text, or NULL -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalHyperlinkHoverUriChangedCallback`@.
noTerminalHyperlinkHoverUriChangedCallback :: Maybe TerminalHyperlinkHoverUriChangedCallback
noTerminalHyperlinkHoverUriChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalHyperlinkHoverUriChangedCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalHyperlinkHoverUriChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalHyperlinkHoverUriChangedCallback :: C_TerminalHyperlinkHoverUriChangedCallback -> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalHyperlinkHoverUriChanged :: TerminalHyperlinkHoverUriChangedCallback -> IO Closure
genClosure_TerminalHyperlinkHoverUriChanged cb = do
    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb
    mk_TerminalHyperlinkHoverUriChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalHyperlinkHoverUriChangedCallback` into a `C_TerminalHyperlinkHoverUriChangedCallback`.
wrap_TerminalHyperlinkHoverUriChangedCallback ::
    TerminalHyperlinkHoverUriChangedCallback ->
    C_TerminalHyperlinkHoverUriChangedCallback
wrap_TerminalHyperlinkHoverUriChangedCallback _cb _ uri bbox _ = do
    uri' <- cstringToText uri
    B.ManagedPtr.withTransient Gdk.Rectangle.Rectangle bbox $ \bbox' -> do
        _cb  uri' bbox'


{- |
Connect a signal handler for the “@hyperlink-hover-uri-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #hyperlinkHoverUriChanged callback
@
-}
onTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
onTerminalHyperlinkHoverUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb
    cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'
    connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@hyperlink-hover-uri-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #hyperlinkHoverUriChanged callback
@
-}
afterTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId
afterTerminalHyperlinkHoverUriChanged obj cb = liftIO $ do
    let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb
    cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'
    connectSignalFunPtr obj "hyperlink-hover-uri-changed" cb'' SignalConnectAfter


-- signal Terminal::icon-title-changed
{- |
Emitted when the terminal\'s @/icon_title/@ field is modified.
-}
type TerminalIconTitleChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconTitleChangedCallback`@.
noTerminalIconTitleChangedCallback :: Maybe TerminalIconTitleChangedCallback
noTerminalIconTitleChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIconTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIconTitleChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalIconTitleChangedCallback :: C_TerminalIconTitleChangedCallback -> IO (FunPtr C_TerminalIconTitleChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalIconTitleChanged :: TerminalIconTitleChangedCallback -> IO Closure
genClosure_TerminalIconTitleChanged cb = do
    let cb' = wrap_TerminalIconTitleChangedCallback cb
    mk_TerminalIconTitleChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalIconTitleChangedCallback` into a `C_TerminalIconTitleChangedCallback`.
wrap_TerminalIconTitleChangedCallback ::
    TerminalIconTitleChangedCallback ->
    C_TerminalIconTitleChangedCallback
wrap_TerminalIconTitleChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@icon-title-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #iconTitleChanged callback
@
-}
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

{- |
Connect a signal handler for the “@icon-title-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #iconTitleChanged callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalIconifyWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIconifyWindowCallback`@.
noTerminalIconifyWindowCallback :: Maybe TerminalIconifyWindowCallback
noTerminalIconifyWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIconifyWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIconifyWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalIconifyWindowCallback :: C_TerminalIconifyWindowCallback -> IO (FunPtr C_TerminalIconifyWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalIconifyWindow :: TerminalIconifyWindowCallback -> IO Closure
genClosure_TerminalIconifyWindow cb = do
    let cb' = wrap_TerminalIconifyWindowCallback cb
    mk_TerminalIconifyWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalIconifyWindowCallback` into a `C_TerminalIconifyWindowCallback`.
wrap_TerminalIconifyWindowCallback ::
    TerminalIconifyWindowCallback ->
    C_TerminalIconifyWindowCallback
wrap_TerminalIconifyWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@iconify-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #iconifyWindow callback
@
-}
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

{- |
Connect a signal handler for the “@iconify-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #iconifyWindow callback
@
-}
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
{- |
Emitted when the user hits the \'+\' key while holding the Control key.
-}
type TerminalIncreaseFontSizeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalIncreaseFontSizeCallback`@.
noTerminalIncreaseFontSizeCallback :: Maybe TerminalIncreaseFontSizeCallback
noTerminalIncreaseFontSizeCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalIncreaseFontSizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalIncreaseFontSizeCallback`.
foreign import ccall "wrapper"
    mk_TerminalIncreaseFontSizeCallback :: C_TerminalIncreaseFontSizeCallback -> IO (FunPtr C_TerminalIncreaseFontSizeCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalIncreaseFontSize :: TerminalIncreaseFontSizeCallback -> IO Closure
genClosure_TerminalIncreaseFontSize cb = do
    let cb' = wrap_TerminalIncreaseFontSizeCallback cb
    mk_TerminalIncreaseFontSizeCallback cb' >>= newCClosure


-- | Wrap a `TerminalIncreaseFontSizeCallback` into a `C_TerminalIncreaseFontSizeCallback`.
wrap_TerminalIncreaseFontSizeCallback ::
    TerminalIncreaseFontSizeCallback ->
    C_TerminalIncreaseFontSizeCallback
wrap_TerminalIncreaseFontSizeCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@increase-font-size@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #increaseFontSize callback
@
-}
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

{- |
Connect a signal handler for the “@increase-font-size@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #increaseFontSize callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalLowerWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalLowerWindowCallback`@.
noTerminalLowerWindowCallback :: Maybe TerminalLowerWindowCallback
noTerminalLowerWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalLowerWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalLowerWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalLowerWindowCallback :: C_TerminalLowerWindowCallback -> IO (FunPtr C_TerminalLowerWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalLowerWindow :: TerminalLowerWindowCallback -> IO Closure
genClosure_TerminalLowerWindow cb = do
    let cb' = wrap_TerminalLowerWindowCallback cb
    mk_TerminalLowerWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalLowerWindowCallback` into a `C_TerminalLowerWindowCallback`.
wrap_TerminalLowerWindowCallback ::
    TerminalLowerWindowCallback ->
    C_TerminalLowerWindowCallback
wrap_TerminalLowerWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@lower-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #lowerWindow callback
@
-}
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

{- |
Connect a signal handler for the “@lower-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #lowerWindow callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalMaximizeWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMaximizeWindowCallback`@.
noTerminalMaximizeWindowCallback :: Maybe TerminalMaximizeWindowCallback
noTerminalMaximizeWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalMaximizeWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalMaximizeWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalMaximizeWindowCallback :: C_TerminalMaximizeWindowCallback -> IO (FunPtr C_TerminalMaximizeWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalMaximizeWindow :: TerminalMaximizeWindowCallback -> IO Closure
genClosure_TerminalMaximizeWindow cb = do
    let cb' = wrap_TerminalMaximizeWindowCallback cb
    mk_TerminalMaximizeWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalMaximizeWindowCallback` into a `C_TerminalMaximizeWindowCallback`.
wrap_TerminalMaximizeWindowCallback ::
    TerminalMaximizeWindowCallback ->
    C_TerminalMaximizeWindowCallback
wrap_TerminalMaximizeWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@maximize-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #maximizeWindow callback
@
-}
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

{- |
Connect a signal handler for the “@maximize-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #maximizeWindow callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalMoveWindowCallback =
    Word32
    {- ^ /@x@/: the terminal\'s desired location, X coordinate -}
    -> Word32
    {- ^ /@y@/: the terminal\'s desired location, Y coordinate -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalMoveWindowCallback`@.
noTerminalMoveWindowCallback :: Maybe TerminalMoveWindowCallback
noTerminalMoveWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalMoveWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalMoveWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalMoveWindowCallback :: C_TerminalMoveWindowCallback -> IO (FunPtr C_TerminalMoveWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalMoveWindow :: TerminalMoveWindowCallback -> IO Closure
genClosure_TerminalMoveWindow cb = do
    let cb' = wrap_TerminalMoveWindowCallback cb
    mk_TerminalMoveWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalMoveWindowCallback` into a `C_TerminalMoveWindowCallback`.
wrap_TerminalMoveWindowCallback ::
    TerminalMoveWindowCallback ->
    C_TerminalMoveWindowCallback
wrap_TerminalMoveWindowCallback _cb _ x y _ = do
    _cb  x y


{- |
Connect a signal handler for the “@move-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #moveWindow callback
@
-}
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

{- |
Connect a signal handler for the “@move-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #moveWindow callback
@
-}
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
{- |
Emitted when a process running in the terminal wants to
send a notification to the desktop environment.
-}
type TerminalNotificationReceivedCallback =
    T.Text
    {- ^ /@summary@/: The summary -}
    -> Maybe T.Text
    {- ^ /@body@/: Extra optional text -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalNotificationReceivedCallback`@.
noTerminalNotificationReceivedCallback :: Maybe TerminalNotificationReceivedCallback
noTerminalNotificationReceivedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalNotificationReceivedCallback =
    Ptr () ->                               -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalNotificationReceivedCallback`.
foreign import ccall "wrapper"
    mk_TerminalNotificationReceivedCallback :: C_TerminalNotificationReceivedCallback -> IO (FunPtr C_TerminalNotificationReceivedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalNotificationReceived :: TerminalNotificationReceivedCallback -> IO Closure
genClosure_TerminalNotificationReceived cb = do
    let cb' = wrap_TerminalNotificationReceivedCallback cb
    mk_TerminalNotificationReceivedCallback cb' >>= newCClosure


-- | Wrap a `TerminalNotificationReceivedCallback` into a `C_TerminalNotificationReceivedCallback`.
wrap_TerminalNotificationReceivedCallback ::
    TerminalNotificationReceivedCallback ->
    C_TerminalNotificationReceivedCallback
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


{- |
Connect a signal handler for the “@notification-received@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #notificationReceived callback
@
-}
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

{- |
Connect a signal handler for the “@notification-received@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #notificationReceived callback
@
-}
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
{- |
Emitted whenever 'GI.Vte.Objects.Terminal.terminalPasteClipboard' is called.
-}
type TerminalPasteClipboardCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalPasteClipboardCallback`@.
noTerminalPasteClipboardCallback :: Maybe TerminalPasteClipboardCallback
noTerminalPasteClipboardCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalPasteClipboardCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalPasteClipboardCallback`.
foreign import ccall "wrapper"
    mk_TerminalPasteClipboardCallback :: C_TerminalPasteClipboardCallback -> IO (FunPtr C_TerminalPasteClipboardCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalPasteClipboard :: TerminalPasteClipboardCallback -> IO Closure
genClosure_TerminalPasteClipboard cb = do
    let cb' = wrap_TerminalPasteClipboardCallback cb
    mk_TerminalPasteClipboardCallback cb' >>= newCClosure


-- | Wrap a `TerminalPasteClipboardCallback` into a `C_TerminalPasteClipboardCallback`.
wrap_TerminalPasteClipboardCallback ::
    TerminalPasteClipboardCallback ->
    C_TerminalPasteClipboardCallback
wrap_TerminalPasteClipboardCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@paste-clipboard@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #pasteClipboard callback
@
-}
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

{- |
Connect a signal handler for the “@paste-clipboard@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #pasteClipboard callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalRaiseWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRaiseWindowCallback`@.
noTerminalRaiseWindowCallback :: Maybe TerminalRaiseWindowCallback
noTerminalRaiseWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRaiseWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRaiseWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRaiseWindowCallback :: C_TerminalRaiseWindowCallback -> IO (FunPtr C_TerminalRaiseWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalRaiseWindow :: TerminalRaiseWindowCallback -> IO Closure
genClosure_TerminalRaiseWindow cb = do
    let cb' = wrap_TerminalRaiseWindowCallback cb
    mk_TerminalRaiseWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalRaiseWindowCallback` into a `C_TerminalRaiseWindowCallback`.
wrap_TerminalRaiseWindowCallback ::
    TerminalRaiseWindowCallback ->
    C_TerminalRaiseWindowCallback
wrap_TerminalRaiseWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@raise-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #raiseWindow callback
@
-}
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

{- |
Connect a signal handler for the “@raise-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #raiseWindow callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalRefreshWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRefreshWindowCallback`@.
noTerminalRefreshWindowCallback :: Maybe TerminalRefreshWindowCallback
noTerminalRefreshWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRefreshWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRefreshWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRefreshWindowCallback :: C_TerminalRefreshWindowCallback -> IO (FunPtr C_TerminalRefreshWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalRefreshWindow :: TerminalRefreshWindowCallback -> IO Closure
genClosure_TerminalRefreshWindow cb = do
    let cb' = wrap_TerminalRefreshWindowCallback cb
    mk_TerminalRefreshWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalRefreshWindowCallback` into a `C_TerminalRefreshWindowCallback`.
wrap_TerminalRefreshWindowCallback ::
    TerminalRefreshWindowCallback ->
    C_TerminalRefreshWindowCallback
wrap_TerminalRefreshWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@refresh-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #refreshWindow callback
@
-}
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

{- |
Connect a signal handler for the “@refresh-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #refreshWindow callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalResizeWindowCallback =
    Word32
    {- ^ /@width@/: the desired number of columns -}
    -> Word32
    {- ^ /@height@/: the desired number of rows -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalResizeWindowCallback`@.
noTerminalResizeWindowCallback :: Maybe TerminalResizeWindowCallback
noTerminalResizeWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalResizeWindowCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalResizeWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalResizeWindowCallback :: C_TerminalResizeWindowCallback -> IO (FunPtr C_TerminalResizeWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalResizeWindow :: TerminalResizeWindowCallback -> IO Closure
genClosure_TerminalResizeWindow cb = do
    let cb' = wrap_TerminalResizeWindowCallback cb
    mk_TerminalResizeWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalResizeWindowCallback` into a `C_TerminalResizeWindowCallback`.
wrap_TerminalResizeWindowCallback ::
    TerminalResizeWindowCallback ->
    C_TerminalResizeWindowCallback
wrap_TerminalResizeWindowCallback _cb _ width height _ = do
    _cb  width height


{- |
Connect a signal handler for the “@resize-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #resizeWindow callback
@
-}
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

{- |
Connect a signal handler for the “@resize-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #resizeWindow callback
@
-}
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
{- |
Emitted at the child application\'s request.
-}
type TerminalRestoreWindowCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalRestoreWindowCallback`@.
noTerminalRestoreWindowCallback :: Maybe TerminalRestoreWindowCallback
noTerminalRestoreWindowCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalRestoreWindowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalRestoreWindowCallback`.
foreign import ccall "wrapper"
    mk_TerminalRestoreWindowCallback :: C_TerminalRestoreWindowCallback -> IO (FunPtr C_TerminalRestoreWindowCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalRestoreWindow :: TerminalRestoreWindowCallback -> IO Closure
genClosure_TerminalRestoreWindow cb = do
    let cb' = wrap_TerminalRestoreWindowCallback cb
    mk_TerminalRestoreWindowCallback cb' >>= newCClosure


-- | Wrap a `TerminalRestoreWindowCallback` into a `C_TerminalRestoreWindowCallback`.
wrap_TerminalRestoreWindowCallback ::
    TerminalRestoreWindowCallback ->
    C_TerminalRestoreWindowCallback
wrap_TerminalRestoreWindowCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@restore-window@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #restoreWindow callback
@
-}
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

{- |
Connect a signal handler for the “@restore-window@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #restoreWindow callback
@
-}
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
{- |
Emitted whenever the contents of terminal\'s selection changes.
-}
type TerminalSelectionChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalSelectionChangedCallback`@.
noTerminalSelectionChangedCallback :: Maybe TerminalSelectionChangedCallback
noTerminalSelectionChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalSelectionChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalSelectionChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalSelectionChangedCallback :: C_TerminalSelectionChangedCallback -> IO (FunPtr C_TerminalSelectionChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalSelectionChanged :: TerminalSelectionChangedCallback -> IO Closure
genClosure_TerminalSelectionChanged cb = do
    let cb' = wrap_TerminalSelectionChangedCallback cb
    mk_TerminalSelectionChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalSelectionChangedCallback` into a `C_TerminalSelectionChangedCallback`.
wrap_TerminalSelectionChangedCallback ::
    TerminalSelectionChangedCallback ->
    C_TerminalSelectionChangedCallback
wrap_TerminalSelectionChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@selection-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #selectionChanged callback
@
-}
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

{- |
Connect a signal handler for the “@selection-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #selectionChanged callback
@
-}
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
{- |
An internal signal used for communication between the terminal and
its accessibility peer. May not be emitted under certain
circumstances.
-}
type TerminalTextDeletedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextDeletedCallback`@.
noTerminalTextDeletedCallback :: Maybe TerminalTextDeletedCallback
noTerminalTextDeletedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextDeletedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextDeletedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextDeletedCallback :: C_TerminalTextDeletedCallback -> IO (FunPtr C_TerminalTextDeletedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalTextDeleted :: TerminalTextDeletedCallback -> IO Closure
genClosure_TerminalTextDeleted cb = do
    let cb' = wrap_TerminalTextDeletedCallback cb
    mk_TerminalTextDeletedCallback cb' >>= newCClosure


-- | Wrap a `TerminalTextDeletedCallback` into a `C_TerminalTextDeletedCallback`.
wrap_TerminalTextDeletedCallback ::
    TerminalTextDeletedCallback ->
    C_TerminalTextDeletedCallback
wrap_TerminalTextDeletedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@text-deleted@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #textDeleted callback
@
-}
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

{- |
Connect a signal handler for the “@text-deleted@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #textDeleted callback
@
-}
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
{- |
An internal signal used for communication between the terminal and
its accessibility peer. May not be emitted under certain
circumstances.
-}
type TerminalTextInsertedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextInsertedCallback`@.
noTerminalTextInsertedCallback :: Maybe TerminalTextInsertedCallback
noTerminalTextInsertedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextInsertedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextInsertedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextInsertedCallback :: C_TerminalTextInsertedCallback -> IO (FunPtr C_TerminalTextInsertedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalTextInserted :: TerminalTextInsertedCallback -> IO Closure
genClosure_TerminalTextInserted cb = do
    let cb' = wrap_TerminalTextInsertedCallback cb
    mk_TerminalTextInsertedCallback cb' >>= newCClosure


-- | Wrap a `TerminalTextInsertedCallback` into a `C_TerminalTextInsertedCallback`.
wrap_TerminalTextInsertedCallback ::
    TerminalTextInsertedCallback ->
    C_TerminalTextInsertedCallback
wrap_TerminalTextInsertedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@text-inserted@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #textInserted callback
@
-}
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

{- |
Connect a signal handler for the “@text-inserted@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #textInserted callback
@
-}
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
{- |
An internal signal used for communication between the terminal and
its accessibility peer. May not be emitted under certain
circumstances.
-}
type TerminalTextModifiedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextModifiedCallback`@.
noTerminalTextModifiedCallback :: Maybe TerminalTextModifiedCallback
noTerminalTextModifiedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextModifiedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextModifiedCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextModifiedCallback :: C_TerminalTextModifiedCallback -> IO (FunPtr C_TerminalTextModifiedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalTextModified :: TerminalTextModifiedCallback -> IO Closure
genClosure_TerminalTextModified cb = do
    let cb' = wrap_TerminalTextModifiedCallback cb
    mk_TerminalTextModifiedCallback cb' >>= newCClosure


-- | Wrap a `TerminalTextModifiedCallback` into a `C_TerminalTextModifiedCallback`.
wrap_TerminalTextModifiedCallback ::
    TerminalTextModifiedCallback ->
    C_TerminalTextModifiedCallback
wrap_TerminalTextModifiedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@text-modified@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #textModified callback
@
-}
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

{- |
Connect a signal handler for the “@text-modified@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #textModified callback
@
-}
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
{- |
An internal signal used for communication between the terminal and
its accessibility peer. May not be emitted under certain
circumstances.
-}
type TerminalTextScrolledCallback =
    Int32
    {- ^ /@delta@/: the number of lines scrolled -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalTextScrolledCallback`@.
noTerminalTextScrolledCallback :: Maybe TerminalTextScrolledCallback
noTerminalTextScrolledCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalTextScrolledCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalTextScrolledCallback`.
foreign import ccall "wrapper"
    mk_TerminalTextScrolledCallback :: C_TerminalTextScrolledCallback -> IO (FunPtr C_TerminalTextScrolledCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalTextScrolled :: TerminalTextScrolledCallback -> IO Closure
genClosure_TerminalTextScrolled cb = do
    let cb' = wrap_TerminalTextScrolledCallback cb
    mk_TerminalTextScrolledCallback cb' >>= newCClosure


-- | Wrap a `TerminalTextScrolledCallback` into a `C_TerminalTextScrolledCallback`.
wrap_TerminalTextScrolledCallback ::
    TerminalTextScrolledCallback ->
    C_TerminalTextScrolledCallback
wrap_TerminalTextScrolledCallback _cb _ delta _ = do
    _cb  delta


{- |
Connect a signal handler for the “@text-scrolled@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #textScrolled callback
@
-}
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

{- |
Connect a signal handler for the “@text-scrolled@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #textScrolled callback
@
-}
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
{- |
Emitted when the terminal\'s @/window_title/@ field is modified.
-}
type TerminalWindowTitleChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `TerminalWindowTitleChangedCallback`@.
noTerminalWindowTitleChangedCallback :: Maybe TerminalWindowTitleChangedCallback
noTerminalWindowTitleChangedCallback = Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalWindowTitleChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_TerminalWindowTitleChangedCallback`.
foreign import ccall "wrapper"
    mk_TerminalWindowTitleChangedCallback :: C_TerminalWindowTitleChangedCallback -> IO (FunPtr C_TerminalWindowTitleChangedCallback)

-- | Wrap the callback into a `Closure`.
genClosure_TerminalWindowTitleChanged :: TerminalWindowTitleChangedCallback -> IO Closure
genClosure_TerminalWindowTitleChanged cb = do
    let cb' = wrap_TerminalWindowTitleChangedCallback cb
    mk_TerminalWindowTitleChangedCallback cb' >>= newCClosure


-- | Wrap a `TerminalWindowTitleChangedCallback` into a `C_TerminalWindowTitleChangedCallback`.
wrap_TerminalWindowTitleChangedCallback ::
    TerminalWindowTitleChangedCallback ->
    C_TerminalWindowTitleChangedCallback
wrap_TerminalWindowTitleChangedCallback _cb _ _ = do
    _cb


{- |
Connect a signal handler for the “@window-title-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' terminal #windowTitleChanged callback
@
-}
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

{- |
Connect a signal handler for the “@window-title-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' terminal #windowTitleChanged callback
@
-}
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)

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

@
'Data.GI.Base.Attributes.get' terminal #allowBold
@
-}
getTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowBold obj = liftIO $ getObjectPropertyBool obj "allow-bold"

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

@
'Data.GI.Base.Attributes.set' terminal [ #allowBold 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAllowBold obj val = liftIO $ setObjectPropertyBool obj "allow-bold" val

{- |
Construct a `GValueConstruct` with valid value for the “@allow-bold@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalAllowBold :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAllowBold val = constructObjectPropertyBool "allow-bold" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #allowHyperlink
@
-}
getTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAllowHyperlink obj = liftIO $ getObjectPropertyBool obj "allow-hyperlink"

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

@
'Data.GI.Base.Attributes.set' terminal [ #allowHyperlink 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAllowHyperlink obj val = liftIO $ setObjectPropertyBool obj "allow-hyperlink" val

{- |
Construct a `GValueConstruct` with valid value for the “@allow-hyperlink@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalAllowHyperlink :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAllowHyperlink val = constructObjectPropertyBool "allow-hyperlink" val

#if ENABLE_OVERLOADING
data TerminalAllowHyperlinkPropertyInfo
instance AttrInfo TerminalAllowHyperlinkPropertyInfo where
    type AttrAllowedOps TerminalAllowHyperlinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalAllowHyperlinkPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalAllowHyperlinkPropertyInfo = IsTerminal
    type AttrGetType TerminalAllowHyperlinkPropertyInfo = Bool
    type AttrLabel TerminalAllowHyperlinkPropertyInfo = "allow-hyperlink"
    type AttrOrigin TerminalAllowHyperlinkPropertyInfo = Terminal
    attrGet _ = getTerminalAllowHyperlink
    attrSet _ = setTerminalAllowHyperlink
    attrConstruct _ = constructTerminalAllowHyperlink
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #audibleBell
@
-}
getTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalAudibleBell obj = liftIO $ getObjectPropertyBool obj "audible-bell"

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

@
'Data.GI.Base.Attributes.set' terminal [ #audibleBell 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalAudibleBell obj val = liftIO $ setObjectPropertyBool obj "audible-bell" val

{- |
Construct a `GValueConstruct` with valid value for the “@audible-bell@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalAudibleBell :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalAudibleBell val = constructObjectPropertyBool "audible-bell" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #backspaceBinding
@
-}
getTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalBackspaceBinding obj = liftIO $ getObjectPropertyEnum obj "backspace-binding"

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

@
'Data.GI.Base.Attributes.set' terminal [ #backspaceBinding 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalBackspaceBinding obj val = liftIO $ setObjectPropertyEnum obj "backspace-binding" val

{- |
Construct a `GValueConstruct` with valid value for the “@backspace-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalBackspaceBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalBackspaceBinding val = constructObjectPropertyEnum "backspace-binding" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #boldIsBright
@
-}
getTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalBoldIsBright obj = liftIO $ getObjectPropertyBool obj "bold-is-bright"

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

@
'Data.GI.Base.Attributes.set' terminal [ #boldIsBright 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalBoldIsBright obj val = liftIO $ setObjectPropertyBool obj "bold-is-bright" val

{- |
Construct a `GValueConstruct` with valid value for the “@bold-is-bright@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalBoldIsBright :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalBoldIsBright val = constructObjectPropertyBool "bold-is-bright" val

#if ENABLE_OVERLOADING
data TerminalBoldIsBrightPropertyInfo
instance AttrInfo TerminalBoldIsBrightPropertyInfo where
    type AttrAllowedOps TerminalBoldIsBrightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalBoldIsBrightPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint TerminalBoldIsBrightPropertyInfo = IsTerminal
    type AttrGetType TerminalBoldIsBrightPropertyInfo = Bool
    type AttrLabel TerminalBoldIsBrightPropertyInfo = "bold-is-bright"
    type AttrOrigin TerminalBoldIsBrightPropertyInfo = Terminal
    attrGet _ = getTerminalBoldIsBright
    attrSet _ = setTerminalBoldIsBright
    attrConstruct _ = constructTerminalBoldIsBright
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #cellHeightScale
@
-}
getTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellHeightScale obj = liftIO $ getObjectPropertyDouble obj "cell-height-scale"

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

@
'Data.GI.Base.Attributes.set' terminal [ #cellHeightScale 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalCellHeightScale obj val = liftIO $ setObjectPropertyDouble obj "cell-height-scale" val

{- |
Construct a `GValueConstruct` with valid value for the “@cell-height-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalCellHeightScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalCellHeightScale val = constructObjectPropertyDouble "cell-height-scale" val

#if ENABLE_OVERLOADING
data TerminalCellHeightScalePropertyInfo
instance AttrInfo TerminalCellHeightScalePropertyInfo where
    type AttrAllowedOps TerminalCellHeightScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalCellHeightScalePropertyInfo = (~) Double
    type AttrBaseTypeConstraint TerminalCellHeightScalePropertyInfo = IsTerminal
    type AttrGetType TerminalCellHeightScalePropertyInfo = Double
    type AttrLabel TerminalCellHeightScalePropertyInfo = "cell-height-scale"
    type AttrOrigin TerminalCellHeightScalePropertyInfo = Terminal
    attrGet _ = getTerminalCellHeightScale
    attrSet _ = setTerminalCellHeightScale
    attrConstruct _ = constructTerminalCellHeightScale
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #cellWidthScale
@
-}
getTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalCellWidthScale obj = liftIO $ getObjectPropertyDouble obj "cell-width-scale"

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

@
'Data.GI.Base.Attributes.set' terminal [ #cellWidthScale 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalCellWidthScale obj val = liftIO $ setObjectPropertyDouble obj "cell-width-scale" val

{- |
Construct a `GValueConstruct` with valid value for the “@cell-width-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalCellWidthScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalCellWidthScale val = constructObjectPropertyDouble "cell-width-scale" val

#if ENABLE_OVERLOADING
data TerminalCellWidthScalePropertyInfo
instance AttrInfo TerminalCellWidthScalePropertyInfo where
    type AttrAllowedOps TerminalCellWidthScalePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalCellWidthScalePropertyInfo = (~) Double
    type AttrBaseTypeConstraint TerminalCellWidthScalePropertyInfo = IsTerminal
    type AttrGetType TerminalCellWidthScalePropertyInfo = Double
    type AttrLabel TerminalCellWidthScalePropertyInfo = "cell-width-scale"
    type AttrOrigin TerminalCellWidthScalePropertyInfo = Terminal
    attrGet _ = getTerminalCellWidthScale
    attrSet _ = setTerminalCellWidthScale
    attrConstruct _ = constructTerminalCellWidthScale
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #cjkAmbiguousWidth
@
-}
getTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> m Int32
getTerminalCjkAmbiguousWidth obj = liftIO $ getObjectPropertyInt32 obj "cjk-ambiguous-width"

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

@
'Data.GI.Base.Attributes.set' terminal [ #cjkAmbiguousWidth 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> Int32 -> m ()
setTerminalCjkAmbiguousWidth obj val = liftIO $ setObjectPropertyInt32 obj "cjk-ambiguous-width" val

{- |
Construct a `GValueConstruct` with valid value for the “@cjk-ambiguous-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalCjkAmbiguousWidth :: (IsTerminal o) => Int32 -> IO (GValueConstruct o)
constructTerminalCjkAmbiguousWidth val = constructObjectPropertyInt32 "cjk-ambiguous-width" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #currentDirectoryUri
@
-}
getTerminalCurrentDirectoryUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalCurrentDirectoryUri obj = liftIO $ getObjectPropertyString obj "current-directory-uri"

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

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

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

@
'Data.GI.Base.Attributes.get' terminal #currentFileUri
@
-}
getTerminalCurrentFileUri :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalCurrentFileUri obj = liftIO $ checkUnexpectedNothing "getTerminalCurrentFileUri" $ getObjectPropertyString obj "current-file-uri"

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #cursorBlinkMode
@
-}
getTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorBlinkMode
getTerminalCursorBlinkMode obj = liftIO $ getObjectPropertyEnum obj "cursor-blink-mode"

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

@
'Data.GI.Base.Attributes.set' terminal [ #cursorBlinkMode 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorBlinkMode -> m ()
setTerminalCursorBlinkMode obj val = liftIO $ setObjectPropertyEnum obj "cursor-blink-mode" val

{- |
Construct a `GValueConstruct` with valid value for the “@cursor-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalCursorBlinkMode :: (IsTerminal o) => Vte.Enums.CursorBlinkMode -> IO (GValueConstruct o)
constructTerminalCursorBlinkMode val = constructObjectPropertyEnum "cursor-blink-mode" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #cursorShape
@
-}
getTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.CursorShape
getTerminalCursorShape obj = liftIO $ getObjectPropertyEnum obj "cursor-shape"

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

@
'Data.GI.Base.Attributes.set' terminal [ #cursorShape 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.CursorShape -> m ()
setTerminalCursorShape obj val = liftIO $ setObjectPropertyEnum obj "cursor-shape" val

{- |
Construct a `GValueConstruct` with valid value for the “@cursor-shape@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalCursorShape :: (IsTerminal o) => Vte.Enums.CursorShape -> IO (GValueConstruct o)
constructTerminalCursorShape val = constructObjectPropertyEnum "cursor-shape" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #deleteBinding
@
-}
getTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.EraseBinding
getTerminalDeleteBinding obj = liftIO $ getObjectPropertyEnum obj "delete-binding"

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

@
'Data.GI.Base.Attributes.set' terminal [ #deleteBinding 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.EraseBinding -> m ()
setTerminalDeleteBinding obj val = liftIO $ setObjectPropertyEnum obj "delete-binding" val

{- |
Construct a `GValueConstruct` with valid value for the “@delete-binding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalDeleteBinding :: (IsTerminal o) => Vte.Enums.EraseBinding -> IO (GValueConstruct o)
constructTerminalDeleteBinding val = constructObjectPropertyEnum "delete-binding" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #encoding
@
-}
getTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalEncoding obj = liftIO $ checkUnexpectedNothing "getTerminalEncoding" $ getObjectPropertyString obj "encoding"

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

@
'Data.GI.Base.Attributes.set' terminal [ #encoding 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> T.Text -> m ()
setTerminalEncoding obj val = liftIO $ setObjectPropertyString obj "encoding" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@encoding@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalEncoding :: (IsTerminal o) => T.Text -> IO (GValueConstruct o)
constructTerminalEncoding val = constructObjectPropertyString "encoding" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #encoding
@
-}
clearTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalEncoding obj = liftIO $ setObjectPropertyString obj "encoding" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #fontDesc
@
-}
getTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m (Maybe Pango.FontDescription.FontDescription)
getTerminalFontDesc obj = liftIO $ getObjectPropertyBoxed obj "font-desc" Pango.FontDescription.FontDescription

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

@
'Data.GI.Base.Attributes.set' terminal [ #fontDesc 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> Pango.FontDescription.FontDescription -> m ()
setTerminalFontDesc obj val = liftIO $ setObjectPropertyBoxed obj "font-desc" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalFontDesc :: (IsTerminal o) => Pango.FontDescription.FontDescription -> IO (GValueConstruct o)
constructTerminalFontDesc val = constructObjectPropertyBoxed "font-desc" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #fontDesc
@
-}
clearTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalFontDesc obj = liftIO $ setObjectPropertyBoxed obj "font-desc" (Nothing :: Maybe Pango.FontDescription.FontDescription)

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #fontScale
@
-}
getTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> m Double
getTerminalFontScale obj = liftIO $ getObjectPropertyDouble obj "font-scale"

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

@
'Data.GI.Base.Attributes.set' terminal [ #fontScale 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()
setTerminalFontScale obj val = liftIO $ setObjectPropertyDouble obj "font-scale" val

{- |
Construct a `GValueConstruct` with valid value for the “@font-scale@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalFontScale :: (IsTerminal o) => Double -> IO (GValueConstruct o)
constructTerminalFontScale val = constructObjectPropertyDouble "font-scale" val

#if ENABLE_OVERLOADING
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
#endif

-- VVV Prop "hyperlink-hover-uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

@
'Data.GI.Base.Attributes.get' terminal #hyperlinkHoverUri
@
-}
getTerminalHyperlinkHoverUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalHyperlinkHoverUri obj = liftIO $ getObjectPropertyString obj "hyperlink-hover-uri"

#if ENABLE_OVERLOADING
data TerminalHyperlinkHoverUriPropertyInfo
instance AttrInfo TerminalHyperlinkHoverUriPropertyInfo where
    type AttrAllowedOps TerminalHyperlinkHoverUriPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = (~) ()
    type AttrBaseTypeConstraint TerminalHyperlinkHoverUriPropertyInfo = IsTerminal
    type AttrGetType TerminalHyperlinkHoverUriPropertyInfo = (Maybe T.Text)
    type AttrLabel TerminalHyperlinkHoverUriPropertyInfo = "hyperlink-hover-uri"
    type AttrOrigin TerminalHyperlinkHoverUriPropertyInfo = Terminal
    attrGet _ = getTerminalHyperlinkHoverUri
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #iconTitle
@
-}
getTerminalIconTitle :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalIconTitle obj = liftIO $ checkUnexpectedNothing "getTerminalIconTitle" $ getObjectPropertyString obj "icon-title"

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #inputEnabled
@
-}
getTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalInputEnabled obj = liftIO $ getObjectPropertyBool obj "input-enabled"

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

@
'Data.GI.Base.Attributes.set' terminal [ #inputEnabled 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalInputEnabled obj val = liftIO $ setObjectPropertyBool obj "input-enabled" val

{- |
Construct a `GValueConstruct` with valid value for the “@input-enabled@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalInputEnabled :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalInputEnabled val = constructObjectPropertyBool "input-enabled" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #pointerAutohide
@
-}
getTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalPointerAutohide obj = liftIO $ getObjectPropertyBool obj "pointer-autohide"

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

@
'Data.GI.Base.Attributes.set' terminal [ #pointerAutohide 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalPointerAutohide obj val = liftIO $ setObjectPropertyBool obj "pointer-autohide" val

{- |
Construct a `GValueConstruct` with valid value for the “@pointer-autohide@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalPointerAutohide :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalPointerAutohide val = constructObjectPropertyBool "pointer-autohide" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #pty
@
-}
getTerminalPty :: (MonadIO m, IsTerminal o) => o -> m Vte.Pty.Pty
getTerminalPty obj = liftIO $ checkUnexpectedNothing "getTerminalPty" $ getObjectPropertyObject obj "pty" Vte.Pty.Pty

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

@
'Data.GI.Base.Attributes.set' terminal [ #pty 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalPty :: (MonadIO m, IsTerminal o, Vte.Pty.IsPty a) => o -> a -> m ()
setTerminalPty obj val = liftIO $ setObjectPropertyObject obj "pty" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@pty@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalPty :: (IsTerminal o, Vte.Pty.IsPty a) => a -> IO (GValueConstruct o)
constructTerminalPty val = constructObjectPropertyObject "pty" (Just val)

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

@
'Data.GI.Base.Attributes.clear' #pty
@
-}
clearTerminalPty :: (MonadIO m, IsTerminal o) => o -> m ()
clearTerminalPty obj = liftIO $ setObjectPropertyObject obj "pty" (Nothing :: Maybe Vte.Pty.Pty)

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #rewrapOnResize
@
-}
getTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalRewrapOnResize obj = liftIO $ getObjectPropertyBool obj "rewrap-on-resize"

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

@
'Data.GI.Base.Attributes.set' terminal [ #rewrapOnResize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalRewrapOnResize obj val = liftIO $ setObjectPropertyBool obj "rewrap-on-resize" val

{- |
Construct a `GValueConstruct` with valid value for the “@rewrap-on-resize@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalRewrapOnResize :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalRewrapOnResize val = constructObjectPropertyBool "rewrap-on-resize" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #scrollOnKeystroke
@
-}
getTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnKeystroke obj = liftIO $ getObjectPropertyBool obj "scroll-on-keystroke"

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

@
'Data.GI.Base.Attributes.set' terminal [ #scrollOnKeystroke 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnKeystroke obj val = liftIO $ setObjectPropertyBool obj "scroll-on-keystroke" val

{- |
Construct a `GValueConstruct` with valid value for the “@scroll-on-keystroke@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalScrollOnKeystroke :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnKeystroke val = constructObjectPropertyBool "scroll-on-keystroke" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #scrollOnOutput
@
-}
getTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> m Bool
getTerminalScrollOnOutput obj = liftIO $ getObjectPropertyBool obj "scroll-on-output"

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

@
'Data.GI.Base.Attributes.set' terminal [ #scrollOnOutput 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()
setTerminalScrollOnOutput obj val = liftIO $ setObjectPropertyBool obj "scroll-on-output" val

{- |
Construct a `GValueConstruct` with valid value for the “@scroll-on-output@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalScrollOnOutput :: (IsTerminal o) => Bool -> IO (GValueConstruct o)
constructTerminalScrollOnOutput val = constructObjectPropertyBool "scroll-on-output" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #scrollSpeed
@
-}
getTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollSpeed obj = liftIO $ getObjectPropertyUInt32 obj "scroll-speed"

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

@
'Data.GI.Base.Attributes.set' terminal [ #scrollSpeed 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalScrollSpeed :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollSpeed obj val = liftIO $ setObjectPropertyUInt32 obj "scroll-speed" val

{- |
Construct a `GValueConstruct` with valid value for the “@scroll-speed@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalScrollSpeed :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollSpeed val = constructObjectPropertyUInt32 "scroll-speed" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #scrollbackLines
@
-}
getTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> m Word32
getTerminalScrollbackLines obj = liftIO $ getObjectPropertyUInt32 obj "scrollback-lines"

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

@
'Data.GI.Base.Attributes.set' terminal [ #scrollbackLines 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()
setTerminalScrollbackLines obj val = liftIO $ setObjectPropertyUInt32 obj "scrollback-lines" val

{- |
Construct a `GValueConstruct` with valid value for the “@scrollback-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalScrollbackLines :: (IsTerminal o) => Word32 -> IO (GValueConstruct o)
constructTerminalScrollbackLines val = constructObjectPropertyUInt32 "scrollback-lines" val

#if ENABLE_OVERLOADING
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
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #textBlinkMode
@
-}
getTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> m Vte.Enums.TextBlinkMode
getTerminalTextBlinkMode obj = liftIO $ getObjectPropertyEnum obj "text-blink-mode"

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

@
'Data.GI.Base.Attributes.set' terminal [ #textBlinkMode 'Data.GI.Base.Attributes.:=' value ]
@
-}
setTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> Vte.Enums.TextBlinkMode -> m ()
setTerminalTextBlinkMode obj val = liftIO $ setObjectPropertyEnum obj "text-blink-mode" val

{- |
Construct a `GValueConstruct` with valid value for the “@text-blink-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructTerminalTextBlinkMode :: (IsTerminal o) => Vte.Enums.TextBlinkMode -> IO (GValueConstruct o)
constructTerminalTextBlinkMode val = constructObjectPropertyEnum "text-blink-mode" val

#if ENABLE_OVERLOADING
data TerminalTextBlinkModePropertyInfo
instance AttrInfo TerminalTextBlinkModePropertyInfo where
    type AttrAllowedOps TerminalTextBlinkModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint TerminalTextBlinkModePropertyInfo = (~) Vte.Enums.TextBlinkMode
    type AttrBaseTypeConstraint TerminalTextBlinkModePropertyInfo = IsTerminal
    type AttrGetType TerminalTextBlinkModePropertyInfo = Vte.Enums.TextBlinkMode
    type AttrLabel TerminalTextBlinkModePropertyInfo = "text-blink-mode"
    type AttrOrigin TerminalTextBlinkModePropertyInfo = Terminal
    attrGet _ = getTerminalTextBlinkMode
    attrSet _ = setTerminalTextBlinkMode
    attrConstruct _ = constructTerminalTextBlinkMode
    attrClear _ = undefined
#endif

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

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

@
'Data.GI.Base.Attributes.get' terminal #windowTitle
@
-}
getTerminalWindowTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe T.Text)
getTerminalWindowTitle obj = liftIO $ getObjectPropertyString obj "window-title"

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

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

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

@
'Data.GI.Base.Attributes.get' terminal #wordCharExceptions
@
-}
getTerminalWordCharExceptions :: (MonadIO m, IsTerminal o) => o -> m T.Text
getTerminalWordCharExceptions obj = liftIO $ checkUnexpectedNothing "getTerminalWordCharExceptions" $ getObjectPropertyString obj "word-char-exceptions"

#if ENABLE_OVERLOADING
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
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList Terminal
type instance O.AttributeList Terminal = TerminalAttributeList
type TerminalAttributeList = ('[ '("allowBold", TerminalAllowBoldPropertyInfo), '("allowHyperlink", TerminalAllowHyperlinkPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("audibleBell", TerminalAudibleBellPropertyInfo), '("backspaceBinding", TerminalBackspaceBindingPropertyInfo), '("boldIsBright", TerminalBoldIsBrightPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("cellHeightScale", TerminalCellHeightScalePropertyInfo), '("cellWidthScale", TerminalCellWidthScalePropertyInfo), '("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), '("hyperlinkHoverUri", TerminalHyperlinkHoverUriPropertyInfo), '("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), '("textBlinkMode", TerminalTextBlinkModePropertyInfo), '("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, *)])
#endif

#if ENABLE_OVERLOADING
terminalAllowBold :: AttrLabelProxy "allowBold"
terminalAllowBold = AttrLabelProxy

terminalAllowHyperlink :: AttrLabelProxy "allowHyperlink"
terminalAllowHyperlink = AttrLabelProxy

terminalAudibleBell :: AttrLabelProxy "audibleBell"
terminalAudibleBell = AttrLabelProxy

terminalBackspaceBinding :: AttrLabelProxy "backspaceBinding"
terminalBackspaceBinding = AttrLabelProxy

terminalBoldIsBright :: AttrLabelProxy "boldIsBright"
terminalBoldIsBright = AttrLabelProxy

terminalCellHeightScale :: AttrLabelProxy "cellHeightScale"
terminalCellHeightScale = AttrLabelProxy

terminalCellWidthScale :: AttrLabelProxy "cellWidthScale"
terminalCellWidthScale = 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

terminalHyperlinkHoverUri :: AttrLabelProxy "hyperlinkHoverUri"
terminalHyperlinkHoverUri = 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

terminalTextBlinkMode :: AttrLabelProxy "textBlinkMode"
terminalTextBlinkMode = AttrLabelProxy

terminalWindowTitle :: AttrLabelProxy "windowTitle"
terminalWindowTitle = AttrLabelProxy

terminalWordCharExceptions :: AttrLabelProxy "wordCharExceptions"
terminalWordCharExceptions = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
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 TerminalHyperlinkHoverUriChangedSignalInfo
instance SignalInfo TerminalHyperlinkHoverUriChangedSignalInfo where
    type HaskellCallbackType TerminalHyperlinkHoverUriChangedSignalInfo = TerminalHyperlinkHoverUriChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_TerminalHyperlinkHoverUriChangedCallback cb
        cb'' <- mk_TerminalHyperlinkHoverUriChangedCallback cb'
        connectSignalFunPtr obj "hyperlink-hover-uri-changed" 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), '("hyperlinkHoverUriChanged", TerminalHyperlinkHoverUriChangedSignalInfo), '("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, *)])

#endif

-- 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'

#if ENABLE_OVERLOADING
#endif

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

{-# DEPRECATED terminalCopyClipboard ["(Since version 0.50)","Use 'GI.Vte.Objects.Terminal.terminalCopyClipboardFormat' with 'GI.Vte.Enums.FormatText'","  instead."] #-}
{- |
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 ()

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

#endif

-- method Terminal::copy_clipboard_format
-- 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 = "format", argType = TInterface (Name {namespace = "Vte", name = "Format"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #VteFormat", 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_format" vte_terminal_copy_clipboard_format ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Vte", name = "Format"})
    IO ()

{- |
Places the selected text in the terminal in the @/GDK_SELECTION_CLIPBOARD/@
selection in the form specified by /@format@/.

For all formats, the selection data (see 'GI.Gtk.Structs.SelectionData.SelectionData') will include the
text targets (see 'GI.Gtk.Structs.TargetList.targetListAddTextTargets' and
@/gtk_selection_data_targets_includes_text()/@). For 'GI.Vte.Enums.FormatHtml',
the selection will also include the \"text\/html\" target, which when requested,
returns the HTML data in UTF-16 with a U+FEFF BYTE ORDER MARK character at
the start.

/Since: 0.50/
-}
terminalCopyClipboardFormat ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.Format
    {- ^ /@format@/: a 'GI.Vte.Enums.Format' -}
    -> m ()
terminalCopyClipboardFormat terminal format = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let format' = (fromIntegral . fromEnum) format
    vte_terminal_copy_clipboard_format terminal' format'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalCopyClipboardFormatMethodInfo
instance (signature ~ (Vte.Enums.Format -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalCopyClipboardFormatMethodInfo a signature where
    overloadedMethod _ = terminalCopyClipboardFormat

#endif

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

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

#endif

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

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

#endif

-- 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 = TCArray False (-1) 2 (TBasicType TInt8), 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 : [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}]
-- 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"})
    Ptr Int8 ->                             -- text : TCArray False (-1) 2 (TBasicType TInt8)
    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 ([Int8])
    {- ^ /@text@/: data to send to the child -}
    -> m ()
terminalFeedChild terminal text = liftIO $ do
    let length_ = case text of
            Nothing -> 0
            Just jText -> fromIntegral $ length jText
    terminal' <- unsafeManagedPtrCastPtr terminal
    maybeText <- case text of
        Nothing -> return nullPtr
        Just jText -> do
            jText' <- packStorableArray jText
            return jText'
    vte_terminal_feed_child terminal' maybeText length_
    touchManagedPtr terminal
    freeMem maybeText
    return ()

#if ENABLE_OVERLOADING
data TerminalFeedChildMethodInfo
instance (signature ~ (Maybe ([Int8]) -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalFeedChildMethodInfo a signature where
    overloadedMethod _ = terminalFeedChild

#endif

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

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

#endif

-- 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,
either by using a bold font variant or by repainting text with a different
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'

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

#endif

-- method Terminal::get_allow_hyperlink
-- 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_hyperlink" vte_terminal_get_allow_hyperlink ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks whether or not hyperlinks (OSC 8 escape sequence) are allowed.

/Since: 0.50/
-}
terminalGetAllowHyperlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if hyperlinks are enabled, 'False' if not -}
terminalGetAllowHyperlink terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_allow_hyperlink terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetAllowHyperlinkMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetAllowHyperlinkMethodInfo a signature where
    overloadedMethod _ = terminalGetAllowHyperlink

#endif

-- 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'

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

#endif

-- method Terminal::get_bold_is_bright
-- 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_bold_is_bright" vte_terminal_get_bold_is_bright ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CInt

{- |
Checks whether the SGR 1 attribute also switches to the bright counterpart
of the first 8 palette colors, in addition to making them bold (legacy behavior)
or if SGR 1 only enables bold and leaves the color intact.

/Since: 0.52/
-}
terminalGetBoldIsBright ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if bold also enables bright, 'False' if not -}
terminalGetBoldIsBright terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_bold_is_bright terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetBoldIsBrightMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetBoldIsBrightMethodInfo a signature where
    overloadedMethod _ = terminalGetBoldIsBright

#endif

-- method Terminal::get_cell_height_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_cell_height_scale" vte_terminal_get_cell_height_scale ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

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

/Since: 0.52/
-}
terminalGetCellHeightScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Double
    {- ^ __Returns:__ the terminal\'s cell height scale -}
terminalGetCellHeightScale terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_cell_height_scale terminal'
    let result' = realToFrac result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetCellHeightScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellHeightScaleMethodInfo a signature where
    overloadedMethod _ = terminalGetCellHeightScale

#endif

-- method Terminal::get_cell_width_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_cell_width_scale" vte_terminal_get_cell_width_scale ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    IO CDouble

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

/Since: 0.52/
-}
terminalGetCellWidthScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Double
    {- ^ __Returns:__ the terminal\'s cell width scale -}
terminalGetCellWidthScale terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_cell_width_scale terminal'
    let result' = realToFrac result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetCellWidthScaleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetCellWidthScaleMethodInfo a signature where
    overloadedMethod _ = terminalGetCellWidthScale

#endif

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

Note that this method should rather be called vte_terminal_get_cell_height,
because the return value takes cell-height-scale into account. -}
terminalGetCharHeight terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_char_height terminal'
    touchManagedPtr terminal
    return result

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

#endif

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

Note that this method should rather be called vte_terminal_get_cell_width,
because the return value takes cell-width-scale into account. -}
terminalGetCharWidth terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_char_width terminal'
    touchManagedPtr terminal
    return result

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

#endif

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

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

#endif

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

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

#endif

-- 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 (Maybe 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'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr terminal
    return maybeResult

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

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

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

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

{-# DEPRECATED terminalGetGeometryHints ["(Since version 0.52)"] #-}
{- |
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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

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

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

#endif

-- method Terminal::get_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}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

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

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

/Since: 0.52/
-}
terminalGetScrollOnKeystroke ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ 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. -}
terminalGetScrollOnKeystroke terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_scroll_on_keystroke terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetScrollOnKeystrokeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod _ = terminalGetScrollOnKeystroke

#endif

-- method Terminal::get_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}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

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

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

/Since: 0.52/
-}
terminalGetScrollOnOutput ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Bool
    {- ^ __Returns:__ whether or not the terminal will forcibly scroll to the bottom of
the viewable history when the new data is received from the child. -}
terminalGetScrollOnOutput terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_scroll_on_output terminal'
    let result' = (/= 0) result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetScrollOnOutputMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollOnOutputMethodInfo a signature where
    overloadedMethod _ = terminalGetScrollOnOutput

#endif

-- method Terminal::get_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}]
-- Lengths : []
-- returnType : Just (TBasicType TLong)
-- throws : False
-- Skip return : False

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

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

/Since: 0.52/
-}
terminalGetScrollbackLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m CLong
    {- ^ __Returns:__ length of the scrollback buffer used by the terminal.
A negative value means \"infinite scrollback\". -}
terminalGetScrollbackLines terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_scrollback_lines terminal'
    touchManagedPtr terminal
    return result

#if ENABLE_OVERLOADING
data TerminalGetScrollbackLinesMethodInfo
instance (signature ~ (m CLong), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetScrollbackLinesMethodInfo a signature where
    overloadedMethod _ = terminalGetScrollbackLines

#endif

-- 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\"}))"
#if ENABLE_OVERLOADING
-- 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
#endif

-- method Terminal::get_text_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 = "TextBlinkMode"}))
-- throws : False
-- Skip return : False

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

{- |
Checks whether or not the terminal will allow blinking text.

/Since: 0.52/
-}
terminalGetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> m Vte.Enums.TextBlinkMode
    {- ^ __Returns:__ the blinking setting -}
terminalGetTextBlinkMode terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_text_blink_mode terminal'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr terminal
    return result'

#if ENABLE_OVERLOADING
data TerminalGetTextBlinkModeMethodInfo
instance (signature ~ (m Vte.Enums.TextBlinkMode), MonadIO m, IsTerminal a) => O.MethodInfo TerminalGetTextBlinkModeMethodInfo a signature where
    overloadedMethod _ = terminalGetTextBlinkMode

#endif

-- 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\"}))"
#if ENABLE_OVERLOADING
-- 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
#endif

-- 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\"}))"
#if ENABLE_OVERLOADING
-- 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
#endif

-- 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 (Maybe T.Text)
    {- ^ __Returns:__ the window title -}
terminalGetWindowTitle terminal = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    result <- vte_terminal_get_window_title terminal'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr terminal
    return maybeResult

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

#endif

-- 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'

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

#endif

-- method Terminal::hyperlink_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}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

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

{- |
Returns a nonempty string: the target of the explicit hyperlink (printed using the OSC 8
escape sequence) at the position of the event, or 'Nothing'.

Proper use of the escape sequence should result in URI-encoded URIs with a proper scheme
like \"http:\/\/\", \"https:\/\/\", \"file:\/\/\", \"mailto:\" etc. This is, however, not enforced by VTE.
The caller must tolerate the returned string potentially not being a valid URI.

/Since: 0.50/
-}
terminalHyperlinkCheckEvent ::
    (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
    {- ^ __Returns:__ a newly allocated string containing the target of the hyperlink -}
terminalHyperlinkCheckEvent terminal event = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    event' <- unsafeManagedPtrGetPtr event
    result <- vte_terminal_hyperlink_check_event terminal' event'
    checkUnexpectedReturnNULL "terminalHyperlinkCheckEvent" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr terminal
    touchManagedPtr event
    return result'

#if ENABLE_OVERLOADING
data TerminalHyperlinkCheckEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m T.Text), MonadIO m, IsTerminal a) => O.MethodInfo TerminalHyperlinkCheckEventMethodInfo a signature where
    overloadedMethod _ = terminalHyperlinkCheckEvent

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

-- 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
    CInt ->                                 -- 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 ()

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

#endif

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

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

#endif

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

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

#endif

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

#if ENABLE_OVERLOADING
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

#endif

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

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

-- 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'

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

-- method Terminal::set_allow_hyperlink
-- 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_hyperlink", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the terminal should allow hyperlinks", 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_hyperlink" vte_terminal_set_allow_hyperlink ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- allow_hyperlink : TBasicType TBoolean
    IO ()

{- |
Controls whether or not hyperlinks (OSC 8 escape sequence) are allowed.

/Since: 0.50/
-}
terminalSetAllowHyperlink ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@allowHyperlink@/: 'True' if the terminal should allow hyperlinks -}
    -> m ()
terminalSetAllowHyperlink terminal allowHyperlink = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let allowHyperlink' = (fromIntegral . fromEnum) allowHyperlink
    vte_terminal_set_allow_hyperlink terminal' allowHyperlink'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetAllowHyperlinkMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetAllowHyperlinkMethodInfo a signature where
    overloadedMethod _ = terminalSetAllowHyperlink

#endif

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

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

#endif

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

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

#endif

-- method Terminal::set_bold_is_bright
-- 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_is_bright", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if bold should also enable bright", 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_bold_is_bright" vte_terminal_set_bold_is_bright ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- bold_is_bright : TBasicType TBoolean
    IO ()

{- |
Sets whether the SGR 1 attribute also switches to the bright counterpart
of the first 8 palette colors, in addition to making them bold (legacy behavior)
or if SGR 1 only enables bold and leaves the color intact.

/Since: 0.52/
-}
terminalSetBoldIsBright ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    {- ^ /@boldIsBright@/: 'True' if bold should also enable bright -}
    -> m ()
terminalSetBoldIsBright terminal boldIsBright = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let boldIsBright' = (fromIntegral . fromEnum) boldIsBright
    vte_terminal_set_bold_is_bright terminal' boldIsBright'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetBoldIsBrightMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetBoldIsBrightMethodInfo a signature where
    overloadedMethod _ = terminalSetBoldIsBright

#endif

-- method Terminal::set_cell_height_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 cell height 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_cell_height_scale" vte_terminal_set_cell_height_scale ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

{- |
Sets the terminal\'s cell height scale to /@scale@/.

This can be used to increase the line spacing. (The font\'s height is not affected.)
Valid values go from 1.0 (default) to 2.0 (\"double spacing\").

/Since: 0.52/
-}
terminalSetCellHeightScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Double
    {- ^ /@scale@/: the cell height scale -}
    -> m ()
terminalSetCellHeightScale terminal scale = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let scale' = realToFrac scale
    vte_terminal_set_cell_height_scale terminal' scale'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetCellHeightScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellHeightScaleMethodInfo a signature where
    overloadedMethod _ = terminalSetCellHeightScale

#endif

-- method Terminal::set_cell_width_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 cell width 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_cell_width_scale" vte_terminal_set_cell_width_scale ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CDouble ->                              -- scale : TBasicType TDouble
    IO ()

{- |
Sets the terminal\'s cell width scale to /@scale@/.

This can be used to increase the letter spacing. (The font\'s width is not affected.)
Valid values go from 1.0 (default) to 2.0.

/Since: 0.52/
-}
terminalSetCellWidthScale ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Double
    {- ^ /@scale@/: the cell width scale -}
    -> m ()
terminalSetCellWidthScale terminal scale = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let scale' = realToFrac scale
    vte_terminal_set_cell_width_scale terminal' scale'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetCellWidthScaleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetCellWidthScaleMethodInfo a signature where
    overloadedMethod _ = terminalSetCellWidthScale

#endif

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

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

#endif

-- method Terminal::set_clear_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 = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, 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_clear_background" vte_terminal_set_clear_background ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Sets whether to paint the background with the background colour.
The default is 'True'.

This function is rarely useful. One use for it is to add a background
image to the terminal.

/Since: 0.52/
-}
terminalSetClearBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Bool
    -> m ()
terminalSetClearBackground terminal setting = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let setting' = (fromIntegral . fromEnum) setting
    vte_terminal_set_clear_background terminal' setting'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetClearBackgroundMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetClearBackgroundMethodInfo a signature where
    overloadedMethod _ = terminalSetClearBackground

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

#if ENABLE_OVERLOADING
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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

-- 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 @/GIConv/@ 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
     )

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

#endif

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

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

#endif

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

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

#endif

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

{-# DEPRECATED terminalSetGeometryHintsForWindow ["(Since version 0.52)"] #-}
{- |
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 ()

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

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetInputEnabledMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetInputEnabledMethodInfo a signature where
    overloadedMethod _ = terminalSetInputEnabled

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetMouseAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetMouseAutohideMethodInfo a signature where
    overloadedMethod _ = terminalSetMouseAutohide

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetPtyMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTerminal a, Vte.Pty.IsPty b) => O.MethodInfo TerminalSetPtyMethodInfo a signature where
    overloadedMethod _ = terminalSetPty

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetRewrapOnResizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetRewrapOnResizeMethodInfo a signature where
    overloadedMethod _ = terminalSetRewrapOnResize

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetScrollOnKeystrokeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnKeystrokeMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollOnKeystroke

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetScrollOnOutputMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollOnOutputMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollOnOutput

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetScrollSpeedMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollSpeedMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollSpeed

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetScrollbackLinesMethodInfo
instance (signature ~ (CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetScrollbackLinesMethodInfo a signature where
    overloadedMethod _ = terminalSetScrollbackLines

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetSizeMethodInfo
instance (signature ~ (CLong -> CLong -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetSizeMethodInfo a signature where
    overloadedMethod _ = terminalSetSize

#endif

-- method Terminal::set_text_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 = "text_blink_mode", argType = TInterface (Name {namespace = "Vte", name = "TextBlinkMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #VteTextBlinkMode 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_text_blink_mode" vte_terminal_set_text_blink_mode ::
    Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
    CUInt ->                                -- text_blink_mode : TInterface (Name {namespace = "Vte", name = "TextBlinkMode"})
    IO ()

{- |
Controls whether or not the terminal will allow blinking text.

/Since: 0.52/
-}
terminalSetTextBlinkMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
    a
    {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
    -> Vte.Enums.TextBlinkMode
    {- ^ /@textBlinkMode@/: the 'GI.Vte.Enums.TextBlinkMode' to use -}
    -> m ()
terminalSetTextBlinkMode terminal textBlinkMode = liftIO $ do
    terminal' <- unsafeManagedPtrCastPtr terminal
    let textBlinkMode' = (fromIntegral . fromEnum) textBlinkMode
    vte_terminal_set_text_blink_mode terminal' textBlinkMode'
    touchManagedPtr terminal
    return ()

#if ENABLE_OVERLOADING
data TerminalSetTextBlinkModeMethodInfo
instance (signature ~ (Vte.Enums.TextBlinkMode -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetTextBlinkModeMethodInfo a signature where
    overloadedMethod _ = terminalSetTextBlinkMode

#endif

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

#if ENABLE_OVERLOADING
data TerminalSetWordCharExceptionsMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalSetWordCharExceptionsMethodInfo a signature where
    overloadedMethod _ = terminalSetWordCharExceptions

#endif

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

{-# DEPRECATED terminalSpawnSync ["(Since version 0.48)","Use @/vte_terminal_spawn_async()/@ instead."] #-}
{- |
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.

Beginning with 0.52, sets PWD to /@workingDirectory@/ in order to preserve symlink components.
The caller should also make sure that symlinks were preserved while constructing the value of /@workingDirectory@/,
e.g. by using 'GI.Vte.Objects.Terminal.terminalGetCurrentDirectoryUri', 'GI.GLib.Functions.getCurrentDir' or @/get_current_dir_name()/@.
-}
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
     )

#if ENABLE_OVERLOADING
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

#endif

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

#if ENABLE_OVERLOADING
data TerminalUnselectAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalUnselectAllMethodInfo a signature where
    overloadedMethod _ = terminalUnselectAll

#endif

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

#if ENABLE_OVERLOADING
data TerminalWatchChildMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsTerminal a) => O.MethodInfo TerminalWatchChildMethodInfo a signature where
    overloadedMethod _ = terminalWatchChild

#endif

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

#if ENABLE_OVERLOADING
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

#endif