module Godot.Api.Auto where
import Data.Coerce
import Foreign.C
import Godot.Internal.Dispatch
import System.IO.Unsafe
import Godot.Gdnative.Internal
import Godot.Gdnative.Types

newtype GodotGlobalConstants = GodotGlobalConstants GodotObject
                                 deriving newtype AsVariant
bindObject_free
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "free" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_free #-}

instance Method "free" GodotObject (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_free (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject__notification
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "_notification" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject__notification #-}

instance Method "_notification" GodotObject (Int -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject__notification (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject__set
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "_set" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject__set #-}

instance Method "_set" GodotObject
           (GodotString -> GodotVariant -> IO Bool)
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject__set (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject__get
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "_get" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject__get #-}

instance Method "_get" GodotObject (GodotString -> IO GodotVariant)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject__get (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject__get_property_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "_get_property_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject__get_property_list #-}

instance Method "_get_property_list" GodotObject (IO GodotArray)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject__get_property_list (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject__init
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "_init" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject__init #-}

instance Method "_init" GodotObject (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject__init (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_class
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_class" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_class #-}

instance Method "get_class" GodotObject (IO GodotString) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_class (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_is_class
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "is_class" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_is_class #-}

instance Method "is_class" GodotObject (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_is_class (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set #-}

instance Method "set" GodotObject
           (GodotString -> GodotVariant -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get #-}

instance Method "get" GodotObject (GodotString -> IO GodotVariant)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set_indexed
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set_indexed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set_indexed #-}

instance Method "set_indexed" GodotObject
           (GodotNodePath -> GodotVariant -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set_indexed (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_indexed
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_indexed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_indexed #-}

instance Method "get_indexed" GodotObject
           (GodotNodePath -> IO GodotVariant)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_indexed (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_property_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_property_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_property_list #-}

instance Method "get_property_list" GodotObject (IO GodotArray)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_property_list (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_method_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_method_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_method_list #-}

instance Method "get_method_list" GodotObject (IO GodotArray) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_method_list (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_notification
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "notification" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_notification #-}

instance Method "notification" GodotObject (Int -> Bool -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_notification (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_instance_id
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_instance_id" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_instance_id #-}

instance Method "get_instance_id" GodotObject (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_instance_id (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set_script
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set_script" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set_script #-}

instance Method "set_script" GodotObject (GodotReference -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set_script (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_script
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_script" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_script #-}

instance Method "get_script" GodotObject (IO GodotReference) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_script (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set_meta
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set_meta" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set_meta #-}

instance Method "set_meta" GodotObject
           (GodotString -> GodotVariant -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set_meta (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_meta
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_meta" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_meta #-}

instance Method "get_meta" GodotObject
           (GodotString -> IO GodotVariant)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_meta (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_has_meta
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "has_meta" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_has_meta #-}

instance Method "has_meta" GodotObject (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_has_meta (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_meta_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_meta_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_meta_list #-}

instance Method "get_meta_list" GodotObject
           (IO GodotPoolStringArray)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_meta_list (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_add_user_signal
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "add_user_signal" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_add_user_signal #-}

instance Method "add_user_signal" GodotObject
           (GodotString -> GodotArray -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_add_user_signal (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_has_user_signal
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "has_user_signal" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_has_user_signal #-}

instance Method "has_user_signal" GodotObject
           (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_has_user_signal (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_callv
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "callv" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_callv #-}

instance Method "callv" GodotObject
           (GodotString -> GodotArray -> IO GodotVariant)
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_callv (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_has_method
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "has_method" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_has_method #-}

instance Method "has_method" GodotObject (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_has_method (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_signal_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_signal_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_signal_list #-}

instance Method "get_signal_list" GodotObject (IO GodotArray) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_signal_list (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_signal_connection_list
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_signal_connection_list" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_signal_connection_list #-}

instance Method "get_signal_connection_list" GodotObject
           (GodotString -> IO GodotArray)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_signal_connection_list
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_get_incoming_connections
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "get_incoming_connections" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_get_incoming_connections #-}

instance Method "get_incoming_connections" GodotObject
           (IO GodotArray)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_get_incoming_connections
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_connect
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "connect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_connect #-}

instance Method "connect" GodotObject
           (GodotString ->
              GodotObject -> GodotString -> GodotArray -> Int -> IO Int)
         where
        runMethod cls arg1 arg2 arg3 arg4 arg5
          = withVariantArray
              [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4,
               toVariant arg5]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_connect (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_disconnect
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "disconnect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_disconnect #-}

instance Method "disconnect" GodotObject
           (GodotString -> GodotObject -> GodotString -> IO ())
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_disconnect (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_is_connected
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "is_connected" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_is_connected #-}

instance Method "is_connected" GodotObject
           (GodotString -> GodotObject -> GodotString -> IO Bool)
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_is_connected (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set_block_signals
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set_block_signals" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set_block_signals #-}

instance Method "set_block_signals" GodotObject (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set_block_signals (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_is_blocking_signals
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "is_blocking_signals" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_is_blocking_signals #-}

instance Method "is_blocking_signals" GodotObject (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_is_blocking_signals (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_property_list_changed_notify
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "property_list_changed_notify" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_property_list_changed_notify #-}

instance Method "property_list_changed_notify" GodotObject (IO ())
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_property_list_changed_notify
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_set_message_translation
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "set_message_translation" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_set_message_translation #-}

instance Method "set_message_translation" GodotObject
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_set_message_translation
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_can_translate_messages
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "can_translate_messages" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_can_translate_messages #-}

instance Method "can_translate_messages" GodotObject (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_can_translate_messages
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_tr
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "tr" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_tr #-}

instance Method "tr" GodotObject (GodotString -> IO GodotString)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_tr (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindObject_is_queued_for_deletion
  = unsafePerformIO $
      withCString "Object" $
        \ clsNamePtr ->
          withCString "is_queued_for_deletion" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindObject_is_queued_for_deletion #-}

instance Method "is_queued_for_deletion" GodotObject (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindObject_is_queued_for_deletion
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotReference = GodotReference GodotObject
                           deriving newtype AsVariant

instance HasBaseClass GodotReference where
        type BaseClass GodotReference = GodotObject
        super = coerce
bindReference_init_ref
  = unsafePerformIO $
      withCString "Reference" $
        \ clsNamePtr ->
          withCString "init_ref" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindReference_init_ref #-}

instance Method "init_ref" GodotReference (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindReference_init_ref (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindReference_reference
  = unsafePerformIO $
      withCString "Reference" $
        \ clsNamePtr ->
          withCString "reference" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindReference_reference #-}

instance Method "reference" GodotReference (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindReference_reference (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindReference_unreference
  = unsafePerformIO $
      withCString "Reference" $
        \ clsNamePtr ->
          withCString "unreference" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindReference_unreference #-}

instance Method "unreference" GodotReference (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindReference_unreference (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotResource = GodotResource GodotObject
                          deriving newtype AsVariant

instance HasBaseClass GodotResource where
        type BaseClass GodotResource = GodotReference
        super = coerce
bindResource__setup_local_to_scene
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "_setup_local_to_scene" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource__setup_local_to_scene #-}

instance Method "_setup_local_to_scene" GodotResource (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource__setup_local_to_scene
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_set_path
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "set_path" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_set_path #-}

instance Method "set_path" GodotResource (GodotString -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_set_path (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_take_over_path
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "take_over_path" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_take_over_path #-}

instance Method "take_over_path" GodotResource
           (GodotString -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_take_over_path (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_get_path
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "get_path" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_get_path #-}

instance Method "get_path" GodotResource (IO GodotString) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_get_path (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_set_name
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "set_name" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_set_name #-}

instance Method "set_name" GodotResource (GodotString -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_set_name (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_get_name
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "get_name" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_get_name #-}

instance Method "get_name" GodotResource (IO GodotString) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_get_name (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_get_rid
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "get_rid" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_get_rid #-}

instance Method "get_rid" GodotResource (IO GodotRid) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_get_rid (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_set_local_to_scene
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "set_local_to_scene" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_set_local_to_scene #-}

instance Method "set_local_to_scene" GodotResource (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_set_local_to_scene (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_is_local_to_scene
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "is_local_to_scene" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_is_local_to_scene #-}

instance Method "is_local_to_scene" GodotResource (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_is_local_to_scene (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_get_local_scene
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "get_local_scene" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_get_local_scene #-}

instance Method "get_local_scene" GodotResource (IO GodotNode)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_get_local_scene (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_setup_local_to_scene
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "setup_local_to_scene" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_setup_local_to_scene #-}

instance Method "setup_local_to_scene" GodotResource (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_setup_local_to_scene
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindResource_duplicate
  = unsafePerformIO $
      withCString "Resource" $
        \ clsNamePtr ->
          withCString "duplicate" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindResource_duplicate #-}

instance Method "duplicate" GodotResource
           (Bool -> IO GodotResource)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindResource_duplicate (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotScript = GodotScript GodotObject
                        deriving newtype AsVariant

instance HasBaseClass GodotScript where
        type BaseClass GodotScript = GodotResource
        super = coerce
bindScript_can_instance
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "can_instance" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_can_instance #-}

instance Method "can_instance" GodotScript (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_can_instance (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_instance_has
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "instance_has" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_instance_has #-}

instance Method "instance_has" GodotScript (GodotObject -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_instance_has (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_has_source_code
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "has_source_code" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_has_source_code #-}

instance Method "has_source_code" GodotScript (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_has_source_code (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_get_source_code
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "get_source_code" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_get_source_code #-}

instance Method "get_source_code" GodotScript (IO GodotString)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_get_source_code (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_set_source_code
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "set_source_code" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_set_source_code #-}

instance Method "set_source_code" GodotScript
           (GodotString -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_set_source_code (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_reload
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "reload" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_reload #-}

instance Method "reload" GodotScript (Bool -> IO Int) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_reload (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_get_base_script
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "get_base_script" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_get_base_script #-}

instance Method "get_base_script" GodotScript (IO GodotScript)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_get_base_script (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_get_instance_base_type
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "get_instance_base_type" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_get_instance_base_type #-}

instance Method "get_instance_base_type" GodotScript
           (IO GodotString)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_get_instance_base_type
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_has_script_signal
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "has_script_signal" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_has_script_signal #-}

instance Method "has_script_signal" GodotScript
           (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_has_script_signal (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindScript_is_tool
  = unsafePerformIO $
      withCString "Script" $
        \ clsNamePtr ->
          withCString "is_tool" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindScript_is_tool #-}

instance Method "is_tool" GodotScript (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindScript_is_tool (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotWeakRef = GodotWeakRef GodotObject
                         deriving newtype AsVariant

instance HasBaseClass GodotWeakRef where
        type BaseClass GodotWeakRef = GodotReference
        super = coerce
bindWeakRef_get_ref
  = unsafePerformIO $
      withCString "WeakRef" $
        \ clsNamePtr ->
          withCString "get_ref" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindWeakRef_get_ref #-}

instance Method "get_ref" GodotWeakRef (IO GodotVariant) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindWeakRef_get_ref (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotImage = GodotImage GodotObject
                       deriving newtype AsVariant

instance HasBaseClass GodotImage where
        type BaseClass GodotImage = GodotResource
        super = coerce
bindImage_get_width
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_width" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_width #-}

instance Method "get_width" GodotImage (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_width (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_height
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_height" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_height #-}

instance Method "get_height" GodotImage (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_height (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_size
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_size" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_size #-}

instance Method "get_size" GodotImage (IO GodotVector2) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_size (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_has_mipmaps
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "has_mipmaps" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_has_mipmaps #-}

instance Method "has_mipmaps" GodotImage (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_has_mipmaps (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_format
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_format" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_format #-}

instance Method "get_format" GodotImage (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_format (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_data
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_data" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_data #-}

instance Method "get_data" GodotImage (IO GodotPoolByteArray) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_data (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_convert
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "convert" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_convert #-}

instance Method "convert" GodotImage (Int -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_convert (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_mipmap_offset
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_mipmap_offset" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_mipmap_offset #-}

instance Method "get_mipmap_offset" GodotImage (Int -> IO Int)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_mipmap_offset (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_resize_to_po2
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "resize_to_po2" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_resize_to_po2 #-}

instance Method "resize_to_po2" GodotImage (Bool -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_resize_to_po2 (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_resize
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "resize" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_resize #-}

instance Method "resize" GodotImage (Int -> Int -> Int -> IO ())
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_resize (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_shrink_x2
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "shrink_x2" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_shrink_x2 #-}

instance Method "shrink_x2" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_shrink_x2 (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_expand_x2_hq2x
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "expand_x2_hq2x" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_expand_x2_hq2x #-}

instance Method "expand_x2_hq2x" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_expand_x2_hq2x (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_crop
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "crop" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_crop #-}

instance Method "crop" GodotImage (Int -> Int -> IO ()) where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_crop (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_flip_x
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "flip_x" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_flip_x #-}

instance Method "flip_x" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_flip_x (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_flip_y
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "flip_y" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_flip_y #-}

instance Method "flip_y" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_flip_y (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_generate_mipmaps
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "generate_mipmaps" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_generate_mipmaps #-}

instance Method "generate_mipmaps" GodotImage (Bool -> IO Int)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_generate_mipmaps (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_clear_mipmaps
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "clear_mipmaps" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_clear_mipmaps #-}

instance Method "clear_mipmaps" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_clear_mipmaps (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_create
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "create" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_create #-}

instance Method "create" GodotImage
           (Int -> Int -> Bool -> Int -> IO ())
         where
        runMethod cls arg1 arg2 arg3 arg4
          = withVariantArray
              [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_create (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_create_from_data
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "create_from_data" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_create_from_data #-}

instance Method "create_from_data" GodotImage
           (Int -> Int -> Bool -> Int -> GodotPoolByteArray -> IO ())
         where
        runMethod cls arg1 arg2 arg3 arg4 arg5
          = withVariantArray
              [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4,
               toVariant arg5]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_create_from_data (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_is_empty
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "is_empty" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_is_empty #-}

instance Method "is_empty" GodotImage (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_is_empty (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_load
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "load" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_load #-}

instance Method "load" GodotImage (GodotString -> IO Int) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_load (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_save_png
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "save_png" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_save_png #-}

instance Method "save_png" GodotImage (GodotString -> IO Int) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_save_png (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_detect_alpha
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "detect_alpha" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_detect_alpha #-}

instance Method "detect_alpha" GodotImage (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_detect_alpha (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_is_invisible
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "is_invisible" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_is_invisible #-}

instance Method "is_invisible" GodotImage (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_is_invisible (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_compress
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "compress" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_compress #-}

instance Method "compress" GodotImage
           (Int -> Int -> Float -> IO Int)
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_compress (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_decompress
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "decompress" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_decompress #-}

instance Method "decompress" GodotImage (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_decompress (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_is_compressed
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "is_compressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_is_compressed #-}

instance Method "is_compressed" GodotImage (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_is_compressed (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_fix_alpha_edges
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "fix_alpha_edges" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_fix_alpha_edges #-}

instance Method "fix_alpha_edges" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_fix_alpha_edges (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_premultiply_alpha
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "premultiply_alpha" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_premultiply_alpha #-}

instance Method "premultiply_alpha" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_premultiply_alpha (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_srgb_to_linear
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "srgb_to_linear" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_srgb_to_linear #-}

instance Method "srgb_to_linear" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_srgb_to_linear (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_normalmap_to_xy
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "normalmap_to_xy" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_normalmap_to_xy #-}

instance Method "normalmap_to_xy" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_normalmap_to_xy (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_rgbe_to_srgb
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "rgbe_to_srgb" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_rgbe_to_srgb #-}

instance Method "rgbe_to_srgb" GodotImage (IO GodotImage) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_rgbe_to_srgb (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_bumpmap_to_normalmap
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "bumpmap_to_normalmap" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_bumpmap_to_normalmap #-}

instance Method "bumpmap_to_normalmap" GodotImage (Float -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_bumpmap_to_normalmap (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_blit_rect
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "blit_rect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_blit_rect #-}

instance Method "blit_rect" GodotImage
           (GodotImage -> GodotRect2 -> GodotVector2 -> IO ())
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_blit_rect (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_blit_rect_mask
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "blit_rect_mask" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_blit_rect_mask #-}

instance Method "blit_rect_mask" GodotImage
           (GodotImage -> GodotImage -> GodotRect2 -> GodotVector2 -> IO ())
         where
        runMethod cls arg1 arg2 arg3 arg4
          = withVariantArray
              [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_blit_rect_mask (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_blend_rect
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "blend_rect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_blend_rect #-}

instance Method "blend_rect" GodotImage
           (GodotImage -> GodotRect2 -> GodotVector2 -> IO ())
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_blend_rect (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_blend_rect_mask
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "blend_rect_mask" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_blend_rect_mask #-}

instance Method "blend_rect_mask" GodotImage
           (GodotImage -> GodotImage -> GodotRect2 -> GodotVector2 -> IO ())
         where
        runMethod cls arg1 arg2 arg3 arg4
          = withVariantArray
              [toVariant arg1, toVariant arg2, toVariant arg3, toVariant arg4]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_blend_rect_mask (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_fill
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "fill" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_fill #-}

instance Method "fill" GodotImage (GodotColor -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_fill (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_used_rect
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_used_rect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_used_rect #-}

instance Method "get_used_rect" GodotImage (IO GodotRect2) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_used_rect (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_rect
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_rect" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_rect #-}

instance Method "get_rect" GodotImage (GodotRect2 -> IO GodotImage)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_rect (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_copy_from
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "copy_from" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_copy_from #-}

instance Method "copy_from" GodotImage (GodotImage -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_copy_from (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage__set_data
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "_set_data" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage__set_data #-}

instance Method "_set_data" GodotImage (GodotDictionary -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage__set_data (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage__get_data
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "_get_data" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage__get_data #-}

instance Method "_get_data" GodotImage (IO GodotDictionary) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage__get_data (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_lock
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "lock" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_lock #-}

instance Method "lock" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_lock (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_unlock
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "unlock" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_unlock #-}

instance Method "unlock" GodotImage (IO ()) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_unlock (coerce cls) arrPtr len >>=
                   \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_pixelv
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_pixelv" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_pixelv #-}

instance Method "get_pixelv" GodotImage
           (GodotVector2 -> IO GodotColor)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_pixelv (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_get_pixel
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "get_pixel" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_get_pixel #-}

instance Method "get_pixel" GodotImage
           (Int -> Int -> IO GodotColor)
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_get_pixel (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_set_pixelv
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "set_pixelv" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_set_pixelv #-}

instance Method "set_pixelv" GodotImage
           (GodotVector2 -> GodotColor -> IO ())
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_set_pixelv (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_set_pixel
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "set_pixel" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_set_pixel #-}

instance Method "set_pixel" GodotImage
           (Int -> Int -> GodotColor -> IO ())
         where
        runMethod cls arg1 arg2 arg3
          = withVariantArray [toVariant arg1, toVariant arg2, toVariant arg3]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_set_pixel (coerce cls) arrPtr len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_load_png_from_buffer
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "load_png_from_buffer" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_load_png_from_buffer #-}

instance Method "load_png_from_buffer" GodotImage
           (GodotPoolByteArray -> IO Int)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_load_png_from_buffer (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_load_jpg_from_buffer
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "load_jpg_from_buffer" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_load_jpg_from_buffer #-}

instance Method "load_jpg_from_buffer" GodotImage
           (GodotPoolByteArray -> IO Int)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_load_jpg_from_buffer (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindImage_load_webp_from_buffer
  = unsafePerformIO $
      withCString "Image" $
        \ clsNamePtr ->
          withCString "load_webp_from_buffer" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindImage_load_webp_from_buffer #-}

instance Method "load_webp_from_buffer" GodotImage
           (GodotPoolByteArray -> IO Int)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindImage_load_webp_from_buffer (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotInputEvent = GodotInputEvent GodotObject
                            deriving newtype AsVariant

instance HasBaseClass GodotInputEvent where
        type BaseClass GodotInputEvent = GodotResource
        super = coerce
bindInputEvent_set_device
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "set_device" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_set_device #-}

instance Method "set_device" GodotInputEvent (Int -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_set_device (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_get_device
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "get_device" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_get_device #-}

instance Method "get_device" GodotInputEvent (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_get_device (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_action
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_action" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_action #-}

instance Method "is_action" GodotInputEvent
           (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_action (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_action_pressed
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_action_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_action_pressed #-}

instance Method "is_action_pressed" GodotInputEvent
           (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_action_pressed
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_action_released
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_action_released" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_action_released #-}

instance Method "is_action_released" GodotInputEvent
           (GodotString -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_action_released
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_get_action_strength
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "get_action_strength" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_get_action_strength #-}

instance Method "get_action_strength" GodotInputEvent
           (GodotString -> IO Float)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_get_action_strength
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_pressed
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_pressed #-}

instance Method "is_pressed" GodotInputEvent (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_pressed (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_echo
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_echo" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_echo #-}

instance Method "is_echo" GodotInputEvent (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_echo (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_as_text
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "as_text" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_as_text #-}

instance Method "as_text" GodotInputEvent (IO GodotString) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_as_text (coerce cls) arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_shortcut_match
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "shortcut_match" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_shortcut_match #-}

instance Method "shortcut_match" GodotInputEvent
           (GodotInputEvent -> IO Bool)
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_shortcut_match (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_is_action_type
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "is_action_type" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_is_action_type #-}

instance Method "is_action_type" GodotInputEvent (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_is_action_type (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEvent_xformed_by
  = unsafePerformIO $
      withCString "InputEvent" $
        \ clsNamePtr ->
          withCString "xformed_by" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEvent_xformed_by #-}

instance Method "xformed_by" GodotInputEvent
           (GodotTransform2d -> GodotVector2 -> IO GodotInputEvent)
         where
        runMethod cls arg1 arg2
          = withVariantArray [toVariant arg1, toVariant arg2]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEvent_xformed_by (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotInputEventWithModifiers = GodotInputEventWithModifiers GodotObject
                                         deriving newtype AsVariant

instance HasBaseClass GodotInputEventWithModifiers where
        type BaseClass GodotInputEventWithModifiers = GodotInputEvent
        super = coerce
bindInputEventWithModifiers_set_alt
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "set_alt" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_set_alt #-}

instance Method "set_alt" GodotInputEventWithModifiers
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_set_alt
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_get_alt
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "get_alt" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_get_alt #-}

instance Method "get_alt" GodotInputEventWithModifiers (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_get_alt
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_set_shift
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "set_shift" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_set_shift #-}

instance Method "set_shift" GodotInputEventWithModifiers
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_set_shift
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_get_shift
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "get_shift" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_get_shift #-}

instance Method "get_shift" GodotInputEventWithModifiers (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_get_shift
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_set_control
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "set_control" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_set_control #-}

instance Method "set_control" GodotInputEventWithModifiers
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_set_control
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_get_control
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "get_control" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_get_control #-}

instance Method "get_control" GodotInputEventWithModifiers
           (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_get_control
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_set_metakey
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "set_metakey" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_set_metakey #-}

instance Method "set_metakey" GodotInputEventWithModifiers
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_set_metakey
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_get_metakey
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "get_metakey" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_get_metakey #-}

instance Method "get_metakey" GodotInputEventWithModifiers
           (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_get_metakey
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_set_command
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "set_command" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_set_command #-}

instance Method "set_command" GodotInputEventWithModifiers
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_set_command
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventWithModifiers_get_command
  = unsafePerformIO $
      withCString "InputEventWithModifiers" $
        \ clsNamePtr ->
          withCString "get_command" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventWithModifiers_get_command #-}

instance Method "get_command" GodotInputEventWithModifiers
           (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventWithModifiers_get_command
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotInputEventKey = GodotInputEventKey GodotObject
                               deriving newtype AsVariant

instance HasBaseClass GodotInputEventKey where
        type BaseClass GodotInputEventKey = GodotInputEventWithModifiers
        super = coerce
bindInputEventKey_is_pressed
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "is_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_is_pressed #-}

instance Method "is_pressed" GodotInputEventKey (IO Bool) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_is_pressed (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_is_echo
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "is_echo" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_is_echo #-}

instance Method "is_echo" GodotInputEventKey (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_is_echo (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_set_pressed
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "set_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_set_pressed #-}

instance Method "set_pressed" GodotInputEventKey (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_set_pressed (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_set_scancode
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "set_scancode" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_set_scancode #-}

instance Method "set_scancode" GodotInputEventKey (Int -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_set_scancode (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_get_scancode
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "get_scancode" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_get_scancode #-}

instance Method "get_scancode" GodotInputEventKey (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_get_scancode (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_set_unicode
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "set_unicode" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_set_unicode #-}

instance Method "set_unicode" GodotInputEventKey (Int -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_set_unicode (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_get_unicode
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "get_unicode" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_get_unicode #-}

instance Method "get_unicode" GodotInputEventKey (IO Int) where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_get_unicode (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_set_echo
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "set_echo" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_set_echo #-}

instance Method "set_echo" GodotInputEventKey (Bool -> IO ()) where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventKey_set_echo (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventKey_get_scancode_with_modifiers
  = unsafePerformIO $
      withCString "InputEventKey" $
        \ clsNamePtr ->
          withCString "get_scancode_with_modifiers" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventKey_get_scancode_with_modifiers #-}

instance Method "get_scancode_with_modifiers" GodotInputEventKey
           (IO Int)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call
                   bindInputEventKey_get_scancode_with_modifiers
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotInputEventMouse = GodotInputEventMouse GodotObject
                                 deriving newtype AsVariant

instance HasBaseClass GodotInputEventMouse where
        type BaseClass GodotInputEventMouse = GodotInputEventWithModifiers
        super = coerce
bindInputEventMouse_set_button_mask
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "set_button_mask" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_set_button_mask #-}

instance Method "set_button_mask" GodotInputEventMouse
           (Int -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_set_button_mask
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouse_get_button_mask
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "get_button_mask" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_get_button_mask #-}

instance Method "get_button_mask" GodotInputEventMouse (IO Int)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_get_button_mask
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouse_set_position
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "set_position" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_set_position #-}

instance Method "set_position" GodotInputEventMouse
           (GodotVector2 -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_set_position
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouse_get_position
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "get_position" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_get_position #-}

instance Method "get_position" GodotInputEventMouse
           (IO GodotVector2)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_get_position
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouse_set_global_position
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "set_global_position" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_set_global_position #-}

instance Method "set_global_position" GodotInputEventMouse
           (GodotVector2 -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_set_global_position
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouse_get_global_position
  = unsafePerformIO $
      withCString "InputEventMouse" $
        \ clsNamePtr ->
          withCString "get_global_position" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouse_get_global_position #-}

instance Method "get_global_position" GodotInputEventMouse
           (IO GodotVector2)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouse_get_global_position
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)

newtype GodotInputEventMouseButton = GodotInputEventMouseButton GodotObject
                                       deriving newtype AsVariant

instance HasBaseClass GodotInputEventMouseButton where
        type BaseClass GodotInputEventMouseButton = GodotInputEventMouse
        super = coerce
bindInputEventMouseButton_is_pressed
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "is_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_is_pressed #-}

instance Method "is_pressed" GodotInputEventMouseButton (IO Bool)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_is_pressed
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_set_factor
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "set_factor" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_set_factor #-}

instance Method "set_factor" GodotInputEventMouseButton
           (Float -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_set_factor
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_get_factor
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "get_factor" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_get_factor #-}

instance Method "get_factor" GodotInputEventMouseButton (IO Float)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_get_factor
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_set_button_index
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "set_button_index" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_set_button_index #-}

instance Method "set_button_index" GodotInputEventMouseButton
           (Int -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_set_button_index
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_get_button_index
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "get_button_index" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_get_button_index #-}

instance Method "get_button_index" GodotInputEventMouseButton
           (IO Int)
         where
        runMethod cls
          = withVariantArray []
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_get_button_index
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_set_pressed
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "set_pressed" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_set_pressed #-}

instance Method "set_pressed" GodotInputEventMouseButton
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_set_pressed
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)
bindInputEventMouseButton_set_doubleclick
  = unsafePerformIO $
      withCString "InputEventMouseButton" $
        \ clsNamePtr ->
          withCString "set_doubleclick" $
            \ methodNamePtr ->
              godot_method_bind_get_method clsNamePtr methodNamePtr

{-# NOINLINE bindInputEventMouseButton_set_doubleclick #-}

instance Method "set_doubleclick" GodotInputEventMouseButton
           (Bool -> IO ())
         where
        runMethod cls arg1
          = withVariantArray [toVariant arg1]
              (\ (arrPtr, len) ->
                 godot_method_bind_call bindInputEventMouseButton_set_doubleclick
                   (coerce cls)
                   arrPtr
                   len
                   >>= \ (err, res) -> throwIfErr err >> fromGodotVariant res)