    {- |
    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 \
           (!defined(__HADDOCK_VERSION__))

    module GI.Vte.Objects.Terminal
        (
    #if ENABLE_OVERLOADING
        TerminalGetTextMethodInfo               ,
    #endif
    #if ENABLE_OVERLOADING
        TerminalGetTextIncludeTrailingSpacesMethodInfo,
    #endif
    #if ENABLE_OVERLOADING
        TerminalGetTextRangeMethodInfo          ,
    #endif
    #if ENABLE_OVERLOADING
        TerminalSpawnAsyncMethodInfo            ,
    #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            ,

    -- ** getColorBackgroundForDraw #method:getColorBackgroundForDraw#

    #if ENABLE_OVERLOADING
        TerminalGetColorBackgroundForDrawMethodInfo,
    #endif
        terminalGetColorBackgroundForDraw       ,

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

    -- ** getEnableBidi #method:getEnableBidi#

    #if ENABLE_OVERLOADING
        TerminalGetEnableBidiMethodInfo         ,
    #endif
        terminalGetEnableBidi                   ,

    -- ** getEnableShaping #method:getEnableShaping#

    #if ENABLE_OVERLOADING
        TerminalGetEnableShapingMethodInfo      ,
    #endif
        terminalGetEnableShaping                ,

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

    -- ** setEnableBidi #method:setEnableBidi#

    #if ENABLE_OVERLOADING
        TerminalSetEnableBidiMethodInfo         ,
    #endif
        terminalSetEnableBidi                   ,

    -- ** setEnableShaping #method:setEnableShaping#

    #if ENABLE_OVERLOADING
        TerminalSetEnableShapingMethodInfo      ,
    #endif
        terminalSetEnableShaping                ,

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

    -- ** 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.
    (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
    the width of ambiguous-width characters is fixed and determined by the encoding
    itself.)

    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

    -- ** enableBidi #attr:enableBidi#
    {- | Controls whether or not the terminal will perform bidirectional text rendering.

    /Since: 0.58/
    -}
    #if ENABLE_OVERLOADING
        TerminalEnableBidiPropertyInfo          ,
    #endif
        constructTerminalEnableBidi             ,
        getTerminalEnableBidi                   ,
        setTerminalEnableBidi                   ,
    #if ENABLE_OVERLOADING
        terminalEnableBidi                      ,
    #endif

    -- ** enableShaping #attr:enableShaping#
    {- | Controls whether or not the terminal will shape Arabic text.

    /Since: 0.58/
    -}
    #if ENABLE_OVERLOADING
        TerminalEnableShapingPropertyInfo       ,
    #endif
        constructTerminalEnableShaping          ,
        getTerminalEnableShaping                ,
        setTerminalEnableShaping                ,
    #if ENABLE_OVERLOADING
        terminalEnableShaping                   ,
    #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#
    {- | /No description available in the introspection data./
    -}
    #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

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

    -- ** 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 "spawnAsync" o = TerminalSpawnAsyncMethodInfo
        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 "getColorBackgroundForDraw" o = TerminalGetColorBackgroundForDrawMethodInfo
        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 "getEnableBidi" o = TerminalGetEnableBidiMethodInfo
        ResolveTerminalMethod "getEnableShaping" o = TerminalGetEnableShapingMethodInfo
        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 "setEnableBidi" o = TerminalSetEnableBidiMethodInfo
        ResolveTerminalMethod "setEnableShaping" o = TerminalSetEnableShapingMethodInfo
        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 "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.

    Note: support for non-UTF-8 is deprecated.
    -}
    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
    {-# DEPRECATED TerminalIconTitleChangedCallback ["(Since version 0.54)","This signal is never emitted."] #-}
    {- |
    /No description available in the introspection data./
    -}
    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::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 True,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 (Maybe T.Text)
    getTerminalCurrentFileUri obj = liftIO $ 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 = (Maybe 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 "enable-bidi"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

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

    @
    'Data.GI.Base.Attributes.get' terminal #enableBidi
    @
    -}
    getTerminalEnableBidi :: (MonadIO m, IsTerminal o) => o -> m Bool
    getTerminalEnableBidi obj = liftIO $ getObjectPropertyBool obj "enable-bidi"

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

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

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

    #if ENABLE_OVERLOADING
    data TerminalEnableBidiPropertyInfo
    instance AttrInfo TerminalEnableBidiPropertyInfo where
        type AttrAllowedOps TerminalEnableBidiPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TerminalEnableBidiPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint TerminalEnableBidiPropertyInfo = IsTerminal
        type AttrGetType TerminalEnableBidiPropertyInfo = Bool
        type AttrLabel TerminalEnableBidiPropertyInfo = "enable-bidi"
        type AttrOrigin TerminalEnableBidiPropertyInfo = Terminal
        attrGet _ = getTerminalEnableBidi
        attrSet _ = setTerminalEnableBidi
        attrConstruct _ = constructTerminalEnableBidi
        attrClear _ = undefined
    #endif

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

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

    @
    'Data.GI.Base.Attributes.get' terminal #enableShaping
    @
    -}
    getTerminalEnableShaping :: (MonadIO m, IsTerminal o) => o -> m Bool
    getTerminalEnableShaping obj = liftIO $ getObjectPropertyBool obj "enable-shaping"

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

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

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

    #if ENABLE_OVERLOADING
    data TerminalEnableShapingPropertyInfo
    instance AttrInfo TerminalEnableShapingPropertyInfo where
        type AttrAllowedOps TerminalEnableShapingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TerminalEnableShapingPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint TerminalEnableShapingPropertyInfo = IsTerminal
        type AttrGetType TerminalEnableShapingPropertyInfo = Bool
        type AttrLabel TerminalEnableShapingPropertyInfo = "enable-shaping"
        type AttrOrigin TerminalEnableShapingPropertyInfo = Terminal
        attrGet _ = getTerminalEnableShaping
        attrSet _ = setTerminalEnableShaping
        attrConstruct _ = constructTerminalEnableShaping
        attrClear _ = undefined
    #endif

    -- VVV Prop "encoding"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just True,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 (Maybe T.Text)
    getTerminalEncoding obj = liftIO $ 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 = (Maybe 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 True,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 (Maybe T.Text)
    getTerminalIconTitle obj = liftIO $ 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 = (Maybe 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 "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 True,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 (Maybe T.Text)
    getTerminalWordCharExceptions obj = liftIO $ 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 = (Maybe 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), '("enableBidi", TerminalEnableBidiPropertyInfo), '("enableShaping", TerminalEnableShapingPropertyInfo), '("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), '("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

    terminalEnableBidi :: AttrLabelProxy "enableBidi"
    terminalEnableBidi = AttrLabelProxy

    terminalEnableShaping :: AttrLabelProxy "enableShaping"
    terminalEnableShaping = 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

    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 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), '("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.
    (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
    the width of ambiguous-width characters is fixed and determined by the encoding
    itself.)
    -}
    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_color_background_for_draw
    -- 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 = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store a #GdbRGBA color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

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

    {- |
    Returns the background colour, as used by /@terminal@/ when
    drawing the background, which may be different from
    the color set by 'GI.Vte.Objects.Terminal.terminalSetColorBackground'.

    Note: you must only call this function while handling the
    GtkWidget::draw signal.

    This function is rarely useful. One use for it is if you disable
    drawing the background (see 'GI.Vte.Objects.Terminal.terminalSetClearBackground')
    and then need to draw the background yourself.

    /Since: 0.54/
    -}
    terminalGetColorBackgroundForDraw ::
        (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
        a
        {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
        -> m (Gdk.RGBA.RGBA)
    terminalGetColorBackgroundForDraw terminal = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        color <- callocBoxedBytes 32 :: IO (Ptr Gdk.RGBA.RGBA)
        vte_terminal_get_color_background_for_draw terminal' color
        color' <- (wrapBoxed Gdk.RGBA.RGBA) color
        touchManagedPtr terminal
        return color'

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

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

    #if ENABLE_OVERLOADING
    data TerminalGetCurrentFileUriMethodInfo
    instance (signature ~ (m (Maybe 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.

    This method is unaware of BiDi. The returned column is logical column.
    -}
    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_enable_bidi
    -- 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_enable_bidi" vte_terminal_get_enable_bidi ::
        Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
        IO CInt

    {- |
    Checks whether the terminal performs bidirectional text rendering.

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

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

    #endif

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

    {- |
    Checks whether the terminal shapes Arabic text.

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

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

    #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

    {-# DEPRECATED terminalGetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}
    {- |
    Determines the name of the encoding in which the terminal expects data to be
    encoded, or 'Nothing' if UTF-8 is in use.
    -}
    terminalGetEncoding ::
        (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
        a
        {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ the current encoding for the terminal -}
    terminalGetEncoding terminal = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        result <- vte_terminal_get_encoding terminal'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr terminal
        return maybeResult

    #if ENABLE_OVERLOADING
    data TerminalGetEncodingMethodInfo
    instance (signature ~ (m (Maybe 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

    {-# DEPRECATED terminalGetIconTitle ["(Since version 0.54)"] #-}
    {- |
    /No description available in the introspection data./
    -}
    terminalGetIconTitle ::
        (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
        a
        {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
        -> m (Maybe T.Text)
        {- ^ __Returns:__ 'Nothing' -}
    terminalGetIconTitle terminal = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        result <- vte_terminal_get_icon_title terminal'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr terminal
        return maybeResult

    #if ENABLE_OVERLOADING
    data TerminalGetIconTitleMethodInfo
    instance (signature ~ (m (Maybe 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

    {-# DEPRECATED terminalGetRewrapOnResize ["(Since version 0.58)"] #-}
    {- |
    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, or 'Nothing' -}
    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 (Maybe T.Text)
        {- ^ __Returns:__ a string, or 'Nothing' -}
    terminalGetWordCharExceptions terminal = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        result <- vte_terminal_get_word_char_exceptions terminal'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- cstringToText result'
            return result''
        touchManagedPtr terminal
        return maybeResult

    #if ENABLE_OVERLOADING
    data TerminalGetWordCharExceptionsMethodInfo
    instance (signature ~ (m (Maybe 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.terminalMatchSetCursorName' 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 ()

    {-# DEPRECATED terminalMatchSetCursorType ["(Since version 0.54)","Use 'GI.Vte.Objects.Terminal.terminalMatchSetCursorName' instead."] #-}
    {- |
    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. 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. 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.
    (Note that when using a non-UTF-8 encoding set via 'GI.Vte.Objects.Terminal.terminalSetEncoding',
    the width of ambiguous-width characters is fixed and determined by the encoding
    itself.)
    -}
    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_enable_bidi
    -- 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 = "enable_bidi", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable BiDi support", 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_enable_bidi" vte_terminal_set_enable_bidi ::
        Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
        CInt ->                                 -- enable_bidi : TBasicType TBoolean
        IO ()

    {- |
    Controls whether or not the terminal will perform bidirectional text rendering.

    /Since: 0.58/
    -}
    terminalSetEnableBidi ::
        (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
        a
        {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
        -> Bool
        {- ^ /@enableBidi@/: 'True' to enable BiDi support -}
        -> m ()
    terminalSetEnableBidi terminal enableBidi = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        let enableBidi' = (fromIntegral . fromEnum) enableBidi
        vte_terminal_set_enable_bidi terminal' enableBidi'
        touchManagedPtr terminal
        return ()

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

    #endif

    -- method Terminal::set_enable_shaping
    -- 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 = "enable_shaping", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to enable Arabic shaping", 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_enable_shaping" vte_terminal_set_enable_shaping ::
        Ptr Terminal ->                         -- terminal : TInterface (Name {namespace = "Vte", name = "Terminal"})
        CInt ->                                 -- enable_shaping : TBasicType TBoolean
        IO ()

    {- |
    Controls whether or not the terminal will shape Arabic text.

    /Since: 0.58/
    -}
    terminalSetEnableShaping ::
        (B.CallStack.HasCallStack, MonadIO m, IsTerminal a) =>
        a
        {- ^ /@terminal@/: a 'GI.Vte.Objects.Terminal.Terminal' -}
        -> Bool
        {- ^ /@enableShaping@/: 'True' to enable Arabic shaping -}
        -> m ()
    terminalSetEnableShaping terminal enableShaping = liftIO $ do
        terminal' <- unsafeManagedPtrCastPtr terminal
        let enableShaping' = (fromIntegral . fromEnum) enableShaping
        vte_terminal_set_enable_shaping terminal' enableShaping'
        touchManagedPtr terminal
        return ()

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

    #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

    {-# DEPRECATED terminalSetEncoding ["(Since version 0.54)","Support for non-UTF-8 is deprecated."] #-}
    {- |
    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\".

    Note: Support for non-UTF-8 is deprecated and may get removed altogether.
    Instead of this function, you should use a wrapper like luit(1) when
    spawning the child process.
    -}
    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 ()

    {-# DEPRECATED terminalSetRewrapOnResize ["(Since version 0.58)"] #-}
    {- |
    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_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

    -- XXX Could not generate method Terminal::spawn_async
    -- Error was : Bad introspection data: "Closure not found! Callable\n  { returnType = Nothing\n  , returnMayBeNull = False\n  , returnTransfer = TransferNothing\n  , returnDocumentation =\n      Documentation { rawDocText = Nothing , sinceVersion = Nothing }\n  , args =\n      [ Arg\n          { argCName = \"terminal\"\n          , argType =\n              TInterface Name { namespace = \"Vte\" , name = \"Terminal\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"a #VteTerminal\" , sinceVersion = Nothing }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"pty_flags\"\n          , argType =\n              TInterface Name { namespace = \"Vte\" , name = \"PtyFlags\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"flags from #VtePtyFlags\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"working_directory\"\n          , argType = TBasicType TUTF8\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"the name of a directory the command should start\\n  in, or %NULL to use the current working directory\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"argv\"\n          , argType = TCArray True (-1) (-1) (TBasicType TFileName)\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"child's argument vector\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"envv\"\n          , argType = TCArray True (-1) (-1) (TBasicType TFileName)\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"a list of environment\\n  variables to be added to the environment before starting the process, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"spawn_flags_\"\n          , argType =\n              TInterface Name { namespace = \"GLib\" , name = \"SpawnFlags\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"flags from #GSpawnFlags\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup\"\n          , argType =\n              TInterface\n                Name { namespace = \"GLib\" , name = \"SpawnChildSetupFunc\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just\n                      \"an extra child setup function to run in the child just before exec(), or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeNotified\n          , argClosure = 7\n          , argDestroy = 8\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup_data\"\n          , argType = TBasicType TPtr\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"user data for @child_setup, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeNotified\n          , argClosure = 6\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"child_setup_data_destroy\"\n          , argType =\n              TInterface Name { namespace = \"GLib\" , name = \"DestroyNotify\" }\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just \"a #GDestroyNotify for @child_setup_data, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeAsync\n          , argClosure = -1\n          , argDestroy = 7\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"timeout\"\n          , argType = TBasicType TInt\n          , direction = DirectionIn\n          , mayBeNull = False\n          , argDoc =\n              Documentation\n                { rawDocText =\n                    Just \"a timeout value in ms, or -1 to wait indefinitely\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"cancellable\"\n          , argType =\n              TInterface Name { namespace = \"Gio\" , name = \"Cancellable\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"a #GCancellable, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = -1\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"callback\"\n          , argType =\n              TInterface\n                Name { namespace = \"Vte\" , name = \"TerminalSpawnAsyncCallback\" }\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"a #VteTerminalSpawnAsyncCallback, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeAsync\n          , argClosure = 12\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      , Arg\n          { argCName = \"user_data\"\n          , argType = TBasicType TPtr\n          , direction = DirectionIn\n          , mayBeNull = True\n          , argDoc =\n              Documentation\n                { rawDocText = Just \"user data for @callback, or %NULL\"\n                , sinceVersion = Nothing\n                }\n          , argScope = ScopeTypeInvalid\n          , argClosure = 11\n          , argDestroy = -1\n          , argCallerAllocates = False\n          , transfer = TransferNothing\n          }\n      ]\n  , skipReturn = False\n  , callableThrows = False\n  , callableDeprecated = Nothing\n  , callableDocumentation =\n      Documentation\n        { rawDocText =\n            Just\n              \"A convenience function that wraps creating the #VtePty and spawning\\nthe child process on it. See vte_pty_new_sync(), vte_pty_spawn_async(),\\nand vte_pty_spawn_finish() for more information.\\n\\nWhen the operation is finished successfully, @callback will be called\\nwith the child #GPid, and a %NULL #GError. The child PID will already be\\nwatched via vte_terminal_watch_child().\\n\\nWhen the operation fails, @callback will be called with a -1 #GPid,\\nand a non-%NULL #GError containing the error information.\\n\\nNote that if @terminal has been destroyed before the operation is called,\\n@callback will be called with a %NULL @terminal; you must not do anything\\nin the callback besides freeing any resources associated with @user_data,\\nbut taking care not to access the now-destroyed #VteTerminal. Note that\\nin this case, if spawning was successful, the child process will be aborted\\nautomatically.\\n\\nBeginning with 0.52, sets PWD to @working_directory in order to preserve symlink components.\\nThe caller should also make sure that symlinks were preserved while constructing the value of @working_directory,\\ne.g. by using vte_terminal_get_current_directory_uri(), g_get_current_dir() or get_current_dir_name().\"\n        , sinceVersion = Just \"0.48\"\n        }\n  }\nfromList\n  [ ( 7\n    , Arg\n        { argCName = \"child_setup\"\n        , argType =\n            TInterface\n              Name { namespace = \"GLib\" , name = \"SpawnChildSetupFunc\" }\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argDoc =\n            Documentation\n              { rawDocText =\n                  Just\n                    \"an extra child setup function to run in the child just before exec(), or %NULL\"\n              , sinceVersion = Nothing\n              }\n        , argScope = ScopeTypeNotified\n        , argClosure = 7\n        , argDestroy = 8\n        , argCallerAllocates = False\n        , transfer = TransferNothing\n        }\n    )\n  , ( 12\n    , Arg\n        { argCName = \"callback\"\n        , argType =\n            TInterface\n              Name { namespace = \"Vte\" , name = \"TerminalSpawnAsyncCallback\" }\n        , direction = DirectionIn\n        , mayBeNull = True\n        , argDoc =\n            Documentation\n              { rawDocText = Just \"a #VteTerminalSpawnAsyncCallback, or %NULL\"\n              , sinceVersion = Nothing\n              }\n        , argScope = ScopeTypeAsync\n        , argClosure = 12\n        , argDestroy = -1\n        , argCallerAllocates = False\n        , transfer = TransferNothing\n        }\n    )\n  ]\n6"
    #if ENABLE_OVERLOADING
    -- XXX: Dummy instance, since code generation failed.
    -- Please file a bug at http://github.com/haskell-gi/haskell-gi.
    data TerminalSpawnAsyncMethodInfo
    instance (p ~ (), o ~ O.MethodResolutionFailed "spawnAsync" Terminal) => O.MethodInfo TerminalSpawnAsyncMethodInfo o p where
        overloadedMethod _ = undefined
    #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 'GI.Vte.Objects.Terminal.terminalSpawnAsync' 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