-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Vte bindings
--   
--   Bindings for Vte, autogenerated by haskell-gi.
@package gi-vte
@version 2.91.19

module GI.Vte.Constants

-- | No description available in the introspection data.
pattern TEST_FLAGS_NONE :: () => () => Word64

-- | No description available in the introspection data.
pattern TEST_FLAGS_ALL :: () => () => Word64

-- | No description available in the introspection data.
pattern SPAWN_NO_PARENT_ENVV :: () => () => Int32

-- | No description available in the introspection data.
pattern REGEX_FLAGS_DEFAULT :: () => () => Int32

-- | The minor version number of the VTE library (e.g. in version 3.1.4
--   this is 1).
pattern MINOR_VERSION :: () => () => Int32

-- | The micro version number of the VTE library (e.g. in version 3.1.4
--   this is 4).
pattern MICRO_VERSION :: () => () => Int32

-- | The major version number of the VTE library (e.g. in version 3.1.4
--   this is 3).
pattern MAJOR_VERSION :: () => () => Int32

module GI.Vte.Enums

-- | An enumerated type which can be used to indicate the cursor blink mode
--   for the terminal.
data CursorBlinkMode

-- | Follow GTK+ settings for cursor blinking.
CursorBlinkModeSystem :: CursorBlinkMode

-- | Cursor blinks.
CursorBlinkModeOn :: CursorBlinkMode

-- | Cursor does not blink.
CursorBlinkModeOff :: CursorBlinkMode

-- | Catch-all for unknown values
AnotherCursorBlinkMode :: Int -> CursorBlinkMode

-- | An enumerated type which can be used to indicate what should the
--   terminal draw at the cursor position.
data CursorShape

-- | Draw a block cursor. This is the default.
CursorShapeBlock :: CursorShape

-- | Draw a vertical bar on the left side of character. This is similar to
--   the default cursor for other GTK+ widgets.
CursorShapeIbeam :: CursorShape

-- | Draw a horizontal bar below the character.
CursorShapeUnderline :: CursorShape

-- | Catch-all for unknown values
AnotherCursorShape :: Int -> CursorShape

-- | An enumerated type which can be used to indicate which string the
--   terminal should send to an application when the user presses the
--   Delete or Backspace keys.
data EraseBinding

-- | For backspace, attempt to determine the right value from the
--   terminal's IO settings. For delete, use the control sequence.
EraseBindingAuto :: EraseBinding

-- | Send an ASCII backspace character (0x08).
EraseBindingAsciiBackspace :: EraseBinding

-- | Send an ASCII delete character (0x7F).
EraseBindingAsciiDelete :: EraseBinding

-- | Send the "@7" control sequence.
EraseBindingDeleteSequence :: EraseBinding

-- | Send terminal's "erase" setting.
EraseBindingTty :: EraseBinding

-- | Catch-all for unknown values
AnotherEraseBinding :: Int -> EraseBinding

-- | An enumeratio type that can be used to specify the format the
--   selection should be copied to the clipboard in.
--   
--   Since: 0.50
data Format

-- | Export as plain text
FormatText :: Format

-- | Export as HTML formatted text
FormatHtml :: Format

-- | Catch-all for unknown values
AnotherFormat :: Int -> Format

-- | No description available in the introspection data.
data PtyError

-- | Obsolete. Deprecated: 0.42
PtyErrorPtyHelperFailed :: PtyError

-- | failure when using PTY98 to allocate the PTY
PtyErrorPty98Failed :: PtyError

-- | Catch-all for unknown values
AnotherPtyError :: Int -> PtyError

-- | Catch exceptions of type PtyError. This is a specialized
--   version of catchGErrorJustDomain.
catchPtyError :: IO a -> (PtyError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type PtyError. This is a specialized
--   version of handleGErrorJustDomain.
handlePtyError :: (PtyError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | An enum type for regex errors. In addition to the values listed above,
--   any PCRE2 error values may occur.
--   
--   Since: 0.46
data RegexError

-- | The PCRE2 library was built without Unicode support which is required
--   for VTE
RegexErrorIncompatible :: RegexError

-- | Regexes are not supported because VTE was built without PCRE2 support
RegexErrorNotSupported :: RegexError

-- | Catch-all for unknown values
AnotherRegexError :: Int -> RegexError

-- | Catch exceptions of type RegexError. This is a specialized
--   version of catchGErrorJustDomain.
catchRegexError :: IO a -> (RegexError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type RegexError. This is a specialized
--   version of handleGErrorJustDomain.
handleRegexError :: (RegexError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | An enumerated type which can be used to indicate whether the terminal
--   allows the text contents to be blinked.
--   
--   Since: 0.52
data TextBlinkMode

-- | Do not blink the text.
TextBlinkModeNever :: TextBlinkMode

-- | Allow blinking text only if the terminal is focused.
TextBlinkModeFocused :: TextBlinkMode

-- | Allow blinking text only if the terminal is unfocused.
TextBlinkModeUnfocused :: TextBlinkMode

-- | Allow blinking text. This is the default.
TextBlinkModeAlways :: TextBlinkMode

-- | Catch-all for unknown values
AnotherTextBlinkMode :: Int -> TextBlinkMode

-- | A flag type to determine how terminal contents should be written to an
--   output stream.
data WriteFlags

-- | Write contents as UTF-8 text. This is the default.
WriteFlagsDefault :: WriteFlags

-- | Catch-all for unknown values
AnotherWriteFlags :: Int -> WriteFlags
instance GHC.Classes.Eq GI.Vte.Enums.CursorBlinkMode
instance GHC.Show.Show GI.Vte.Enums.CursorBlinkMode
instance GHC.Classes.Eq GI.Vte.Enums.CursorShape
instance GHC.Show.Show GI.Vte.Enums.CursorShape
instance GHC.Classes.Eq GI.Vte.Enums.EraseBinding
instance GHC.Show.Show GI.Vte.Enums.EraseBinding
instance GHC.Classes.Eq GI.Vte.Enums.Format
instance GHC.Show.Show GI.Vte.Enums.Format
instance GHC.Classes.Eq GI.Vte.Enums.PtyError
instance GHC.Show.Show GI.Vte.Enums.PtyError
instance GHC.Classes.Eq GI.Vte.Enums.RegexError
instance GHC.Show.Show GI.Vte.Enums.RegexError
instance GHC.Classes.Eq GI.Vte.Enums.TextBlinkMode
instance GHC.Show.Show GI.Vte.Enums.TextBlinkMode
instance GHC.Classes.Eq GI.Vte.Enums.WriteFlags
instance GHC.Show.Show GI.Vte.Enums.WriteFlags
instance GHC.Enum.Enum GI.Vte.Enums.CursorBlinkMode
instance GHC.Classes.Ord GI.Vte.Enums.CursorBlinkMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.CursorBlinkMode
instance GHC.Enum.Enum GI.Vte.Enums.CursorShape
instance GHC.Classes.Ord GI.Vte.Enums.CursorShape
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.CursorShape
instance GHC.Enum.Enum GI.Vte.Enums.EraseBinding
instance GHC.Classes.Ord GI.Vte.Enums.EraseBinding
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.EraseBinding
instance GHC.Enum.Enum GI.Vte.Enums.Format
instance GHC.Classes.Ord GI.Vte.Enums.Format
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.Format
instance GHC.Enum.Enum GI.Vte.Enums.PtyError
instance GHC.Classes.Ord GI.Vte.Enums.PtyError
instance Data.GI.Base.GError.GErrorClass GI.Vte.Enums.PtyError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.PtyError
instance GHC.Enum.Enum GI.Vte.Enums.RegexError
instance GHC.Classes.Ord GI.Vte.Enums.RegexError
instance Data.GI.Base.GError.GErrorClass GI.Vte.Enums.RegexError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.RegexError
instance GHC.Enum.Enum GI.Vte.Enums.TextBlinkMode
instance GHC.Classes.Ord GI.Vte.Enums.TextBlinkMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.TextBlinkMode
instance GHC.Enum.Enum GI.Vte.Enums.WriteFlags
instance GHC.Classes.Ord GI.Vte.Enums.WriteFlags
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Vte.Enums.WriteFlags

module GI.Vte.Flags

-- | No description available in the introspection data.
data PtyFlags

-- | Unused. Deprecated: 0.38
PtyFlagsNoLastlog :: PtyFlags

-- | Unused. Deprecated: 0.38
PtyFlagsNoUtmp :: PtyFlags

-- | Unused. Deprecated: 0.38
PtyFlagsNoWtmp :: PtyFlags

-- | Unused. Deprecated: 0.38
PtyFlagsNoHelper :: PtyFlags

-- | Unused. Deprecated: 0.38
PtyFlagsNoFallback :: PtyFlags

-- | Do not start a new session for the child in ptyChildSetup. See
--   man:setsid(2) for more information. Since: 0.58
PtyFlagsNoSession :: PtyFlags

-- | Do not set the PTY as the controlling TTY for the child in
--   ptyChildSetup. See man:tty_ioctl(4) for more information.
--   Since: 0.58
PtyFlagsNoCtty :: PtyFlags

-- | the default flags
PtyFlagsDefault :: PtyFlags

-- | Catch-all for unknown values
AnotherPtyFlags :: Int -> PtyFlags
instance GHC.Classes.Eq GI.Vte.Flags.PtyFlags
instance GHC.Show.Show GI.Vte.Flags.PtyFlags
instance GHC.Enum.Enum GI.Vte.Flags.PtyFlags
instance GHC.Classes.Ord GI.Vte.Flags.PtyFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Vte.Flags.PtyFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Vte.Flags.PtyFlags

module GI.Vte.Functions

-- | Gets a list of features vte was compiled with.
--   
--   Since: 0.40
getFeatures :: (HasCallStack, MonadIO m) => m Text

-- | Returns the major version of the VTE library at runtime. Contrast this
--   with MAJOR_VERSION which represents the version of the VTE
--   library that the code was compiled with.
--   
--   Since: 0.40
getMajorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the micro version of the VTE library at runtime. Contrast this
--   with MICRO_VERSION which represents the version of the VTE
--   library that the code was compiled with.
--   
--   Since: 0.40
getMicroVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the minor version of the VTE library at runtime. Contrast this
--   with MINOR_VERSION which represents the version of the VTE
--   library that the code was compiled with.
--   
--   Since: 0.40
getMinorVersion :: (HasCallStack, MonadIO m) => m Word32

-- | Gets the user's shell, or Nothing. In the latter case, the
--   system default (usually "/bin/sh") should be used.
getUserShell :: (HasCallStack, MonadIO m) => m [Char]

-- | No description available in the introspection data.
module GI.Vte.Objects.Pty

-- | Memory-managed wrapper type.
newtype Pty
Pty :: ManagedPtr Pty -> Pty

-- | Type class for types which can be safely cast to Pty, for
--   instance with toPty.
class GObject o => IsPty o

-- | Cast to Pty, for types for which this is known to be safe. For
--   general casts, use castTo.
toPty :: (MonadIO m, IsPty o) => o -> m Pty

-- | A convenience alias for Nothing :: Maybe Pty.
noPty :: Maybe Pty

-- | FIXMEchpe
ptyChildSetup :: (HasCallStack, MonadIO m, IsPty a) => a -> m ()

-- | Since 0.42 this is a no-op.

-- | Deprecated: (Since version 0.42)
ptyClose :: (HasCallStack, MonadIO m, IsPty a) => a -> m ()

-- | No description available in the introspection data.
ptyGetFd :: (HasCallStack, MonadIO m, IsPty a) => a -> m Int32

-- | Reads the pseudo terminal's window size.
--   
--   If getting the window size failed, error will be set
--   to a IOError.
ptyGetSize :: (HasCallStack, MonadIO m, IsPty a) => a -> m (Int32, Int32)

-- | Creates a new Pty for the PTY master fd.
--   
--   No entry will be made in the lastlog, utmp or wtmp system files.
--   
--   Note that the newly created Pty will take ownership of
--   fd and close it on finalize.
ptyNewForeignSync :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Maybe a -> m Pty

-- | Allocates a new pseudo-terminal.
--   
--   You can later use fork() or the spawnAsync
--   family of functions to start a process on the PTY.
--   
--   If using fork(), you MUST call ptyChildSetup in
--   the child.
--   
--   If using spawnAsync and friends, you MUST either use
--   ptyChildSetup directly as the child setup function, or call
--   ptyChildSetup from your own child setup function supplied.
--   
--   When using terminalSpawnSync with a custom child setup
--   function, ptyChildSetup will be called before the supplied
--   function; you must not call it again.
--   
--   Also, you MUST pass the SpawnFlagsDoNotReapChild flag.
ptyNewSync :: (HasCallStack, MonadIO m, IsCancellable a) => [PtyFlags] -> Maybe a -> m Pty

-- | Attempts to resize the pseudo terminal's window size. If successful,
--   the OS kernel will send SIGWINCH to the child process
--   group.
--   
--   If setting the window size failed, error will be set
--   to a IOError.
ptySetSize :: (HasCallStack, MonadIO m, IsPty a) => a -> Int32 -> Int32 -> m ()

-- | Tells the kernel whether the terminal is UTF-8 or not, in case it can
--   make use of the info. Linux 2.6.5 or so defines IUTF8 to make the line
--   discipline do multibyte backspace correctly.
ptySetUtf8 :: (HasCallStack, MonadIO m, IsPty a) => a -> Bool -> m ()

-- | No description available in the introspection data.
--   
--   Since: 0.48
ptySpawnFinish :: (HasCallStack, MonadIO m, IsPty a, IsAsyncResult b) => a -> b -> m Int32

-- | Construct a GValueConstruct with valid value for the
--   “fd” property. This is rarely needed directly, but it is used
--   by new.
constructPtyFd :: IsPty o => Int32 -> IO (GValueConstruct o)

-- | Get the value of the “fd” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get pty #fd
--   
getPtyFd :: (MonadIO m, IsPty o) => o -> m Int32

-- | Construct a GValueConstruct with valid value for the
--   “flags” property. This is rarely needed directly, but it is
--   used by new.
constructPtyFlags :: IsPty o => [PtyFlags] -> IO (GValueConstruct o)

-- | Get the value of the “flags” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get pty #flags
--   
getPtyFlags :: (MonadIO m, IsPty o) => o -> m [PtyFlags]
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Vte.Objects.Pty.Pty a) => GI.Vte.Objects.Pty.IsPty a
instance GI.Vte.Objects.Pty.IsPty GI.Vte.Objects.Pty.Pty
instance Data.GI.Base.BasicTypes.GObject GI.Vte.Objects.Pty.Pty
instance GI.GObject.Objects.Object.IsObject GI.Vte.Objects.Pty.Pty
instance GI.Gio.Interfaces.Initable.IsInitable GI.Vte.Objects.Pty.Pty

module GI.Vte.Callbacks

-- | Type for the callback on the (unwrapped) C side.
type C_SelectionFunc = Ptr Terminal -> CLong -> CLong -> Ptr () -> IO CInt

-- | Specifies the type of a selection function used to check whether a
--   cell has to be selected or not.
type SelectionFunc = Terminal " /@terminal@/: terminal in which the cell is. " -> CLong " /@column@/: column in which the cell is. " -> CLong " /@row@/: row in which the cell is. " -> IO Bool " __Returns:__ 'True' if cell has to be selected; 'False' if otherwise. "

-- | Specifies the type of a selection function used to check whether a
--   cell has to be selected or not.
type SelectionFunc_WithClosures = Terminal " /@terminal@/: terminal in which the cell is. " -> CLong " /@column@/: column in which the cell is. " -> CLong " /@row@/: row in which the cell is. " -> Ptr () " /@data@/: user data. " -> IO Bool " __Returns:__ 'True' if cell has to be selected; 'False' if otherwise. "

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SelectionFunc :: SelectionFunc -> SelectionFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_SelectionFunc :: (HasCallStack, MonadIO m, IsTerminal a) => FunPtr C_SelectionFunc -> a -> CLong -> CLong -> Ptr () -> m Bool

-- | Wrap the callback into a Closure.
genClosure_SelectionFunc :: SelectionFunc -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_SelectionFunc.
mk_SelectionFunc :: C_SelectionFunc -> IO (FunPtr C_SelectionFunc)

-- | A convenience synonym for Nothing :: Maybe
--   SelectionFunc.
noSelectionFunc :: Maybe SelectionFunc

-- | A convenience synonym for Nothing :: Maybe
--   SelectionFunc_WithClosures.
noSelectionFunc_WithClosures :: Maybe SelectionFunc_WithClosures

-- | Wrap a SelectionFunc into a C_SelectionFunc.
wrap_SelectionFunc :: Maybe (Ptr (FunPtr C_SelectionFunc)) -> SelectionFunc_WithClosures -> C_SelectionFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TerminalSpawnAsyncCallback = Ptr Terminal -> Int32 -> Ptr GError -> Ptr () -> IO ()

-- | Callback for terminalSpawnAsync.
--   
--   On success, pid contains the PID of the spawned
--   process, and error is Nothing. On failure,
--   pid is -1 and error contains the error
--   information.
--   
--   Since: 0.48
type TerminalSpawnAsyncCallback = Terminal " /@terminal@/: the 'GI.Vte.Objects.Terminal.Terminal' " -> Int32 " /@pid@/: a @/GPid/@ " -> GError " /@error@/: a 'GError', or 'Nothing' " -> IO ()

-- | Callback for terminalSpawnAsync.
--   
--   On success, pid contains the PID of the spawned
--   process, and error is Nothing. On failure,
--   pid is -1 and error contains the error
--   information.
--   
--   Since: 0.48
type TerminalSpawnAsyncCallback_WithClosures = Terminal " /@terminal@/: the 'GI.Vte.Objects.Terminal.Terminal' " -> Int32 " /@pid@/: a @/GPid/@ " -> GError " /@error@/: a 'GError', or 'Nothing' " -> Ptr () " /@userData@/: user data that was passed to vte_terminal_spawn_async " -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_TerminalSpawnAsyncCallback :: TerminalSpawnAsyncCallback -> TerminalSpawnAsyncCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TerminalSpawnAsyncCallback :: (HasCallStack, MonadIO m, IsTerminal a) => FunPtr C_TerminalSpawnAsyncCallback -> a -> Int32 -> GError -> Ptr () -> m ()

-- | Wrap the callback into a Closure.
genClosure_TerminalSpawnAsyncCallback :: TerminalSpawnAsyncCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalSpawnAsyncCallback.
mk_TerminalSpawnAsyncCallback :: C_TerminalSpawnAsyncCallback -> IO (FunPtr C_TerminalSpawnAsyncCallback)

-- | A convenience synonym for Nothing :: Maybe
--   TerminalSpawnAsyncCallback.
noTerminalSpawnAsyncCallback :: Maybe TerminalSpawnAsyncCallback

-- | A convenience synonym for Nothing :: Maybe
--   TerminalSpawnAsyncCallback_WithClosures.
noTerminalSpawnAsyncCallback_WithClosures :: Maybe TerminalSpawnAsyncCallback_WithClosures

-- | Wrap a TerminalSpawnAsyncCallback into a
--   C_TerminalSpawnAsyncCallback.
wrap_TerminalSpawnAsyncCallback :: Maybe (Ptr (FunPtr C_TerminalSpawnAsyncCallback)) -> TerminalSpawnAsyncCallback_WithClosures -> C_TerminalSpawnAsyncCallback

-- | No description available in the introspection data.
module GI.Vte.Structs.CharAttributes

-- | Memory-managed wrapper type.
newtype CharAttributes
CharAttributes :: ManagedPtr CharAttributes -> CharAttributes

-- | Construct a CharAttributes struct initialized to zero.
newZeroCharAttributes :: MonadIO m => m CharAttributes

-- | A convenience alias for Nothing :: Maybe
--   CharAttributes.
noCharAttributes :: Maybe CharAttributes
instance Data.GI.Base.BasicTypes.WrappedPtr GI.Vte.Structs.CharAttributes.CharAttributes
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Vte.Structs.CharAttributes.CharAttributes tag

-- | No description available in the introspection data.
module GI.Vte.Objects.Terminal

-- | Memory-managed wrapper type.
newtype Terminal
Terminal :: ManagedPtr Terminal -> Terminal

-- | Type class for types which can be safely cast to Terminal, for
--   instance with toTerminal.
class GObject o => IsTerminal o

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

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

-- | Places the selected text in the terminal in the
--   GDK_SELECTION_CLIPBOARD selection.

-- | Deprecated: (Since version 0.50)Use
--   terminalCopyClipboardFormat with FormatText instead.
terminalCopyClipboard :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | 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 SelectionData) will
--   include the text targets (see targetListAddTextTargets and
--   gtk_selection_data_targets_includes_text()). For
--   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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Format -> m ()

-- | Places the selected text in the terminal in the
--   GDK_SELECTION_PRIMARY selection.
terminalCopyPrimary :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe ByteString -> m ()

-- | Sends a block of UTF-8 text to the child as if it were entered by the
--   user at the keyboard.
terminalFeedChild :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe [Int8] -> m ()

-- | Sends a block of binary data to the child.
terminalFeedChildBinary :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe ByteString -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Checks whether or not hyperlinks (OSC 8 escape sequence) are allowed.
--   
--   Since: 0.50
terminalGetAllowHyperlink :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Checks whether or not the terminal will beep when the child outputs
--   the "bl" sequence.
terminalGetAudibleBell :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.
--   
--   Since: 0.52
terminalGetCellHeightScale :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Double

-- | No description available in the introspection data.
--   
--   Since: 0.52
terminalGetCellWidthScale :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Double

-- | No description available in the introspection data.
terminalGetCharHeight :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CLong

-- | No description available in the introspection data.
terminalGetCharWidth :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CLong

-- | Returns whether ambiguous-width characters are narrow or wide. (Note
--   that when using a non-UTF-8 encoding set via
--   terminalSetEncoding, the width of ambiguous-width characters is
--   fixed and determined by the encoding itself.)
terminalGetCjkAmbiguousWidth :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Int32

-- | Returns the background colour, as used by terminal
--   when drawing the background, which may be different from the color set
--   by 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 terminalSetClearBackground) and
--   then need to draw the background yourself.
--   
--   Since: 0.54
terminalGetColorBackgroundForDraw :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m RGBA

-- | No description available in the introspection data.
terminalGetColumnCount :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CLong

-- | No description available in the introspection data.
terminalGetCurrentDirectoryUri :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | No description available in the introspection data.
terminalGetCurrentFileUri :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | Returns the currently set cursor blink mode.
terminalGetCursorBlinkMode :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CursorBlinkMode

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (CLong, CLong)

-- | Returns the currently set cursor shape.
terminalGetCursorShape :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CursorShape

-- | Checks whether the terminal performs bidirectional text rendering.
--   
--   Since: 0.58
terminalGetEnableBidi :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Checks whether the terminal shapes Arabic text.
--   
--   Since: 0.58
terminalGetEnableShaping :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Determines the name of the encoding in which the terminal expects data
--   to be encoded, or Nothing if UTF-8 is in use.

-- | Deprecated: (Since version 0.54)Support for non-UTF-8 is
--   deprecated.
terminalGetEncoding :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m FontDescription

-- | No description available in the introspection data.
terminalGetFontScale :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Double

-- | Fills in some hints from terminal's
--   geometry. The hints filled are those covered by the
--   WindowHintsResizeInc, WindowHintsMinSize and
--   WindowHintsBaseSize flags.
--   
--   See windowSetGeometryHints for more information.
--   
--   terminal must be realized (see
--   widgetGetRealized).

-- | Deprecated: (Since version 0.52)
terminalGetGeometryHints :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> Int32 -> m Geometry

-- | Checks if the terminal currently contains selected text. Note that
--   this is different from determining if the terminal is the owner of any
--   Clipboard items.
terminalGetHasSelection :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.

-- | Deprecated: (Since version 0.54)
terminalGetIconTitle :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | Returns whether the terminal allow user input.
terminalGetInputEnabled :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | 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 terminalSetMouseAutohide.
terminalGetMouseAutohide :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Returns the Pty of terminal.
terminalGetPty :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Pty

-- | Checks whether or not the terminal will rewrap its contents upon
--   resize.

-- | Deprecated: (Since version 0.58)
terminalGetRewrapOnResize :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.
terminalGetRowCount :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CLong

-- | No description available in the introspection data.
--   
--   Since: 0.52
terminalGetScrollOnKeystroke :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.
--   
--   Since: 0.52
terminalGetScrollOnOutput :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.
--   
--   Since: 0.52
terminalGetScrollbackLines :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m CLong

-- | Checks whether or not the terminal will allow blinking text.
--   
--   Since: 0.52
terminalGetTextBlinkMode :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m TextBlinkMode

-- | No description available in the introspection data.
terminalGetWindowTitle :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m (Maybe Text)

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Event -> m Text

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

-- | Deprecated: (Since version 0.46)Use terminalMatchAddRegex or
--   vte_terminal_match_add_regex_full() instead.
terminalMatchAddGregex :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Regex -> [RegexMatchFlags] -> m 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Regex -> Word32 -> m Int32

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

-- | Deprecated: (Since version 0.46)Use terminalMatchCheckEvent
--   instead.
terminalMatchCheck :: (HasCallStack, MonadIO m, IsTerminal a) => a -> CLong -> CLong -> m (Text, Int32)

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Event -> m (Text, Int32)

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> m ()

-- | Clears the list of regular expressions the terminal uses to highlight
--   text when the user moves the mouse cursor.
terminalMatchRemoveAll :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | Sets which cursor the terminal will use if the pointer is over the
--   pattern specified by tag. The terminal keeps a
--   reference to cursor.

-- | Deprecated: (Since version 0.40)Use
--   terminalMatchSetCursorName instead.
terminalMatchSetCursor :: (HasCallStack, MonadIO m, IsTerminal a, IsCursor b) => a -> Int32 -> Maybe b -> m ()

-- | Sets which cursor the terminal will use if the pointer is over the
--   pattern specified by tag.
terminalMatchSetCursorName :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> Text -> m ()

-- | Sets which cursor the terminal will use if the pointer is over the
--   pattern specified by tag.

-- | Deprecated: (Since version 0.54)Use
--   terminalMatchSetCursorName instead.
terminalMatchSetCursorType :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> CursorType -> m ()

-- | Creates a new terminal widget.
terminalNew :: (HasCallStack, MonadIO m) => m Terminal

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | Creates a new Pty, and sets the emulation property from
--   Terminal:emulation.
--   
--   See vte_pty_new() for more information.
terminalPtyNewSync :: (HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) => a -> [PtyFlags] -> Maybe b -> m Pty

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> Bool -> m ()

-- | Searches the next string matching the search regex set with
--   terminalSearchSetRegex.
terminalSearchFindNext :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | Searches the previous string matching the search regex set with
--   terminalSearchSetRegex.
terminalSearchFindPrevious :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

-- | No description available in the introspection data.

-- | Deprecated: (Since version 0.46)use terminalSearchGetRegex
--   instead.
terminalSearchGetGregex :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Regex

-- | No description available in the introspection data.
--   
--   Since: 0.46
terminalSearchGetRegex :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Regex

-- | No description available in the introspection data.
terminalSearchGetWrapAround :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m Bool

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

-- | Deprecated: (Since version 0.46)use terminalSearchSetRegex
--   instead.
terminalSearchSetGregex :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe Regex -> [RegexMatchFlags] -> m ()

-- | Sets the regex to search for. Unsets the search regex when passed
--   Nothing.
--   
--   Since: 0.46
terminalSearchSetRegex :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe Regex -> Word32 -> m ()

-- | Sets whether search should wrap around to the beginning of the
--   terminal content when reaching its end.
terminalSearchSetWrapAround :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | Selects all text within the terminal (including the scrollback
--   buffer).
terminalSelectAll :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | Controls whether or not hyperlinks (OSC 8 escape sequence) are
--   allowed.
--   
--   Since: 0.50
terminalSetAllowHyperlink :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | Controls whether or not the terminal will beep when the child outputs
--   the "bl" sequence.
terminalSetAudibleBell :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> EraseBinding -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Double -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Double -> m ()

-- | This setting controls whether ambiguous-width characters are narrow or
--   wide. (Note that when using a non-UTF-8 encoding set via
--   terminalSetEncoding, the width of ambiguous-width characters is
--   fixed and determined by the encoding itself.)
terminalSetCjkAmbiguousWidth :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> RGBA -> m ()

-- | Sets the color used to draw bold text in the default foreground color.
--   If bold is Nothing then the default color is
--   used.
terminalSetColorBold :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> m ()

-- | Sets the foreground color used to draw normal text.
terminalSetColorForeground :: (HasCallStack, MonadIO m, IsTerminal a) => a -> RGBA -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe RGBA -> Maybe RGBA -> Maybe [RGBA] -> m ()

-- | Sets whether or not the cursor will blink. Using
--   CursorBlinkModeSystem will use the
--   Settings::gtk-cursor-blink setting.
terminalSetCursorBlinkMode :: (HasCallStack, MonadIO m, IsTerminal a) => a -> CursorBlinkMode -> m ()

-- | Sets the shape of the cursor drawn.
terminalSetCursorShape :: (HasCallStack, MonadIO m, IsTerminal a) => a -> CursorShape -> m ()

-- | Reset the terminal palette to reasonable compiled-in default color.
terminalSetDefaultColors :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> EraseBinding -> m ()

-- | Controls whether or not the terminal will perform bidirectional text
--   rendering.
--   
--   Since: 0.58
terminalSetEnableBidi :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | Controls whether or not the terminal will shape Arabic text.
--   
--   Since: 0.58
terminalSetEnableShaping :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

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

-- | Deprecated: (Since version 0.54)Support for non-UTF-8 is
--   deprecated.
terminalSetEncoding :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe Text -> m ()

-- | Sets the font used for rendering all text displayed by the terminal,
--   overriding any fonts set using 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Maybe FontDescription -> m ()

-- | Sets the terminal's font scale to scale.
terminalSetFontScale :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Double -> m ()

-- | Sets terminal as window's geometry
--   widget. See windowSetGeometryHints for more information.
--   
--   terminal must be realized (see
--   widgetGetRealized).

-- | Deprecated: (Since version 0.52)
terminalSetGeometryHintsForWindow :: (HasCallStack, MonadIO m, IsTerminal a, IsWindow b) => a -> b -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 terminalGetMouseAutohide.
terminalSetMouseAutohide :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | Sets pty as the PTY to use in
--   terminal. Use Nothing to unset the PTY.
terminalSetPty :: (HasCallStack, MonadIO m, IsTerminal a, IsPty b) => a -> Maybe b -> m ()

-- | Controls whether or not the terminal will rewrap its contents,
--   including the scrollback history, whenever the terminal's width
--   changes.

-- | Deprecated: (Since version 0.58)
terminalSetRewrapOnResize :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Bool -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> CLong -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> CLong -> CLong -> m ()

-- | Controls whether or not the terminal will allow blinking text.
--   
--   Since: 0.52
terminalSetTextBlinkMode :: (HasCallStack, MonadIO m, IsTerminal a) => a -> TextBlinkMode -> m ()

-- | 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 :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Text -> m ()

-- | 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 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(), spawnAsync and
--   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
--   terminalGetCurrentDirectoryUri, getCurrentDir or
--   get_current_dir_name().

-- | Deprecated: (Since version 0.48)Use terminalSpawnAsync
--   instead.
terminalSpawnSync :: (HasCallStack, MonadIO m, IsTerminal a, IsCancellable b) => a -> [PtyFlags] -> Maybe Text -> [[Char]] -> Maybe [[Char]] -> [SpawnFlags] -> Maybe SpawnChildSetupFunc -> Maybe b -> m Int32

-- | Clears the current selection.
terminalUnselectAll :: (HasCallStack, MonadIO m, IsTerminal a) => a -> m ()

-- | Watches childPid. When the process exists, the
--   Terminal::child-exited signal will be called
--   with the child's exit status.
--   
--   Prior to calling this function, a Pty must have been set in
--   terminal using terminalSetPty. When the child
--   exits, the terminal's Pty will be set to Nothing.
--   
--   Note: g_child_watch_add() or childWatchAdd must
--   not have been called for childPid, nor a Source
--   for it been created with childWatchSourceNew.
--   
--   Note: when using the spawnAsync family of functions, the
--   SpawnFlagsDoNotReapChild flag MUST have been passed.
terminalWatchChild :: (HasCallStack, MonadIO m, IsTerminal a) => a -> Int32 -> m ()

-- | 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
--   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 :: (HasCallStack, MonadIO m, IsTerminal a, IsOutputStream b, IsCancellable c) => a -> b -> WriteFlags -> Maybe c -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “allow-bold” property. This is rarely needed directly, but it
--   is used by new.
constructTerminalAllowBold :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “allow-bold” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #allowBold
--   
getTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “allow-bold” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #allowBold := value ]
--   
setTerminalAllowBold :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “allow-hyperlink” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalAllowHyperlink :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “allow-hyperlink” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #allowHyperlink
--   
getTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “allow-hyperlink” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #allowHyperlink := value ]
--   
setTerminalAllowHyperlink :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “audible-bell” property. This is rarely needed directly, but
--   it is used by new.
constructTerminalAudibleBell :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “audible-bell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #audibleBell
--   
getTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “audible-bell” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #audibleBell := value ]
--   
setTerminalAudibleBell :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “backspace-binding” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalBackspaceBinding :: IsTerminal o => EraseBinding -> IO (GValueConstruct o)

-- | Get the value of the “backspace-binding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #backspaceBinding
--   
getTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> m EraseBinding

-- | Set the value of the “backspace-binding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #backspaceBinding := value ]
--   
setTerminalBackspaceBinding :: (MonadIO m, IsTerminal o) => o -> EraseBinding -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “bold-is-bright” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalBoldIsBright :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “bold-is-bright” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #boldIsBright
--   
getTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “bold-is-bright” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #boldIsBright := value ]
--   
setTerminalBoldIsBright :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-height-scale” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalCellHeightScale :: IsTerminal o => Double -> IO (GValueConstruct o)

-- | Get the value of the “cell-height-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #cellHeightScale
--   
getTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> m Double

-- | Set the value of the “cell-height-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #cellHeightScale := value ]
--   
setTerminalCellHeightScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cell-width-scale” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalCellWidthScale :: IsTerminal o => Double -> IO (GValueConstruct o)

-- | Get the value of the “cell-width-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #cellWidthScale
--   
getTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> m Double

-- | Set the value of the “cell-width-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #cellWidthScale := value ]
--   
setTerminalCellWidthScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cjk-ambiguous-width” property. This is rarely needed
--   directly, but it is used by new.
constructTerminalCjkAmbiguousWidth :: IsTerminal o => Int32 -> IO (GValueConstruct o)

-- | Get the value of the “cjk-ambiguous-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #cjkAmbiguousWidth
--   
getTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> m Int32

-- | Set the value of the “cjk-ambiguous-width” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #cjkAmbiguousWidth := value ]
--   
setTerminalCjkAmbiguousWidth :: (MonadIO m, IsTerminal o) => o -> Int32 -> m ()

-- | Get the value of the “current-directory-uri” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #currentDirectoryUri
--   
getTerminalCurrentDirectoryUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Get the value of the “current-file-uri” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #currentFileUri
--   
getTerminalCurrentFileUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “cursor-blink-mode” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalCursorBlinkMode :: IsTerminal o => CursorBlinkMode -> IO (GValueConstruct o)

-- | Get the value of the “cursor-blink-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #cursorBlinkMode
--   
getTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> m CursorBlinkMode

-- | Set the value of the “cursor-blink-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #cursorBlinkMode := value ]
--   
setTerminalCursorBlinkMode :: (MonadIO m, IsTerminal o) => o -> CursorBlinkMode -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “cursor-shape” property. This is rarely needed directly, but
--   it is used by new.
constructTerminalCursorShape :: IsTerminal o => CursorShape -> IO (GValueConstruct o)

-- | Get the value of the “cursor-shape” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #cursorShape
--   
getTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> m CursorShape

-- | Set the value of the “cursor-shape” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #cursorShape := value ]
--   
setTerminalCursorShape :: (MonadIO m, IsTerminal o) => o -> CursorShape -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “delete-binding” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalDeleteBinding :: IsTerminal o => EraseBinding -> IO (GValueConstruct o)

-- | Get the value of the “delete-binding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #deleteBinding
--   
getTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> m EraseBinding

-- | Set the value of the “delete-binding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #deleteBinding := value ]
--   
setTerminalDeleteBinding :: (MonadIO m, IsTerminal o) => o -> EraseBinding -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-bidi” property. This is rarely needed directly, but
--   it is used by new.
constructTerminalEnableBidi :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “enable-bidi” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #enableBidi
--   
getTerminalEnableBidi :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “enable-bidi” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #enableBidi := value ]
--   
setTerminalEnableBidi :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “enable-shaping” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalEnableShaping :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “enable-shaping” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #enableShaping
--   
getTerminalEnableShaping :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “enable-shaping” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #enableShaping := value ]
--   
setTerminalEnableShaping :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Set the value of the “encoding” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #encoding
--   
clearTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “encoding” property. This is rarely needed directly, but it
--   is used by new.
constructTerminalEncoding :: IsTerminal o => Text -> IO (GValueConstruct o)

-- | Get the value of the “encoding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #encoding
--   
getTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Set the value of the “encoding” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #encoding := value ]
--   
setTerminalEncoding :: (MonadIO m, IsTerminal o) => o -> Text -> m ()

-- | Set the value of the “font-desc” property to Nothing.
--   When overloading is enabled, this is equivalent to
--   
--   
--   clear #fontDesc
--   
clearTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-desc” property. This is rarely needed directly, but it
--   is used by new.
constructTerminalFontDesc :: IsTerminal o => FontDescription -> IO (GValueConstruct o)

-- | Get the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #fontDesc
--   
getTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> m (Maybe FontDescription)

-- | Set the value of the “font-desc” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #fontDesc := value ]
--   
setTerminalFontDesc :: (MonadIO m, IsTerminal o) => o -> FontDescription -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “font-scale” property. This is rarely needed directly, but it
--   is used by new.
constructTerminalFontScale :: IsTerminal o => Double -> IO (GValueConstruct o)

-- | Get the value of the “font-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #fontScale
--   
getTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> m Double

-- | Set the value of the “font-scale” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #fontScale := value ]
--   
setTerminalFontScale :: (MonadIO m, IsTerminal o) => o -> Double -> m ()

-- | Get the value of the “hyperlink-hover-uri” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #hyperlinkHoverUri
--   
getTerminalHyperlinkHoverUri :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Get the value of the “icon-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #iconTitle
--   
getTerminalIconTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Construct a GValueConstruct with valid value for the
--   “input-enabled” property. This is rarely needed directly, but
--   it is used by new.
constructTerminalInputEnabled :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “input-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #inputEnabled
--   
getTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “input-enabled” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #inputEnabled := value ]
--   
setTerminalInputEnabled :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pointer-autohide” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalPointerAutohide :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “pointer-autohide” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #pointerAutohide
--   
getTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “pointer-autohide” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #pointerAutohide := value ]
--   
setTerminalPointerAutohide :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Set the value of the “pty” property to Nothing. When
--   overloading is enabled, this is equivalent to
--   
--   
--   clear #pty
--   
clearTerminalPty :: (MonadIO m, IsTerminal o) => o -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “pty” property. This is rarely needed directly, but it is
--   used by new.
constructTerminalPty :: (IsTerminal o, IsPty a) => a -> IO (GValueConstruct o)

-- | Get the value of the “pty” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   get terminal #pty
--   
getTerminalPty :: (MonadIO m, IsTerminal o) => o -> m Pty

-- | Set the value of the “pty” property. When overloading
--   is enabled, this is equivalent to
--   
--   
--   set terminal [ #pty := value ]
--   
setTerminalPty :: (MonadIO m, IsTerminal o, IsPty a) => o -> a -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “rewrap-on-resize” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalRewrapOnResize :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “rewrap-on-resize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #rewrapOnResize
--   
getTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “rewrap-on-resize” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #rewrapOnResize := value ]
--   
setTerminalRewrapOnResize :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scroll-on-keystroke” property. This is rarely needed
--   directly, but it is used by new.
constructTerminalScrollOnKeystroke :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “scroll-on-keystroke” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #scrollOnKeystroke
--   
getTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “scroll-on-keystroke” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #scrollOnKeystroke := value ]
--   
setTerminalScrollOnKeystroke :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scroll-on-output” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalScrollOnOutput :: IsTerminal o => Bool -> IO (GValueConstruct o)

-- | Get the value of the “scroll-on-output” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #scrollOnOutput
--   
getTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> m Bool

-- | Set the value of the “scroll-on-output” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #scrollOnOutput := value ]
--   
setTerminalScrollOnOutput :: (MonadIO m, IsTerminal o) => o -> Bool -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “scrollback-lines” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalScrollbackLines :: IsTerminal o => Word32 -> IO (GValueConstruct o)

-- | Get the value of the “scrollback-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #scrollbackLines
--   
getTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> m Word32

-- | Set the value of the “scrollback-lines” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #scrollbackLines := value ]
--   
setTerminalScrollbackLines :: (MonadIO m, IsTerminal o) => o -> Word32 -> m ()

-- | Construct a GValueConstruct with valid value for the
--   “text-blink-mode” property. This is rarely needed directly,
--   but it is used by new.
constructTerminalTextBlinkMode :: IsTerminal o => TextBlinkMode -> IO (GValueConstruct o)

-- | Get the value of the “text-blink-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #textBlinkMode
--   
getTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> m TextBlinkMode

-- | Set the value of the “text-blink-mode” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   set terminal [ #textBlinkMode := value ]
--   
setTerminalTextBlinkMode :: (MonadIO m, IsTerminal o) => o -> TextBlinkMode -> m ()

-- | Get the value of the “window-title” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #windowTitle
--   
getTerminalWindowTitle :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

-- | Get the value of the “word-char-exceptions” property. When
--   overloading is enabled, this is equivalent to
--   
--   
--   get terminal #wordCharExceptions
--   
getTerminalWordCharExceptions :: (MonadIO m, IsTerminal o) => o -> m (Maybe Text)

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

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

-- | Connect a signal handler for the “bell” signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after terminal #bell callback
--   
afterTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalBell :: TerminalBellCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalBellCallback.
mk_TerminalBellCallback :: C_TerminalBellCallback -> IO (FunPtr C_TerminalBellCallback)

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

-- | Connect a signal handler for the “bell” signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on terminal #bell callback
--   
onTerminalBell :: (IsTerminal a, MonadIO m) => a -> TerminalBellCallback -> m SignalHandlerId

-- | Wrap a TerminalBellCallback into a
--   C_TerminalBellCallback.
wrap_TerminalBellCallback :: TerminalBellCallback -> C_TerminalBellCallback

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

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

-- | Connect a signal handler for the “char-size-changed” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #charSizeChanged callback
--   
afterTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCharSizeChanged :: TerminalCharSizeChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCharSizeChangedCallback.
mk_TerminalCharSizeChangedCallback :: C_TerminalCharSizeChangedCallback -> IO (FunPtr C_TerminalCharSizeChangedCallback)

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

-- | Connect a signal handler for the “char-size-changed” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #charSizeChanged callback
--   
onTerminalCharSizeChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCharSizeChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalCharSizeChangedCallback into a
--   C_TerminalCharSizeChangedCallback.
wrap_TerminalCharSizeChangedCallback :: TerminalCharSizeChangedCallback -> C_TerminalCharSizeChangedCallback

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

-- | This signal is emitted when the terminal detects that a child watched
--   using terminalWatchChild has exited.
type TerminalChildExitedCallback = Int32 " /@status@/: the child\'s exit status " -> IO ()

-- | Connect a signal handler for the “child-exited” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #childExited callback
--   
afterTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalChildExited :: TerminalChildExitedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalChildExitedCallback.
mk_TerminalChildExitedCallback :: C_TerminalChildExitedCallback -> IO (FunPtr C_TerminalChildExitedCallback)

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

-- | Connect a signal handler for the “child-exited” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #childExited callback
--   
onTerminalChildExited :: (IsTerminal a, MonadIO m) => a -> TerminalChildExitedCallback -> m SignalHandlerId

-- | Wrap a TerminalChildExitedCallback into a
--   C_TerminalChildExitedCallback.
wrap_TerminalChildExitedCallback :: TerminalChildExitedCallback -> C_TerminalChildExitedCallback

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

-- | 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 = Text " /@text@/: a string of text " -> Word32 " /@size@/: the length of that string of text " -> IO ()

-- | Connect a signal handler for the “commit” signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after terminal #commit callback
--   
afterTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCommit :: TerminalCommitCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCommitCallback.
mk_TerminalCommitCallback :: C_TerminalCommitCallback -> IO (FunPtr C_TerminalCommitCallback)

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

-- | Connect a signal handler for the “commit” signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on terminal #commit callback
--   
onTerminalCommit :: (IsTerminal a, MonadIO m) => a -> TerminalCommitCallback -> m SignalHandlerId

-- | Wrap a TerminalCommitCallback into a
--   C_TerminalCommitCallback.
wrap_TerminalCommitCallback :: TerminalCommitCallback -> C_TerminalCommitCallback

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

-- | Emitted whenever the visible appearance of the terminal has changed.
--   Used primarily by VteTerminalAccessible.
type TerminalContentsChangedCallback = IO ()

-- | Connect a signal handler for the “contents-changed” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #contentsChanged callback
--   
afterTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalContentsChanged :: TerminalContentsChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalContentsChangedCallback.
mk_TerminalContentsChangedCallback :: C_TerminalContentsChangedCallback -> IO (FunPtr C_TerminalContentsChangedCallback)

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

-- | Connect a signal handler for the “contents-changed” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #contentsChanged callback
--   
onTerminalContentsChanged :: (IsTerminal a, MonadIO m) => a -> TerminalContentsChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalContentsChangedCallback into a
--   C_TerminalContentsChangedCallback.
wrap_TerminalContentsChangedCallback :: TerminalContentsChangedCallback -> C_TerminalContentsChangedCallback

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

-- | Emitted whenever terminalCopyClipboard is called.
type TerminalCopyClipboardCallback = IO ()

-- | Connect a signal handler for the “copy-clipboard” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #copyClipboard callback
--   
afterTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCopyClipboard :: TerminalCopyClipboardCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCopyClipboardCallback.
mk_TerminalCopyClipboardCallback :: C_TerminalCopyClipboardCallback -> IO (FunPtr C_TerminalCopyClipboardCallback)

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

-- | Connect a signal handler for the “copy-clipboard” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #copyClipboard callback
--   
onTerminalCopyClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalCopyClipboardCallback -> m SignalHandlerId

-- | Wrap a TerminalCopyClipboardCallback into a
--   C_TerminalCopyClipboardCallback.
wrap_TerminalCopyClipboardCallback :: TerminalCopyClipboardCallback -> C_TerminalCopyClipboardCallback

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

-- | Emitted when the current directory URI is modified.
type TerminalCurrentDirectoryUriChangedCallback = IO ()

-- | Connect a signal handler for the
--   “current-directory-uri-changed” signal, to be run after the
--   default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after terminal #currentDirectoryUriChanged callback
--   
afterTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCurrentDirectoryUriChanged :: TerminalCurrentDirectoryUriChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCurrentDirectoryUriChangedCallback.
mk_TerminalCurrentDirectoryUriChangedCallback :: C_TerminalCurrentDirectoryUriChangedCallback -> IO (FunPtr C_TerminalCurrentDirectoryUriChangedCallback)

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

-- | Connect a signal handler for the
--   “current-directory-uri-changed” signal, to be run before the
--   default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on terminal #currentDirectoryUriChanged callback
--   
onTerminalCurrentDirectoryUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentDirectoryUriChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalCurrentDirectoryUriChangedCallback into a
--   C_TerminalCurrentDirectoryUriChangedCallback.
wrap_TerminalCurrentDirectoryUriChangedCallback :: TerminalCurrentDirectoryUriChangedCallback -> C_TerminalCurrentDirectoryUriChangedCallback

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

-- | Emitted when the current file URI is modified.
type TerminalCurrentFileUriChangedCallback = IO ()

-- | Connect a signal handler for the “current-file-uri-changed”
--   signal, to be run after the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   after terminal #currentFileUriChanged callback
--   
afterTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCurrentFileUriChanged :: TerminalCurrentFileUriChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCurrentFileUriChangedCallback.
mk_TerminalCurrentFileUriChangedCallback :: C_TerminalCurrentFileUriChangedCallback -> IO (FunPtr C_TerminalCurrentFileUriChangedCallback)

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

-- | Connect a signal handler for the “current-file-uri-changed”
--   signal, to be run before the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   on terminal #currentFileUriChanged callback
--   
onTerminalCurrentFileUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalCurrentFileUriChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalCurrentFileUriChangedCallback into a
--   C_TerminalCurrentFileUriChangedCallback.
wrap_TerminalCurrentFileUriChangedCallback :: TerminalCurrentFileUriChangedCallback -> C_TerminalCurrentFileUriChangedCallback

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

-- | Emitted whenever the cursor moves to a new character cell. Used
--   primarily by VteTerminalAccessible.
type TerminalCursorMovedCallback = IO ()

-- | Connect a signal handler for the “cursor-moved” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #cursorMoved callback
--   
afterTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalCursorMoved :: TerminalCursorMovedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalCursorMovedCallback.
mk_TerminalCursorMovedCallback :: C_TerminalCursorMovedCallback -> IO (FunPtr C_TerminalCursorMovedCallback)

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

-- | Connect a signal handler for the “cursor-moved” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #cursorMoved callback
--   
onTerminalCursorMoved :: (IsTerminal a, MonadIO m) => a -> TerminalCursorMovedCallback -> m SignalHandlerId

-- | Wrap a TerminalCursorMovedCallback into a
--   C_TerminalCursorMovedCallback.
wrap_TerminalCursorMovedCallback :: TerminalCursorMovedCallback -> C_TerminalCursorMovedCallback

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

-- | Emitted when the user hits the '-' key while holding the Control key.
type TerminalDecreaseFontSizeCallback = IO ()

-- | Connect a signal handler for the “decrease-font-size” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #decreaseFontSize callback
--   
afterTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalDecreaseFontSize :: TerminalDecreaseFontSizeCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalDecreaseFontSizeCallback.
mk_TerminalDecreaseFontSizeCallback :: C_TerminalDecreaseFontSizeCallback -> IO (FunPtr C_TerminalDecreaseFontSizeCallback)

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

-- | Connect a signal handler for the “decrease-font-size” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #decreaseFontSize callback
--   
onTerminalDecreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalDecreaseFontSizeCallback -> m SignalHandlerId

-- | Wrap a TerminalDecreaseFontSizeCallback into a
--   C_TerminalDecreaseFontSizeCallback.
wrap_TerminalDecreaseFontSizeCallback :: TerminalDecreaseFontSizeCallback -> C_TerminalDecreaseFontSizeCallback

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

-- | Emitted at the child application's request.
type TerminalDeiconifyWindowCallback = IO ()

-- | Connect a signal handler for the “deiconify-window” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #deiconifyWindow callback
--   
afterTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalDeiconifyWindow :: TerminalDeiconifyWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalDeiconifyWindowCallback.
mk_TerminalDeiconifyWindowCallback :: C_TerminalDeiconifyWindowCallback -> IO (FunPtr C_TerminalDeiconifyWindowCallback)

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

-- | Connect a signal handler for the “deiconify-window” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #deiconifyWindow callback
--   
onTerminalDeiconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalDeiconifyWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalDeiconifyWindowCallback into a
--   C_TerminalDeiconifyWindowCallback.
wrap_TerminalDeiconifyWindowCallback :: TerminalDeiconifyWindowCallback -> C_TerminalDeiconifyWindowCallback

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

-- | Emitted whenever the terminal's current encoding has changed.
--   
--   Note: support for non-UTF-8 is deprecated.
type TerminalEncodingChangedCallback = IO ()

-- | Connect a signal handler for the “encoding-changed” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #encodingChanged callback
--   
afterTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalEncodingChanged :: TerminalEncodingChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalEncodingChangedCallback.
mk_TerminalEncodingChangedCallback :: C_TerminalEncodingChangedCallback -> IO (FunPtr C_TerminalEncodingChangedCallback)

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

-- | Connect a signal handler for the “encoding-changed” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #encodingChanged callback
--   
onTerminalEncodingChanged :: (IsTerminal a, MonadIO m) => a -> TerminalEncodingChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalEncodingChangedCallback into a
--   C_TerminalEncodingChangedCallback.
wrap_TerminalEncodingChangedCallback :: TerminalEncodingChangedCallback -> C_TerminalEncodingChangedCallback

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

-- | 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 Terminal::child-exited signal.
type TerminalEofCallback = IO ()

-- | Connect a signal handler for the “eof” signal, to be run
--   after the default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after terminal #eof callback
--   
afterTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalEof :: TerminalEofCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalEofCallback.
mk_TerminalEofCallback :: C_TerminalEofCallback -> IO (FunPtr C_TerminalEofCallback)

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

-- | Connect a signal handler for the “eof” signal, to be run
--   before the default handler. When overloading is enabled, this
--   is equivalent to
--   
--   
--   on terminal #eof callback
--   
onTerminalEof :: (IsTerminal a, MonadIO m) => a -> TerminalEofCallback -> m SignalHandlerId

-- | Wrap a TerminalEofCallback into a C_TerminalEofCallback.
wrap_TerminalEofCallback :: TerminalEofCallback -> C_TerminalEofCallback

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

-- | 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 = Text " /@uri@/: the nonempty target URI under the mouse, or NULL " -> Rectangle " /@bbox@/: the bounding box of the hyperlink anchor text, or NULL " -> IO ()

-- | Connect a signal handler for the
--   “hyperlink-hover-uri-changed” signal, to be run after the
--   default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   after terminal #hyperlinkHoverUriChanged callback
--   
afterTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalHyperlinkHoverUriChanged :: TerminalHyperlinkHoverUriChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalHyperlinkHoverUriChangedCallback.
mk_TerminalHyperlinkHoverUriChangedCallback :: C_TerminalHyperlinkHoverUriChangedCallback -> IO (FunPtr C_TerminalHyperlinkHoverUriChangedCallback)

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

-- | Connect a signal handler for the
--   “hyperlink-hover-uri-changed” signal, to be run before the
--   default handler. When overloading is enabled, this is
--   equivalent to
--   
--   
--   on terminal #hyperlinkHoverUriChanged callback
--   
onTerminalHyperlinkHoverUriChanged :: (IsTerminal a, MonadIO m) => a -> TerminalHyperlinkHoverUriChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalHyperlinkHoverUriChangedCallback into a
--   C_TerminalHyperlinkHoverUriChangedCallback.
wrap_TerminalHyperlinkHoverUriChangedCallback :: TerminalHyperlinkHoverUriChangedCallback -> C_TerminalHyperlinkHoverUriChangedCallback

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

-- | No description available in the introspection data.

-- | Deprecated: (Since version 0.54)This signal is never emitted.
type TerminalIconTitleChangedCallback = IO ()

-- | Connect a signal handler for the “icon-title-changed” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #iconTitleChanged callback
--   
afterTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalIconTitleChanged :: TerminalIconTitleChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalIconTitleChangedCallback.
mk_TerminalIconTitleChangedCallback :: C_TerminalIconTitleChangedCallback -> IO (FunPtr C_TerminalIconTitleChangedCallback)

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

-- | Connect a signal handler for the “icon-title-changed” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #iconTitleChanged callback
--   
onTerminalIconTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalIconTitleChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalIconTitleChangedCallback into a
--   C_TerminalIconTitleChangedCallback.
wrap_TerminalIconTitleChangedCallback :: TerminalIconTitleChangedCallback -> C_TerminalIconTitleChangedCallback

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

-- | Emitted at the child application's request.
type TerminalIconifyWindowCallback = IO ()

-- | Connect a signal handler for the “iconify-window” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #iconifyWindow callback
--   
afterTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalIconifyWindow :: TerminalIconifyWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalIconifyWindowCallback.
mk_TerminalIconifyWindowCallback :: C_TerminalIconifyWindowCallback -> IO (FunPtr C_TerminalIconifyWindowCallback)

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

-- | Connect a signal handler for the “iconify-window” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #iconifyWindow callback
--   
onTerminalIconifyWindow :: (IsTerminal a, MonadIO m) => a -> TerminalIconifyWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalIconifyWindowCallback into a
--   C_TerminalIconifyWindowCallback.
wrap_TerminalIconifyWindowCallback :: TerminalIconifyWindowCallback -> C_TerminalIconifyWindowCallback

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

-- | Emitted when the user hits the '+' key while holding the Control key.
type TerminalIncreaseFontSizeCallback = IO ()

-- | Connect a signal handler for the “increase-font-size” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #increaseFontSize callback
--   
afterTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalIncreaseFontSize :: TerminalIncreaseFontSizeCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalIncreaseFontSizeCallback.
mk_TerminalIncreaseFontSizeCallback :: C_TerminalIncreaseFontSizeCallback -> IO (FunPtr C_TerminalIncreaseFontSizeCallback)

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

-- | Connect a signal handler for the “increase-font-size” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #increaseFontSize callback
--   
onTerminalIncreaseFontSize :: (IsTerminal a, MonadIO m) => a -> TerminalIncreaseFontSizeCallback -> m SignalHandlerId

-- | Wrap a TerminalIncreaseFontSizeCallback into a
--   C_TerminalIncreaseFontSizeCallback.
wrap_TerminalIncreaseFontSizeCallback :: TerminalIncreaseFontSizeCallback -> C_TerminalIncreaseFontSizeCallback

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

-- | Emitted at the child application's request.
type TerminalLowerWindowCallback = IO ()

-- | Connect a signal handler for the “lower-window” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #lowerWindow callback
--   
afterTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalLowerWindow :: TerminalLowerWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalLowerWindowCallback.
mk_TerminalLowerWindowCallback :: C_TerminalLowerWindowCallback -> IO (FunPtr C_TerminalLowerWindowCallback)

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

-- | Connect a signal handler for the “lower-window” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #lowerWindow callback
--   
onTerminalLowerWindow :: (IsTerminal a, MonadIO m) => a -> TerminalLowerWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalLowerWindowCallback into a
--   C_TerminalLowerWindowCallback.
wrap_TerminalLowerWindowCallback :: TerminalLowerWindowCallback -> C_TerminalLowerWindowCallback

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

-- | Emitted at the child application's request.
type TerminalMaximizeWindowCallback = IO ()

-- | Connect a signal handler for the “maximize-window” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #maximizeWindow callback
--   
afterTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalMaximizeWindow :: TerminalMaximizeWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalMaximizeWindowCallback.
mk_TerminalMaximizeWindowCallback :: C_TerminalMaximizeWindowCallback -> IO (FunPtr C_TerminalMaximizeWindowCallback)

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

-- | Connect a signal handler for the “maximize-window” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #maximizeWindow callback
--   
onTerminalMaximizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMaximizeWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalMaximizeWindowCallback into a
--   C_TerminalMaximizeWindowCallback.
wrap_TerminalMaximizeWindowCallback :: TerminalMaximizeWindowCallback -> C_TerminalMaximizeWindowCallback

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

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

-- | Connect a signal handler for the “move-window” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #moveWindow callback
--   
afterTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalMoveWindow :: TerminalMoveWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalMoveWindowCallback.
mk_TerminalMoveWindowCallback :: C_TerminalMoveWindowCallback -> IO (FunPtr C_TerminalMoveWindowCallback)

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

-- | Connect a signal handler for the “move-window” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #moveWindow callback
--   
onTerminalMoveWindow :: (IsTerminal a, MonadIO m) => a -> TerminalMoveWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalMoveWindowCallback into a
--   C_TerminalMoveWindowCallback.
wrap_TerminalMoveWindowCallback :: TerminalMoveWindowCallback -> C_TerminalMoveWindowCallback

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

-- | Emitted whenever terminalPasteClipboard is called.
type TerminalPasteClipboardCallback = IO ()

-- | Connect a signal handler for the “paste-clipboard” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #pasteClipboard callback
--   
afterTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalPasteClipboard :: TerminalPasteClipboardCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalPasteClipboardCallback.
mk_TerminalPasteClipboardCallback :: C_TerminalPasteClipboardCallback -> IO (FunPtr C_TerminalPasteClipboardCallback)

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

-- | Connect a signal handler for the “paste-clipboard” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #pasteClipboard callback
--   
onTerminalPasteClipboard :: (IsTerminal a, MonadIO m) => a -> TerminalPasteClipboardCallback -> m SignalHandlerId

-- | Wrap a TerminalPasteClipboardCallback into a
--   C_TerminalPasteClipboardCallback.
wrap_TerminalPasteClipboardCallback :: TerminalPasteClipboardCallback -> C_TerminalPasteClipboardCallback

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

-- | Emitted at the child application's request.
type TerminalRaiseWindowCallback = IO ()

-- | Connect a signal handler for the “raise-window” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #raiseWindow callback
--   
afterTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalRaiseWindow :: TerminalRaiseWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalRaiseWindowCallback.
mk_TerminalRaiseWindowCallback :: C_TerminalRaiseWindowCallback -> IO (FunPtr C_TerminalRaiseWindowCallback)

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

-- | Connect a signal handler for the “raise-window” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #raiseWindow callback
--   
onTerminalRaiseWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRaiseWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalRaiseWindowCallback into a
--   C_TerminalRaiseWindowCallback.
wrap_TerminalRaiseWindowCallback :: TerminalRaiseWindowCallback -> C_TerminalRaiseWindowCallback

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

-- | Emitted at the child application's request.
type TerminalRefreshWindowCallback = IO ()

-- | Connect a signal handler for the “refresh-window” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #refreshWindow callback
--   
afterTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalRefreshWindow :: TerminalRefreshWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalRefreshWindowCallback.
mk_TerminalRefreshWindowCallback :: C_TerminalRefreshWindowCallback -> IO (FunPtr C_TerminalRefreshWindowCallback)

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

-- | Connect a signal handler for the “refresh-window” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #refreshWindow callback
--   
onTerminalRefreshWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRefreshWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalRefreshWindowCallback into a
--   C_TerminalRefreshWindowCallback.
wrap_TerminalRefreshWindowCallback :: TerminalRefreshWindowCallback -> C_TerminalRefreshWindowCallback

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

-- | Emitted at the child application's request.
type TerminalResizeWindowCallback = Word32 " /@width@/: the desired number of columns " -> Word32 " /@height@/: the desired number of rows " -> IO ()

-- | Connect a signal handler for the “resize-window” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #resizeWindow callback
--   
afterTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalResizeWindow :: TerminalResizeWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalResizeWindowCallback.
mk_TerminalResizeWindowCallback :: C_TerminalResizeWindowCallback -> IO (FunPtr C_TerminalResizeWindowCallback)

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

-- | Connect a signal handler for the “resize-window” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #resizeWindow callback
--   
onTerminalResizeWindow :: (IsTerminal a, MonadIO m) => a -> TerminalResizeWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalResizeWindowCallback into a
--   C_TerminalResizeWindowCallback.
wrap_TerminalResizeWindowCallback :: TerminalResizeWindowCallback -> C_TerminalResizeWindowCallback

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

-- | Emitted at the child application's request.
type TerminalRestoreWindowCallback = IO ()

-- | Connect a signal handler for the “restore-window” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #restoreWindow callback
--   
afterTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalRestoreWindow :: TerminalRestoreWindowCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalRestoreWindowCallback.
mk_TerminalRestoreWindowCallback :: C_TerminalRestoreWindowCallback -> IO (FunPtr C_TerminalRestoreWindowCallback)

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

-- | Connect a signal handler for the “restore-window” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #restoreWindow callback
--   
onTerminalRestoreWindow :: (IsTerminal a, MonadIO m) => a -> TerminalRestoreWindowCallback -> m SignalHandlerId

-- | Wrap a TerminalRestoreWindowCallback into a
--   C_TerminalRestoreWindowCallback.
wrap_TerminalRestoreWindowCallback :: TerminalRestoreWindowCallback -> C_TerminalRestoreWindowCallback

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

-- | Emitted whenever the contents of terminal's selection changes.
type TerminalSelectionChangedCallback = IO ()

-- | Connect a signal handler for the “selection-changed” signal,
--   to be run after the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   after terminal #selectionChanged callback
--   
afterTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalSelectionChanged :: TerminalSelectionChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalSelectionChangedCallback.
mk_TerminalSelectionChangedCallback :: C_TerminalSelectionChangedCallback -> IO (FunPtr C_TerminalSelectionChangedCallback)

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

-- | Connect a signal handler for the “selection-changed” signal,
--   to be run before the default handler. When overloading is
--   enabled, this is equivalent to
--   
--   
--   on terminal #selectionChanged callback
--   
onTerminalSelectionChanged :: (IsTerminal a, MonadIO m) => a -> TerminalSelectionChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalSelectionChangedCallback into a
--   C_TerminalSelectionChangedCallback.
wrap_TerminalSelectionChangedCallback :: TerminalSelectionChangedCallback -> C_TerminalSelectionChangedCallback

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

-- | An internal signal used for communication between the terminal and its
--   accessibility peer. May not be emitted under certain circumstances.
type TerminalTextDeletedCallback = IO ()

-- | Connect a signal handler for the “text-deleted” signal, to be
--   run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #textDeleted callback
--   
afterTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalTextDeleted :: TerminalTextDeletedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalTextDeletedCallback.
mk_TerminalTextDeletedCallback :: C_TerminalTextDeletedCallback -> IO (FunPtr C_TerminalTextDeletedCallback)

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

-- | Connect a signal handler for the “text-deleted” signal, to be
--   run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #textDeleted callback
--   
onTerminalTextDeleted :: (IsTerminal a, MonadIO m) => a -> TerminalTextDeletedCallback -> m SignalHandlerId

-- | Wrap a TerminalTextDeletedCallback into a
--   C_TerminalTextDeletedCallback.
wrap_TerminalTextDeletedCallback :: TerminalTextDeletedCallback -> C_TerminalTextDeletedCallback

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

-- | An internal signal used for communication between the terminal and its
--   accessibility peer. May not be emitted under certain circumstances.
type TerminalTextInsertedCallback = IO ()

-- | Connect a signal handler for the “text-inserted” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #textInserted callback
--   
afterTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalTextInserted :: TerminalTextInsertedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalTextInsertedCallback.
mk_TerminalTextInsertedCallback :: C_TerminalTextInsertedCallback -> IO (FunPtr C_TerminalTextInsertedCallback)

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

-- | Connect a signal handler for the “text-inserted” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #textInserted callback
--   
onTerminalTextInserted :: (IsTerminal a, MonadIO m) => a -> TerminalTextInsertedCallback -> m SignalHandlerId

-- | Wrap a TerminalTextInsertedCallback into a
--   C_TerminalTextInsertedCallback.
wrap_TerminalTextInsertedCallback :: TerminalTextInsertedCallback -> C_TerminalTextInsertedCallback

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

-- | An internal signal used for communication between the terminal and its
--   accessibility peer. May not be emitted under certain circumstances.
type TerminalTextModifiedCallback = IO ()

-- | Connect a signal handler for the “text-modified” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #textModified callback
--   
afterTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalTextModified :: TerminalTextModifiedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalTextModifiedCallback.
mk_TerminalTextModifiedCallback :: C_TerminalTextModifiedCallback -> IO (FunPtr C_TerminalTextModifiedCallback)

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

-- | Connect a signal handler for the “text-modified” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #textModified callback
--   
onTerminalTextModified :: (IsTerminal a, MonadIO m) => a -> TerminalTextModifiedCallback -> m SignalHandlerId

-- | Wrap a TerminalTextModifiedCallback into a
--   C_TerminalTextModifiedCallback.
wrap_TerminalTextModifiedCallback :: TerminalTextModifiedCallback -> C_TerminalTextModifiedCallback

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

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

-- | Connect a signal handler for the “text-scrolled” signal, to
--   be run after the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   after terminal #textScrolled callback
--   
afterTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalTextScrolled :: TerminalTextScrolledCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalTextScrolledCallback.
mk_TerminalTextScrolledCallback :: C_TerminalTextScrolledCallback -> IO (FunPtr C_TerminalTextScrolledCallback)

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

-- | Connect a signal handler for the “text-scrolled” signal, to
--   be run before the default handler. When overloading is enabled,
--   this is equivalent to
--   
--   
--   on terminal #textScrolled callback
--   
onTerminalTextScrolled :: (IsTerminal a, MonadIO m) => a -> TerminalTextScrolledCallback -> m SignalHandlerId

-- | Wrap a TerminalTextScrolledCallback into a
--   C_TerminalTextScrolledCallback.
wrap_TerminalTextScrolledCallback :: TerminalTextScrolledCallback -> C_TerminalTextScrolledCallback

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

-- | Emitted when the terminal's window_title field is
--   modified.
type TerminalWindowTitleChangedCallback = IO ()

-- | Connect a signal handler for the “window-title-changed”
--   signal, to be run after the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   after terminal #windowTitleChanged callback
--   
afterTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId

-- | Wrap the callback into a Closure.
genClosure_TerminalWindowTitleChanged :: TerminalWindowTitleChangedCallback -> IO Closure

-- | Generate a function pointer callable from C code, from a
--   C_TerminalWindowTitleChangedCallback.
mk_TerminalWindowTitleChangedCallback :: C_TerminalWindowTitleChangedCallback -> IO (FunPtr C_TerminalWindowTitleChangedCallback)

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

-- | Connect a signal handler for the “window-title-changed”
--   signal, to be run before the default handler. When overloading
--   is enabled, this is equivalent to
--   
--   
--   on terminal #windowTitleChanged callback
--   
onTerminalWindowTitleChanged :: (IsTerminal a, MonadIO m) => a -> TerminalWindowTitleChangedCallback -> m SignalHandlerId

-- | Wrap a TerminalWindowTitleChangedCallback into a
--   C_TerminalWindowTitleChangedCallback.
wrap_TerminalWindowTitleChangedCallback :: TerminalWindowTitleChangedCallback -> C_TerminalWindowTitleChangedCallback
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.Vte.Objects.Terminal.Terminal a) => GI.Vte.Objects.Terminal.IsTerminal a
instance GI.Vte.Objects.Terminal.IsTerminal GI.Vte.Objects.Terminal.Terminal
instance Data.GI.Base.BasicTypes.GObject GI.Vte.Objects.Terminal.Terminal
instance GI.Gtk.Objects.Widget.IsWidget GI.Vte.Objects.Terminal.Terminal
instance GI.GObject.Objects.Object.IsObject GI.Vte.Objects.Terminal.Terminal
instance GI.Atk.Interfaces.ImplementorIface.IsImplementorIface GI.Vte.Objects.Terminal.Terminal
instance GI.Gtk.Interfaces.Buildable.IsBuildable GI.Vte.Objects.Terminal.Terminal
instance GI.Gtk.Interfaces.Scrollable.IsScrollable GI.Vte.Objects.Terminal.Terminal

module GI.Vte.Objects

-- | No description available in the introspection data.
module GI.Vte.Structs.Regex

-- | Memory-managed wrapper type.
newtype Regex
Regex :: ManagedPtr Regex -> Regex

-- | A convenience alias for Nothing :: Maybe Regex.
noRegex :: Maybe Regex

-- | No description available in the introspection data.
regexJit :: (HasCallStack, MonadIO m) => Regex -> Word32 -> m ()

-- | No description available in the introspection data.
regexNewForMatch :: (HasCallStack, MonadIO m) => Text -> Int64 -> Word32 -> m Regex

-- | No description available in the introspection data.
regexNewForSearch :: (HasCallStack, MonadIO m) => Text -> Int64 -> Word32 -> m Regex

-- | No description available in the introspection data.
regexRef :: (HasCallStack, MonadIO m) => Regex -> m Regex

-- | No description available in the introspection data.
regexSubstitute :: (HasCallStack, MonadIO m) => Regex -> Text -> Text -> Word32 -> m Text

-- | No description available in the introspection data.
regexUnref :: (HasCallStack, MonadIO m) => Regex -> m Regex
instance Data.GI.Base.BasicTypes.BoxedObject GI.Vte.Structs.Regex.Regex

module GI.Vte.Structs

module GI.Vte
