    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- /No description available in the introspection data./

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Vte.Structs.Regex
        (

    -- * Exported types
        Regex(..)                               ,

     -- * Methods
    -- |
    --
    --  === __Click to display all available methods, including inherited ones__
    -- ==== Methods
    -- [jit]("GI.Vte.Structs.Regex#g:method:jit"), [ref]("GI.Vte.Structs.Regex#g:method:ref"), [substitute]("GI.Vte.Structs.Regex#g:method:substitute"), [unref]("GI.Vte.Structs.Regex#g:method:unref").
    --
    -- ==== Getters
    -- /None/.
    --
    -- ==== Setters
    -- /None/.

    #if defined(ENABLE_OVERLOADING)
        ResolveRegexMethod                      ,
    #endif

    -- ** jit #method:jit#

    #if defined(ENABLE_OVERLOADING)
        RegexJitMethodInfo                      ,
    #endif
        regexJit                                ,

    -- ** newForMatch #method:newForMatch#

        regexNewForMatch                        ,

    -- ** newForMatchFull #method:newForMatchFull#

        regexNewForMatchFull                    ,

    -- ** newForSearch #method:newForSearch#

        regexNewForSearch                       ,

    -- ** newForSearchFull #method:newForSearchFull#

        regexNewForSearchFull                   ,

    -- ** ref #method:ref#

    #if defined(ENABLE_OVERLOADING)
        RegexRefMethodInfo                      ,
    #endif
        regexRef                                ,

    -- ** substitute #method:substitute#

    #if defined(ENABLE_OVERLOADING)
        RegexSubstituteMethodInfo               ,
    #endif
        regexSubstitute                         ,

    -- ** unref #method:unref#

    #if defined(ENABLE_OVERLOADING)
        RegexUnrefMethodInfo                    ,
    #endif
        regexUnref                              ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- | Memory-managed wrapper type.
    newtype Regex = Regex (SP.ManagedPtr Regex)
        deriving (Regex -> Regex -> Bool
    (Regex -> Regex -> Bool) -> (Regex -> Regex -> Bool) -> Eq Regex
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Regex -> Regex -> Bool
    == :: Regex -> Regex -> Bool
    $c/= :: Regex -> Regex -> Bool
    /= :: Regex -> Regex -> Bool
    Eq)

    instance SP.ManagedPtrNewtype Regex where
        toManagedPtr :: Regex -> ManagedPtr Regex
    toManagedPtr (Regex ManagedPtr Regex
    p) = ManagedPtr Regex
    p

    foreign import ccall "vte_regex_get_type" c_vte_regex_get_type ::
        IO GType

    type instance O.ParentTypes Regex = '[]
    instance O.HasParentTypes Regex

    instance B.Types.TypedObject Regex where
        glibType :: IO GType
    glibType = IO GType
    c_vte_regex_get_type

    instance B.Types.GBoxed Regex

    -- | Convert t'Regex' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe Regex) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_vte_regex_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Regex -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Regex
    P.Nothing = Ptr GValue -> Ptr Regex -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr Regex
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Regex)
        gvalueSet_ Ptr GValue
    gv (P.Just Regex
    obj) = Regex -> (Ptr Regex -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Regex
    obj (Ptr GValue -> Ptr Regex -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Regex)
    gvalueGet_ Ptr GValue
    gv = do
            ptr <- Ptr GValue -> IO (Ptr Regex)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr Regex)
            if ptr /= FP.nullPtr
            then P.Just <$> B.ManagedPtr.newBoxed Regex ptr
            else return P.Nothing

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Regex
    type instance O.AttributeList Regex = RegexAttributeList
    type RegexAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

    -- method Regex::new_for_match
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "pattern"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a regex pattern string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pattern_length"
    --           , argType = TBasicType TSSize
    --           , argCType = Just "gssize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the length of @pattern in bytes, or -1 if the\n string is NUL-terminated and the length is unknown"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "guint32"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 compile flags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Regex" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "vte_regex_new_for_match" vte_regex_new_for_match ::
        CString ->                              -- pattern : TBasicType TUTF8
        DI.Int64 ->                             -- pattern_length : TBasicType TSSize
        Word32 ->                               -- flags : TBasicType TUInt32
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Regex)

    -- | Compiles /@pattern@/ into a regex for use as a match regex
    -- with 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' or
    -- @/vte_terminal_event_check_regex_simple()/@.
    --
    -- See man:pcre2pattern(3) for information
    -- about the supported regex language, and man:pcre2api(3) for
    -- information about the supported /@flags@/.
    --
    -- The regex will be compiled using \<literal>PCRE2_UTF\<\/literal> and
    -- possibly other flags, in addition to the flags supplied in /@flags@/.
    regexNewForMatch ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@pattern@/: a regex pattern string
        -> DI.Int64
        -- ^ /@patternLength@/: the length of /@pattern@/ in bytes, or -1 if the
        --  string is NUL-terminated and the length is unknown
        -> Word32
        -- ^ /@flags@/: PCRE2 compile flags
        -> m Regex
        -- ^ __Returns:__ a newly created t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing' with /@error@/ filled in /(Can throw 'Data.GI.Base.GError.GError')/
    regexNewForMatch :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> Word32 -> m Regex
    regexNewForMatch Text
    pattern Int64
    patternLength Word32
    flags = IO Regex -> m Regex
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
    forall a b. (a -> b) -> a -> b
    $ do
        pattern' <- Text -> IO CString
    textToCString Text
    pattern
        onException (do
            result <- propagateGError $ vte_regex_new_for_match pattern' patternLength flags
            checkUnexpectedReturnNULL "regexNewForMatch" result
            result' <- (wrapBoxed Regex) result
            freeMem pattern'
            return result'
         ) (do
            freeMem pattern'
         )

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Regex::new_for_match_full
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "pattern"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a regex pattern string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pattern_length"
    --           , argType = TBasicType TSSize
    --           , argCType = Just "gssize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the length of @pattern in bytes, or -1 if the\n string is NUL-terminated and the length is unknown"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "uint32_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 compile flags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "extra_flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "uint32_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 extra compile flags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "error_offset"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location to store the error offset"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Regex" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "vte_regex_new_for_match_full" vte_regex_new_for_match_full ::
        CString ->                              -- pattern : TBasicType TUTF8
        DI.Int64 ->                             -- pattern_length : TBasicType TSSize
        Word32 ->                               -- flags : TBasicType TUInt32
        Word32 ->                               -- extra_flags : TBasicType TUInt32
        Ptr FCT.CSize ->                        -- error_offset : TBasicType TSize
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Regex)

    -- | Compiles /@pattern@/ into a regex for use as a match regex
    -- with 'GI.Vte.Objects.Terminal.terminalMatchAddRegex' or
    -- @/vte_terminal_event_check_regex_simple()/@.
    --
    -- See man:pcre2pattern(3) for information
    -- about the supported regex language, and man:pcre2api(3) for
    -- information about the supported /@flags@/ and /@extraFlags@/.
    --
    -- The regex will be compiled using \<literal>PCRE2_UTF\<\/literal> and
    -- possibly other flags, in addition to the flags supplied in /@flags@/.
    --
    -- If regex compilation fails, /@error@/ will be set and /@errorOffset@/ point
    -- to error as an offset into /@pattern@/.
    --
    -- /Since: 0.76/
    regexNewForMatchFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@pattern@/: a regex pattern string
        -> DI.Int64
        -- ^ /@patternLength@/: the length of /@pattern@/ in bytes, or -1 if the
        --  string is NUL-terminated and the length is unknown
        -> Word32
        -- ^ /@flags@/: PCRE2 compile flags
        -> Word32
        -- ^ /@extraFlags@/: PCRE2 extra compile flags
        -> m ((Regex, FCT.CSize))
        -- ^ __Returns:__ a newly created t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing' /(Can throw 'Data.GI.Base.GError.GError')/
    regexNewForMatchFull :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> Word32 -> Word32 -> m (Regex, CSize)
    regexNewForMatchFull Text
    pattern Int64
    patternLength Word32
    flags Word32
    extraFlags = IO (Regex, CSize) -> m (Regex, CSize)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Regex, CSize) -> m (Regex, CSize))
    -> IO (Regex, CSize) -> m (Regex, CSize)
    forall a b. (a -> b) -> a -> b
    $ do
        pattern' <- Text -> IO CString
    textToCString Text
    pattern
        errorOffset <- allocMem :: IO (Ptr FCT.CSize)
        onException (do
            result <- propagateGError $ vte_regex_new_for_match_full pattern' patternLength flags extraFlags errorOffset
            checkUnexpectedReturnNULL "regexNewForMatchFull" result
            result' <- (wrapBoxed Regex) result
            errorOffset' <- peek errorOffset
            freeMem pattern'
            freeMem errorOffset
            return (result', errorOffset')
         ) (do
            freeMem pattern'
            freeMem errorOffset
         )

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Regex::new_for_search
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "pattern"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a regex pattern string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pattern_length"
    --           , argType = TBasicType TSSize
    --           , argCType = Just "gssize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the length of @pattern in bytes, or -1 if the\n string is NUL-terminated and the length is unknown"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "guint32"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 compile flags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Regex" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "vte_regex_new_for_search" vte_regex_new_for_search ::
        CString ->                              -- pattern : TBasicType TUTF8
        DI.Int64 ->                             -- pattern_length : TBasicType TSSize
        Word32 ->                               -- flags : TBasicType TUInt32
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Regex)

    -- | Compiles /@pattern@/ into a regex for use as a search regex
    -- with 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
    --
    -- See man:pcre2pattern(3) for information
    -- about the supported regex language, and man:pcre2api(3) for
    -- information about the supported /@flags@/.
    --
    -- The regex will be compiled using \<literal>PCRE2_UTF\<\/literal> and
    -- possibly other flags, in addition to the flags supplied in /@flags@/.
    regexNewForSearch ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@pattern@/: a regex pattern string
        -> DI.Int64
        -- ^ /@patternLength@/: the length of /@pattern@/ in bytes, or -1 if the
        --  string is NUL-terminated and the length is unknown
        -> Word32
        -- ^ /@flags@/: PCRE2 compile flags
        -> m Regex
        -- ^ __Returns:__ a newly created t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing' with /@error@/ filled in /(Can throw 'Data.GI.Base.GError.GError')/
    regexNewForSearch :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> Word32 -> m Regex
    regexNewForSearch Text
    pattern Int64
    patternLength Word32
    flags = IO Regex -> m Regex
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
    forall a b. (a -> b) -> a -> b
    $ do
        pattern' <- Text -> IO CString
    textToCString Text
    pattern
        onException (do
            result <- propagateGError $ vte_regex_new_for_search pattern' patternLength flags
            checkUnexpectedReturnNULL "regexNewForSearch" result
            result' <- (wrapBoxed Regex) result
            freeMem pattern'
            return result'
         ) (do
            freeMem pattern'
         )

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Regex::new_for_search_full
    -- method type : Constructor
    -- Args: [ Arg
    --           { argCName = "pattern"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a regex pattern string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "pattern_length"
    --           , argType = TBasicType TSSize
    --           , argCType = Just "gssize"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "the length of @pattern in bytes, or -1 if the\n string is NUL-terminated and the length is unknown"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "uint32_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 compile flags"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "extra_flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "uint32_t"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "error_offset"
    --           , argType = TBasicType TSize
    --           , argCType = Just "gsize*"
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "return location to store the error offset"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Vte" , name = "Regex" })
    -- throws : True
    -- Skip return : False

    foreign import ccall "vte_regex_new_for_search_full" vte_regex_new_for_search_full ::
        CString ->                              -- pattern : TBasicType TUTF8
        DI.Int64 ->                             -- pattern_length : TBasicType TSSize
        Word32 ->                               -- flags : TBasicType TUInt32
        Word32 ->                               -- extra_flags : TBasicType TUInt32
        Ptr FCT.CSize ->                        -- error_offset : TBasicType TSize
        Ptr (Ptr GError) ->                     -- error
        IO (Ptr Regex)

    -- | Compiles /@pattern@/ into a regex for use as a search regex
    -- with 'GI.Vte.Objects.Terminal.terminalSearchSetRegex'.
    --
    -- See man:pcre2pattern(3) for information
    -- about the supported regex language, and man:pcre2api(3) for
    -- information about the supported /@flags@/ and /@extraFlags@/.
    --
    -- The regex will be compiled using \<literal>PCRE2_UTF\<\/literal> and
    -- possibly other flags, in addition to the flags supplied in /@flags@/.
    --
    -- If regex compilation fails, /@error@/ will be set and /@errorOffset@/ point
    -- to error as an offset into /@pattern@/.
    --
    -- /Since: 0.76/
    regexNewForSearchFull ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        -- ^ /@pattern@/: a regex pattern string
        -> DI.Int64
        -- ^ /@patternLength@/: the length of /@pattern@/ in bytes, or -1 if the
        --  string is NUL-terminated and the length is unknown
        -> Word32
        -- ^ /@flags@/: PCRE2 compile flags
        -> Word32
        -> m ((Regex, FCT.CSize))
        -- ^ __Returns:__ a newly created t'GI.Vte.Structs.Regex.Regex', or 'P.Nothing' /(Can throw 'Data.GI.Base.GError.GError')/
    regexNewForSearchFull :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Text -> Int64 -> Word32 -> Word32 -> m (Regex, CSize)
    regexNewForSearchFull Text
    pattern Int64
    patternLength Word32
    flags Word32
    extraFlags = IO (Regex, CSize) -> m (Regex, CSize)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Regex, CSize) -> m (Regex, CSize))
    -> IO (Regex, CSize) -> m (Regex, CSize)
    forall a b. (a -> b) -> a -> b
    $ do
        pattern' <- Text -> IO CString
    textToCString Text
    pattern
        errorOffset <- allocMem :: IO (Ptr FCT.CSize)
        onException (do
            result <- propagateGError $ vte_regex_new_for_search_full pattern' patternLength flags extraFlags errorOffset
            checkUnexpectedReturnNULL "regexNewForSearchFull" result
            result' <- (wrapBoxed Regex) result
            errorOffset' <- peek errorOffset
            freeMem pattern'
            freeMem errorOffset
            return (result', errorOffset')
         ) (do
            freeMem pattern'
            freeMem errorOffset
         )

    #if defined(ENABLE_OVERLOADING)
    #endif

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

    foreign import ccall "vte_regex_jit" vte_regex_jit ::
        Ptr Regex ->                            -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
        Word32 ->                               -- flags : TBasicType TUInt32
        Ptr (Ptr GError) ->                     -- error
        IO CInt

    -- | If the platform supports JITing, JIT compiles /@regex@/.
    regexJit ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Regex
        -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
        -> Word32
        -- ^ /@flags@/: PCRE2 JIT flags, or 0
        -> m ()
        -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
    regexJit :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Regex -> Word32 -> m ()
    regexJit Regex
    regex Word32
    flags = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        regex' <- Regex -> IO (Ptr Regex)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Regex
    regex
        onException (do
            _ <- propagateGError $ vte_regex_jit regex' flags
            touchManagedPtr regex
            return ()
         ) (do
            return ()
         )

    #if defined(ENABLE_OVERLOADING)
    data RegexJitMethodInfo
    instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod RegexJitMethodInfo Regex signature where
        overloadedMethod = regexJit

    instance O.OverloadedMethodInfo RegexJitMethodInfo Regex where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Regex.regexJit",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.35/docs/GI-Vte-Structs-Regex.html#v:regexJit"
            })

    #endif

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

    foreign import ccall "vte_regex_ref" vte_regex_ref ::
        Ptr Regex ->                            -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
        IO (Ptr Regex)

    -- | Increases the reference count of /@regex@/ by one.
    regexRef ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Regex
        -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
        -> m Regex
        -- ^ __Returns:__ /@regex@/
    regexRef :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Regex -> m Regex
    regexRef Regex
    regex = IO Regex -> m Regex
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
    forall a b. (a -> b) -> a -> b
    $ do
        regex' <- Regex -> IO (Ptr Regex)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Regex
    regex
        result <- vte_regex_ref regex'
        checkUnexpectedReturnNULL "regexRef" result
        result' <- (wrapBoxed Regex) result
        touchManagedPtr regex
        return result'

    #if defined(ENABLE_OVERLOADING)
    data RegexRefMethodInfo
    instance (signature ~ (m Regex), MonadIO m) => O.OverloadedMethod RegexRefMethodInfo Regex signature where
        overloadedMethod = regexRef

    instance O.OverloadedMethodInfo RegexRefMethodInfo Regex where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Regex.regexRef",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.35/docs/GI-Vte-Structs-Regex.html#v:regexRef"
            })

    #endif

    -- method Regex::substitute
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "regex"
    --           , argType = TInterface Name { namespace = "Vte" , name = "Regex" }
    --           , argCType = Just "VteRegex*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #VteRegex" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "subject"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the subject string" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "replacement"
    --           , argType = TBasicType TUTF8
    --           , argCType = Just "const char*"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the replacement string"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "flags"
    --           , argType = TBasicType TUInt32
    --           , argCType = Just "guint32"
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "PCRE2 match flags" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUTF8)
    -- throws : True
    -- Skip return : False

    foreign import ccall "vte_regex_substitute" vte_regex_substitute ::
        Ptr Regex ->                            -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
        CString ->                              -- subject : TBasicType TUTF8
        CString ->                              -- replacement : TBasicType TUTF8
        Word32 ->                               -- flags : TBasicType TUInt32
        Ptr (Ptr GError) ->                     -- error
        IO CString

    -- | See man:pcre2api(3) and man:pcre2_substitute(3) for more information.
    --
    -- /Since: 0.56/
    regexSubstitute ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Regex
        -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
        -> T.Text
        -- ^ /@subject@/: the subject string
        -> T.Text
        -- ^ /@replacement@/: the replacement string
        -> Word32
        -- ^ /@flags@/: PCRE2 match flags
        -> m T.Text
        -- ^ __Returns:__ the substituted string, or 'P.Nothing'
        --   if an error occurred /(Can throw 'Data.GI.Base.GError.GError')/
    regexSubstitute :: forall (m :: * -> *).
    (HasCallStack, MonadIO m) =>
    Regex -> Text -> Text -> Word32 -> m Text
    regexSubstitute Regex
    regex Text
    subject Text
    replacement Word32
    flags = IO Text -> m Text
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Text -> m Text) -> IO Text -> m Text
    forall a b. (a -> b) -> a -> b
    $ do
        regex' <- Regex -> IO (Ptr Regex)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Regex
    regex
        subject' <- textToCString subject
        replacement' <- textToCString replacement
        onException (do
            result <- propagateGError $ vte_regex_substitute regex' subject' replacement' flags
            checkUnexpectedReturnNULL "regexSubstitute" result
            result' <- cstringToText result
            freeMem result
            touchManagedPtr regex
            freeMem subject'
            freeMem replacement'
            return result'
         ) (do
            freeMem subject'
            freeMem replacement'
         )

    #if defined(ENABLE_OVERLOADING)
    data RegexSubstituteMethodInfo
    instance (signature ~ (T.Text -> T.Text -> Word32 -> m T.Text), MonadIO m) => O.OverloadedMethod RegexSubstituteMethodInfo Regex signature where
        overloadedMethod = regexSubstitute

    instance O.OverloadedMethodInfo RegexSubstituteMethodInfo Regex where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Regex.regexSubstitute",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.35/docs/GI-Vte-Structs-Regex.html#v:regexSubstitute"
            })

    #endif

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

    foreign import ccall "vte_regex_unref" vte_regex_unref ::
        Ptr Regex ->                            -- regex : TInterface (Name {namespace = "Vte", name = "Regex"})
        IO (Ptr Regex)

    -- | Decreases the reference count of /@regex@/ by one, and frees /@regex@/
    -- if the refcount reaches zero.
    regexUnref ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        Regex
        -- ^ /@regex@/: a t'GI.Vte.Structs.Regex.Regex'
        -> m Regex
        -- ^ __Returns:__ 'P.Nothing'
    regexUnref :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Regex -> m Regex
    regexUnref Regex
    regex = IO Regex -> m Regex
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Regex -> m Regex) -> IO Regex -> m Regex
    forall a b. (a -> b) -> a -> b
    $ do
        regex' <- Regex -> IO (Ptr Regex)
    forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
    B.ManagedPtr.disownBoxed Regex
    regex
        result <- vte_regex_unref regex'
        checkUnexpectedReturnNULL "regexUnref" result
        result' <- (wrapBoxed Regex) result
        touchManagedPtr regex
        return result'

    #if defined(ENABLE_OVERLOADING)
    data RegexUnrefMethodInfo
    instance (signature ~ (m Regex), MonadIO m) => O.OverloadedMethod RegexUnrefMethodInfo Regex signature where
        overloadedMethod = regexUnref

    instance O.OverloadedMethodInfo RegexUnrefMethodInfo Regex where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Vte.Structs.Regex.regexUnref",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vte-2.91.35/docs/GI-Vte-Structs-Regex.html#v:regexUnref"
            })

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveRegexMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveRegexMethod "jit" o = RegexJitMethodInfo
        ResolveRegexMethod "ref" o = RegexRefMethodInfo
        ResolveRegexMethod "substitute" o = RegexSubstituteMethodInfo
        ResolveRegexMethod "unref" o = RegexUnrefMethodInfo
        ResolveRegexMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveRegexMethod t Regex, O.OverloadedMethod info Regex p) => OL.IsLabel t (Regex -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod @info
    #else
        fromLabel _ = O.overloadedMethod @info
    #endif

    #if MIN_VERSION_base(4,13,0)
    instance (info ~ ResolveRegexMethod t Regex, O.OverloadedMethod info Regex p, R.HasField t Regex p) => R.HasField t Regex p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveRegexMethod t Regex, O.OverloadedMethodInfo info Regex) => OL.IsLabel t (O.MethodProxy info Regex) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif