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

'GI.WebKit.Interfaces.SpellChecker.SpellChecker' provides APIs for the spell checking
functionality used internally by WebKit to perform spell checking
in editable areas. This can be used, for example, by browsers to
implement custom spell checking context menus or sophisticated
auto-correct features.
-}

module GI.WebKit.Interfaces.SpellChecker
    ( 

-- * Exported types
    SpellChecker(..)                        ,
    noSpellChecker                          ,
    IsSpellChecker                          ,
    toSpellChecker                          ,


 -- * Methods
-- ** checkSpellingOfString #method:checkSpellingOfString#
    SpellCheckerCheckSpellingOfStringMethodInfo,
    spellCheckerCheckSpellingOfString       ,


-- ** getAutocorrectSuggestionsForMisspelledWord #method:getAutocorrectSuggestionsForMisspelledWord#
    SpellCheckerGetAutocorrectSuggestionsForMisspelledWordMethodInfo,
    spellCheckerGetAutocorrectSuggestionsForMisspelledWord,


-- ** getGuessesForWord #method:getGuessesForWord#
    SpellCheckerGetGuessesForWordMethodInfo ,
    spellCheckerGetGuessesForWord           ,


-- ** ignoreWord #method:ignoreWord#
    SpellCheckerIgnoreWordMethodInfo        ,
    spellCheckerIgnoreWord                  ,


-- ** learnWord #method:learnWord#
    SpellCheckerLearnWordMethodInfo         ,
    spellCheckerLearnWord                   ,


-- ** updateSpellCheckingLanguages #method:updateSpellCheckingLanguages#
    SpellCheckerUpdateSpellCheckingLanguagesMethodInfo,
    spellCheckerUpdateSpellCheckingLanguages,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object

-- interface SpellChecker 
newtype SpellChecker = SpellChecker (ManagedPtr SpellChecker)
noSpellChecker :: Maybe SpellChecker
noSpellChecker = Nothing

type instance O.SignalList SpellChecker = SpellCheckerSignalList
type SpellCheckerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

foreign import ccall "webkit_spell_checker_get_type"
    c_webkit_spell_checker_get_type :: IO GType

instance GObject SpellChecker where
    gobjectType _ = c_webkit_spell_checker_get_type
    

class GObject o => IsSpellChecker o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SpellChecker a) =>
    IsSpellChecker a
#endif
instance IsSpellChecker SpellChecker
instance GObject.Object.IsObject SpellChecker

toSpellChecker :: IsSpellChecker o => o -> IO SpellChecker
toSpellChecker = unsafeCastTo SpellChecker

instance O.HasAttributeList SpellChecker
type instance O.AttributeList SpellChecker = SpellCheckerAttributeList
type SpellCheckerAttributeList = ('[ ] :: [(Symbol, *)])

type family ResolveSpellCheckerMethod (t :: Symbol) (o :: *) :: * where
    ResolveSpellCheckerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSpellCheckerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSpellCheckerMethod "checkSpellingOfString" o = SpellCheckerCheckSpellingOfStringMethodInfo
    ResolveSpellCheckerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSpellCheckerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSpellCheckerMethod "ignoreWord" o = SpellCheckerIgnoreWordMethodInfo
    ResolveSpellCheckerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSpellCheckerMethod "learnWord" o = SpellCheckerLearnWordMethodInfo
    ResolveSpellCheckerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSpellCheckerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSpellCheckerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSpellCheckerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSpellCheckerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveSpellCheckerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveSpellCheckerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSpellCheckerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSpellCheckerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSpellCheckerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSpellCheckerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSpellCheckerMethod "updateSpellCheckingLanguages" o = SpellCheckerUpdateSpellCheckingLanguagesMethodInfo
    ResolveSpellCheckerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSpellCheckerMethod "getAutocorrectSuggestionsForMisspelledWord" o = SpellCheckerGetAutocorrectSuggestionsForMisspelledWordMethodInfo
    ResolveSpellCheckerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSpellCheckerMethod "getGuessesForWord" o = SpellCheckerGetGuessesForWordMethodInfo
    ResolveSpellCheckerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSpellCheckerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSpellCheckerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSpellCheckerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSpellCheckerMethod l o = O.MethodResolutionFailed l o

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

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

-- method SpellChecker::check_spelling_of_string
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "checker", argType = TInterface (Name {namespace = "WebKit", name = "SpellChecker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSpellChecker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the string to check for misspellings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "misspelling_location", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an integer to store the location of the first misspelling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "misspelling_length", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an integer to store the length of the first misspelling", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_spell_checker_check_spelling_of_string" webkit_spell_checker_check_spelling_of_string :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- string : TBasicType TUTF8
    Ptr Int32 ->                            -- misspelling_location : TBasicType TInt
    Ptr Int32 ->                            -- misspelling_length : TBasicType TInt
    IO ()

{- |
Checks /@string@/ for misspellings using /@checker@/, storing the
location and length of the first misspelling in
/@misspellingLocation@/ and /@misspellingLength@/ respectively.

@since 1.5.1
-}
spellCheckerCheckSpellingOfString ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> T.Text
    {- ^ /@string@/: the string to check for misspellings -}
    -> m (Int32,Int32)
spellCheckerCheckSpellingOfString checker string = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    string' <- textToCString string
    misspellingLocation <- allocMem :: IO (Ptr Int32)
    misspellingLength <- allocMem :: IO (Ptr Int32)
    webkit_spell_checker_check_spelling_of_string checker' string' misspellingLocation misspellingLength
    misspellingLocation' <- peek misspellingLocation
    misspellingLength' <- peek misspellingLength
    touchManagedPtr checker
    freeMem string'
    freeMem misspellingLocation
    freeMem misspellingLength
    return (misspellingLocation', misspellingLength')

data SpellCheckerCheckSpellingOfStringMethodInfo
instance (signature ~ (T.Text -> m (Int32,Int32)), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerCheckSpellingOfStringMethodInfo a signature where
    overloadedMethod _ = spellCheckerCheckSpellingOfString

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

foreign import ccall "webkit_spell_checker_get_autocorrect_suggestions_for_misspelled_word" webkit_spell_checker_get_autocorrect_suggestions_for_misspelled_word :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- word : TBasicType TUTF8
    IO CString

{- |
Returns a suggestion for a word to use in an \"autocorrect\" feature.

@since 1.5.1
-}
spellCheckerGetAutocorrectSuggestionsForMisspelledWord ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> T.Text
    {- ^ /@word@/: a misspelled word -}
    -> m T.Text
    {- ^ __Returns:__ the suggestion for the autocorrection of
/@word@/ -}
spellCheckerGetAutocorrectSuggestionsForMisspelledWord checker word = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    word' <- textToCString word
    result <- webkit_spell_checker_get_autocorrect_suggestions_for_misspelled_word checker' word'
    checkUnexpectedReturnNULL "spellCheckerGetAutocorrectSuggestionsForMisspelledWord" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr checker
    freeMem word'
    return result'

data SpellCheckerGetAutocorrectSuggestionsForMisspelledWordMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerGetAutocorrectSuggestionsForMisspelledWordMethodInfo a signature where
    overloadedMethod _ = spellCheckerGetAutocorrectSuggestionsForMisspelledWord

-- method SpellChecker::get_guesses_for_word
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "checker", argType = TInterface (Name {namespace = "WebKit", name = "SpellChecker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSpellChecker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "word", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the misspelled word", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the surrounding context of the misspelled word", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_spell_checker_get_guesses_for_word" webkit_spell_checker_get_guesses_for_word :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- word : TBasicType TUTF8
    CString ->                              -- context : TBasicType TUTF8
    IO (Ptr CString)

{- |
Returns a 'Nothing'-terminated array of guesses for corrections of the
misspelled word /@word@/.

@since 1.5.1
-}
spellCheckerGetGuessesForWord ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> T.Text
    {- ^ /@word@/: the misspelled word -}
    -> Maybe (T.Text)
    {- ^ /@context@/: the surrounding context of the misspelled word -}
    -> m [T.Text]
    {- ^ __Returns:__ a newly allocated 'Nothing'-terminated array
of suggested corrections for a misspelled word /@word@/. Free it with
@/g_strfreev/@ when done with it. -}
spellCheckerGetGuessesForWord checker word context = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    word' <- textToCString word
    maybeContext <- case context of
        Nothing -> return nullPtr
        Just jContext -> do
            jContext' <- textToCString jContext
            return jContext'
    result <- webkit_spell_checker_get_guesses_for_word checker' word' maybeContext
    checkUnexpectedReturnNULL "spellCheckerGetGuessesForWord" result
    result' <- unpackZeroTerminatedUTF8CArray result
    mapZeroTerminatedCArray freeMem result
    freeMem result
    touchManagedPtr checker
    freeMem word'
    freeMem maybeContext
    return result'

data SpellCheckerGetGuessesForWordMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m [T.Text]), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerGetGuessesForWordMethodInfo a signature where
    overloadedMethod _ = spellCheckerGetGuessesForWord

-- method SpellChecker::ignore_word
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "checker", argType = TInterface (Name {namespace = "WebKit", name = "SpellChecker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSpellChecker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "word", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the word to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_spell_checker_ignore_word" webkit_spell_checker_ignore_word :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- word : TBasicType TUTF8
    IO ()

{- |
Instructs the /@checker@/ to ignore /@word@/ as a misspelling for this
session.

@since 1.5.1
-}
spellCheckerIgnoreWord ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> T.Text
    {- ^ /@word@/: the word to ignore -}
    -> m ()
spellCheckerIgnoreWord checker word = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    word' <- textToCString word
    webkit_spell_checker_ignore_word checker' word'
    touchManagedPtr checker
    freeMem word'
    return ()

data SpellCheckerIgnoreWordMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerIgnoreWordMethodInfo a signature where
    overloadedMethod _ = spellCheckerIgnoreWord

-- method SpellChecker::learn_word
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "checker", argType = TInterface (Name {namespace = "WebKit", name = "SpellChecker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSpellChecker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "word", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the word to learn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_spell_checker_learn_word" webkit_spell_checker_learn_word :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- word : TBasicType TUTF8
    IO ()

{- |
Instructs the /@checker@/ to add /@word@/ to its dictionary as a properly
spelled word. The word will be learned permanently in the user\'s
personal dictionary.

@since 1.5.1
-}
spellCheckerLearnWord ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> T.Text
    {- ^ /@word@/: the word to learn -}
    -> m ()
spellCheckerLearnWord checker word = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    word' <- textToCString word
    webkit_spell_checker_learn_word checker' word'
    touchManagedPtr checker
    freeMem word'
    return ()

data SpellCheckerLearnWordMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerLearnWordMethodInfo a signature where
    overloadedMethod _ = spellCheckerLearnWord

-- method SpellChecker::update_spell_checking_languages
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "checker", argType = TInterface (Name {namespace = "WebKit", name = "SpellChecker"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitSpellChecker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "languages", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a string of languages to use for @checker", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_spell_checker_update_spell_checking_languages" webkit_spell_checker_update_spell_checking_languages :: 
    Ptr SpellChecker ->                     -- checker : TInterface (Name {namespace = "WebKit", name = "SpellChecker"})
    CString ->                              -- languages : TBasicType TUTF8
    IO ()

{- |
Sets /@languages@/ as the list of languages to use by /@checker@/. The
accepted format is a list of comma (\',\') separated language codes
of the form \'en_US\', ie, language_VARIANT.

@since 1.5.1
-}
spellCheckerUpdateSpellCheckingLanguages ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpellChecker a) =>
    a
    {- ^ /@checker@/: a 'GI.WebKit.Interfaces.SpellChecker.SpellChecker' -}
    -> Maybe (T.Text)
    {- ^ /@languages@/: a string of languages to use for /@checker@/ -}
    -> m ()
spellCheckerUpdateSpellCheckingLanguages checker languages = liftIO $ do
    checker' <- unsafeManagedPtrCastPtr checker
    maybeLanguages <- case languages of
        Nothing -> return nullPtr
        Just jLanguages -> do
            jLanguages' <- textToCString jLanguages
            return jLanguages'
    webkit_spell_checker_update_spell_checking_languages checker' maybeLanguages
    touchManagedPtr checker
    freeMem maybeLanguages
    return ()

data SpellCheckerUpdateSpellCheckingLanguagesMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsSpellChecker a) => O.MethodInfo SpellCheckerUpdateSpellCheckingLanguagesMethodInfo a signature where
    overloadedMethod _ = spellCheckerUpdateSpellCheckingLanguages