#pragma once
#ifndef MIQT_QT6_GEN_QEVENT_H
#define MIQT_QT6_GEN_QEVENT_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#include "../libmiqt/libmiqt.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
class QAction;
class QActionEvent;
class QApplicationStateChangeEvent;
class QCloseEvent;
class QContextMenuEvent;
class QDragEnterEvent;
class QDragLeaveEvent;
class QDragMoveEvent;
class QDropEvent;
class QEnterEvent;
class QEvent;
class QEventPoint;
class QExposeEvent;
class QFile;
class QFileOpenEvent;
class QFocusEvent;
class QHelpEvent;
class QHideEvent;
class QHoverEvent;
class QIconDragEvent;
class QInputDevice;
class QInputEvent;
class QInputMethodEvent;
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_QInputMethodEvent__Attribute)
typedef QInputMethodEvent::Attribute QInputMethodEvent__Attribute;
#else
class QInputMethodEvent__Attribute;
#endif
class QInputMethodQueryEvent;
class QKeyCombination;
class QKeyEvent;
class QKeySequence;
class QMimeData;
class QMouseEvent;
class QMoveEvent;
class QNativeGestureEvent;
class QObject;
class QPaintEvent;
class QPlatformSurfaceEvent;
class QPoint;
class QPointF;
class QPointerEvent;
class QPointingDevice;
class QRect;
class QRectF;
class QRegion;
class QResizeEvent;
class QScreen;
class QScreenOrientationChangeEvent;
class QScrollEvent;
class QScrollPrepareEvent;
class QShortcutEvent;
class QShowEvent;
class QSinglePointEvent;
class QSize;
class QSizeF;
class QStatusTipEvent;
class QTabletEvent;
class QToolBarChangeEvent;
class QTouchEvent;
class QUrl;
class QVariant;
class QWhatsThisClickedEvent;
class QWheelEvent;
class QWindowStateChangeEvent;
#else
typedef struct QAction QAction;
typedef struct QActionEvent QActionEvent;
typedef struct QApplicationStateChangeEvent QApplicationStateChangeEvent;
typedef struct QCloseEvent QCloseEvent;
typedef struct QContextMenuEvent QContextMenuEvent;
typedef struct QDragEnterEvent QDragEnterEvent;
typedef struct QDragLeaveEvent QDragLeaveEvent;
typedef struct QDragMoveEvent QDragMoveEvent;
typedef struct QDropEvent QDropEvent;
typedef struct QEnterEvent QEnterEvent;
typedef struct QEvent QEvent;
typedef struct QEventPoint QEventPoint;
typedef struct QExposeEvent QExposeEvent;
typedef struct QFile QFile;
typedef struct QFileOpenEvent QFileOpenEvent;
typedef struct QFocusEvent QFocusEvent;
typedef struct QHelpEvent QHelpEvent;
typedef struct QHideEvent QHideEvent;
typedef struct QHoverEvent QHoverEvent;
typedef struct QIconDragEvent QIconDragEvent;
typedef struct QInputDevice QInputDevice;
typedef struct QInputEvent QInputEvent;
typedef struct QInputMethodEvent QInputMethodEvent;
typedef struct QInputMethodEvent__Attribute QInputMethodEvent__Attribute;
typedef struct QInputMethodQueryEvent QInputMethodQueryEvent;
typedef struct QKeyCombination QKeyCombination;
typedef struct QKeyEvent QKeyEvent;
typedef struct QKeySequence QKeySequence;
typedef struct QMimeData QMimeData;
typedef struct QMouseEvent QMouseEvent;
typedef struct QMoveEvent QMoveEvent;
typedef struct QNativeGestureEvent QNativeGestureEvent;
typedef struct QObject QObject;
typedef struct QPaintEvent QPaintEvent;
typedef struct QPlatformSurfaceEvent QPlatformSurfaceEvent;
typedef struct QPoint QPoint;
typedef struct QPointF QPointF;
typedef struct QPointerEvent QPointerEvent;
typedef struct QPointingDevice QPointingDevice;
typedef struct QRect QRect;
typedef struct QRectF QRectF;
typedef struct QRegion QRegion;
typedef struct QResizeEvent QResizeEvent;
typedef struct QScreen QScreen;
typedef struct QScreenOrientationChangeEvent QScreenOrientationChangeEvent;
typedef struct QScrollEvent QScrollEvent;
typedef struct QScrollPrepareEvent QScrollPrepareEvent;
typedef struct QShortcutEvent QShortcutEvent;
typedef struct QShowEvent QShowEvent;
typedef struct QSinglePointEvent QSinglePointEvent;
typedef struct QSize QSize;
typedef struct QSizeF QSizeF;
typedef struct QStatusTipEvent QStatusTipEvent;
typedef struct QTabletEvent QTabletEvent;
typedef struct QToolBarChangeEvent QToolBarChangeEvent;
typedef struct QTouchEvent QTouchEvent;
typedef struct QUrl QUrl;
typedef struct QVariant QVariant;
typedef struct QWhatsThisClickedEvent QWhatsThisClickedEvent;
typedef struct QWheelEvent QWheelEvent;
typedef struct QWindowStateChangeEvent QWindowStateChangeEvent;
#endif

QInputEvent* QInputEvent_new(int typeVal, QInputDevice* m_dev);
QInputEvent* QInputEvent_new2(int typeVal, QInputDevice* m_dev, int modifiers);
void QInputEvent_virtbase(QInputEvent* src, QEvent** outptr_QEvent);
QInputEvent* QInputEvent_Clone(const QInputEvent* self);
QInputDevice* QInputEvent_Device(const QInputEvent* self);
int QInputEvent_DeviceType(const QInputEvent* self);
int QInputEvent_Modifiers(const QInputEvent* self);
void QInputEvent_SetModifiers(QInputEvent* self, int modifiers);
unsigned long long QInputEvent_Timestamp(const QInputEvent* self);
void QInputEvent_SetTimestamp(QInputEvent* self, unsigned long long timestamp);
void QInputEvent_override_virtual_Clone(void* self, intptr_t slot);
QInputEvent* QInputEvent_virtualbase_Clone(const void* self);
void QInputEvent_override_virtual_SetTimestamp(void* self, intptr_t slot);
void QInputEvent_virtualbase_SetTimestamp(void* self, unsigned long long timestamp);
void QInputEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QInputEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QInputEvent_Delete(QInputEvent* self, bool isSubclass);

QPointerEvent* QPointerEvent_new(int typeVal, QPointingDevice* dev);
QPointerEvent* QPointerEvent_new2(int typeVal, QPointingDevice* dev, int modifiers);
QPointerEvent* QPointerEvent_new3(int typeVal, QPointingDevice* dev, int modifiers, struct miqt_array /* of QEventPoint* */  points);
void QPointerEvent_virtbase(QPointerEvent* src, QInputEvent** outptr_QInputEvent);
QPointerEvent* QPointerEvent_Clone(const QPointerEvent* self);
QPointingDevice* QPointerEvent_PointingDevice(const QPointerEvent* self);
int QPointerEvent_PointerType(const QPointerEvent* self);
void QPointerEvent_SetTimestamp(QPointerEvent* self, unsigned long long timestamp);
ptrdiff_t QPointerEvent_PointCount(const QPointerEvent* self);
QEventPoint* QPointerEvent_Point(QPointerEvent* self, ptrdiff_t i);
struct miqt_array /* of QEventPoint* */  QPointerEvent_Points(const QPointerEvent* self);
QEventPoint* QPointerEvent_PointById(QPointerEvent* self, int id);
bool QPointerEvent_AllPointsGrabbed(const QPointerEvent* self);
bool QPointerEvent_IsBeginEvent(const QPointerEvent* self);
bool QPointerEvent_IsUpdateEvent(const QPointerEvent* self);
bool QPointerEvent_IsEndEvent(const QPointerEvent* self);
bool QPointerEvent_AllPointsAccepted(const QPointerEvent* self);
void QPointerEvent_SetAccepted(QPointerEvent* self, bool accepted);
QObject* QPointerEvent_ExclusiveGrabber(const QPointerEvent* self, QEventPoint* point);
void QPointerEvent_SetExclusiveGrabber(QPointerEvent* self, QEventPoint* point, QObject* exclusiveGrabber);
void QPointerEvent_ClearPassiveGrabbers(QPointerEvent* self, QEventPoint* point);
bool QPointerEvent_AddPassiveGrabber(QPointerEvent* self, QEventPoint* point, QObject* grabber);
bool QPointerEvent_RemovePassiveGrabber(QPointerEvent* self, QEventPoint* point, QObject* grabber);
void QPointerEvent_override_virtual_Clone(void* self, intptr_t slot);
QPointerEvent* QPointerEvent_virtualbase_Clone(const void* self);
void QPointerEvent_override_virtual_SetTimestamp(void* self, intptr_t slot);
void QPointerEvent_virtualbase_SetTimestamp(void* self, unsigned long long timestamp);
void QPointerEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QPointerEvent_virtualbase_IsBeginEvent(const void* self);
void QPointerEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QPointerEvent_virtualbase_IsUpdateEvent(const void* self);
void QPointerEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QPointerEvent_virtualbase_IsEndEvent(const void* self);
void QPointerEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QPointerEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QPointerEvent_Delete(QPointerEvent* self, bool isSubclass);

void QSinglePointEvent_virtbase(QSinglePointEvent* src, QPointerEvent** outptr_QPointerEvent);
QSinglePointEvent* QSinglePointEvent_Clone(const QSinglePointEvent* self);
int QSinglePointEvent_Button(const QSinglePointEvent* self);
int QSinglePointEvent_Buttons(const QSinglePointEvent* self);
QPointF* QSinglePointEvent_Position(const QSinglePointEvent* self);
QPointF* QSinglePointEvent_ScenePosition(const QSinglePointEvent* self);
QPointF* QSinglePointEvent_GlobalPosition(const QSinglePointEvent* self);
bool QSinglePointEvent_IsBeginEvent(const QSinglePointEvent* self);
bool QSinglePointEvent_IsUpdateEvent(const QSinglePointEvent* self);
bool QSinglePointEvent_IsEndEvent(const QSinglePointEvent* self);
QObject* QSinglePointEvent_ExclusivePointGrabber(const QSinglePointEvent* self);
void QSinglePointEvent_SetExclusivePointGrabber(QSinglePointEvent* self, QObject* exclusiveGrabber);
void QSinglePointEvent_Delete(QSinglePointEvent* self, bool isSubclass);

QEnterEvent* QEnterEvent_new(QPointF* localPos, QPointF* scenePos, QPointF* globalPos);
QEnterEvent* QEnterEvent_new2(QPointF* localPos, QPointF* scenePos, QPointF* globalPos, QPointingDevice* device);
void QEnterEvent_virtbase(QEnterEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QEnterEvent* QEnterEvent_Clone(const QEnterEvent* self);
QPoint* QEnterEvent_Pos(const QEnterEvent* self);
QPoint* QEnterEvent_GlobalPos(const QEnterEvent* self);
int QEnterEvent_X(const QEnterEvent* self);
int QEnterEvent_Y(const QEnterEvent* self);
int QEnterEvent_GlobalX(const QEnterEvent* self);
int QEnterEvent_GlobalY(const QEnterEvent* self);
QPointF* QEnterEvent_LocalPos(const QEnterEvent* self);
QPointF* QEnterEvent_WindowPos(const QEnterEvent* self);
QPointF* QEnterEvent_ScreenPos(const QEnterEvent* self);
void QEnterEvent_override_virtual_Clone(void* self, intptr_t slot);
QEnterEvent* QEnterEvent_virtualbase_Clone(const void* self);
void QEnterEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QEnterEvent_virtualbase_IsBeginEvent(const void* self);
void QEnterEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QEnterEvent_virtualbase_IsUpdateEvent(const void* self);
void QEnterEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QEnterEvent_virtualbase_IsEndEvent(const void* self);
void QEnterEvent_Delete(QEnterEvent* self, bool isSubclass);

QMouseEvent* QMouseEvent_new(int typeVal, QPointF* localPos, int button, int buttons, int modifiers);
QMouseEvent* QMouseEvent_new2(int typeVal, QPointF* localPos, QPointF* globalPos, int button, int buttons, int modifiers);
QMouseEvent* QMouseEvent_new3(int typeVal, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, int button, int buttons, int modifiers);
QMouseEvent* QMouseEvent_new4(int typeVal, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, int button, int buttons, int modifiers, int source);
QMouseEvent* QMouseEvent_new5(int typeVal, QPointF* localPos, int button, int buttons, int modifiers, QPointingDevice* device);
QMouseEvent* QMouseEvent_new6(int typeVal, QPointF* localPos, QPointF* globalPos, int button, int buttons, int modifiers, QPointingDevice* device);
QMouseEvent* QMouseEvent_new7(int typeVal, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, int button, int buttons, int modifiers, QPointingDevice* device);
QMouseEvent* QMouseEvent_new8(int typeVal, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, int button, int buttons, int modifiers, int source, QPointingDevice* device);
void QMouseEvent_virtbase(QMouseEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QMouseEvent* QMouseEvent_Clone(const QMouseEvent* self);
QPoint* QMouseEvent_Pos(const QMouseEvent* self);
QPoint* QMouseEvent_GlobalPos(const QMouseEvent* self);
int QMouseEvent_X(const QMouseEvent* self);
int QMouseEvent_Y(const QMouseEvent* self);
int QMouseEvent_GlobalX(const QMouseEvent* self);
int QMouseEvent_GlobalY(const QMouseEvent* self);
QPointF* QMouseEvent_LocalPos(const QMouseEvent* self);
QPointF* QMouseEvent_WindowPos(const QMouseEvent* self);
QPointF* QMouseEvent_ScreenPos(const QMouseEvent* self);
int QMouseEvent_Source(const QMouseEvent* self);
int QMouseEvent_Flags(const QMouseEvent* self);
void QMouseEvent_override_virtual_Clone(void* self, intptr_t slot);
QMouseEvent* QMouseEvent_virtualbase_Clone(const void* self);
void QMouseEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QMouseEvent_virtualbase_IsBeginEvent(const void* self);
void QMouseEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QMouseEvent_virtualbase_IsUpdateEvent(const void* self);
void QMouseEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QMouseEvent_virtualbase_IsEndEvent(const void* self);
void QMouseEvent_Delete(QMouseEvent* self, bool isSubclass);

QHoverEvent* QHoverEvent_new(int typeVal, QPointF* scenePos, QPointF* globalPos, QPointF* oldPos);
QHoverEvent* QHoverEvent_new2(int typeVal, QPointF* pos, QPointF* oldPos);
QHoverEvent* QHoverEvent_new3(int typeVal, QPointF* scenePos, QPointF* globalPos, QPointF* oldPos, int modifiers);
QHoverEvent* QHoverEvent_new4(int typeVal, QPointF* scenePos, QPointF* globalPos, QPointF* oldPos, int modifiers, QPointingDevice* device);
QHoverEvent* QHoverEvent_new5(int typeVal, QPointF* pos, QPointF* oldPos, int modifiers);
QHoverEvent* QHoverEvent_new6(int typeVal, QPointF* pos, QPointF* oldPos, int modifiers, QPointingDevice* device);
void QHoverEvent_virtbase(QHoverEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QHoverEvent* QHoverEvent_Clone(const QHoverEvent* self);
QPoint* QHoverEvent_Pos(const QHoverEvent* self);
QPointF* QHoverEvent_PosF(const QHoverEvent* self);
bool QHoverEvent_IsUpdateEvent(const QHoverEvent* self);
QPoint* QHoverEvent_OldPos(const QHoverEvent* self);
QPointF* QHoverEvent_OldPosF(const QHoverEvent* self);
void QHoverEvent_override_virtual_Clone(void* self, intptr_t slot);
QHoverEvent* QHoverEvent_virtualbase_Clone(const void* self);
void QHoverEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QHoverEvent_virtualbase_IsUpdateEvent(const void* self);
void QHoverEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QHoverEvent_virtualbase_IsBeginEvent(const void* self);
void QHoverEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QHoverEvent_virtualbase_IsEndEvent(const void* self);
void QHoverEvent_Delete(QHoverEvent* self, bool isSubclass);

QWheelEvent* QWheelEvent_new(QPointF* pos, QPointF* globalPos, QPoint* pixelDelta, QPoint* angleDelta, int buttons, int modifiers, int phase, bool inverted);
QWheelEvent* QWheelEvent_new2(QPointF* pos, QPointF* globalPos, QPoint* pixelDelta, QPoint* angleDelta, int buttons, int modifiers, int phase, bool inverted, int source);
QWheelEvent* QWheelEvent_new3(QPointF* pos, QPointF* globalPos, QPoint* pixelDelta, QPoint* angleDelta, int buttons, int modifiers, int phase, bool inverted, int source, QPointingDevice* device);
void QWheelEvent_virtbase(QWheelEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QWheelEvent* QWheelEvent_Clone(const QWheelEvent* self);
QPoint* QWheelEvent_PixelDelta(const QWheelEvent* self);
QPoint* QWheelEvent_AngleDelta(const QWheelEvent* self);
int QWheelEvent_Phase(const QWheelEvent* self);
bool QWheelEvent_Inverted(const QWheelEvent* self);
bool QWheelEvent_IsInverted(const QWheelEvent* self);
bool QWheelEvent_HasPixelDelta(const QWheelEvent* self);
bool QWheelEvent_IsBeginEvent(const QWheelEvent* self);
bool QWheelEvent_IsUpdateEvent(const QWheelEvent* self);
bool QWheelEvent_IsEndEvent(const QWheelEvent* self);
int QWheelEvent_Source(const QWheelEvent* self);
void QWheelEvent_override_virtual_Clone(void* self, intptr_t slot);
QWheelEvent* QWheelEvent_virtualbase_Clone(const void* self);
void QWheelEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QWheelEvent_virtualbase_IsBeginEvent(const void* self);
void QWheelEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QWheelEvent_virtualbase_IsUpdateEvent(const void* self);
void QWheelEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QWheelEvent_virtualbase_IsEndEvent(const void* self);
void QWheelEvent_Delete(QWheelEvent* self, bool isSubclass);

QTabletEvent* QTabletEvent_new(int t, QPointingDevice* device, QPointF* pos, QPointF* globalPos, double pressure, float xTilt, float yTilt, float tangentialPressure, double rotation, float z, int keyState, int button, int buttons);
void QTabletEvent_virtbase(QTabletEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QTabletEvent* QTabletEvent_Clone(const QTabletEvent* self);
QPoint* QTabletEvent_Pos(const QTabletEvent* self);
QPoint* QTabletEvent_GlobalPos(const QTabletEvent* self);
QPointF* QTabletEvent_PosF(const QTabletEvent* self);
QPointF* QTabletEvent_GlobalPosF(const QTabletEvent* self);
int QTabletEvent_X(const QTabletEvent* self);
int QTabletEvent_Y(const QTabletEvent* self);
int QTabletEvent_GlobalX(const QTabletEvent* self);
int QTabletEvent_GlobalY(const QTabletEvent* self);
double QTabletEvent_HiResGlobalX(const QTabletEvent* self);
double QTabletEvent_HiResGlobalY(const QTabletEvent* self);
long long QTabletEvent_UniqueId(const QTabletEvent* self);
double QTabletEvent_Pressure(const QTabletEvent* self);
double QTabletEvent_Rotation(const QTabletEvent* self);
double QTabletEvent_Z(const QTabletEvent* self);
double QTabletEvent_TangentialPressure(const QTabletEvent* self);
double QTabletEvent_XTilt(const QTabletEvent* self);
double QTabletEvent_YTilt(const QTabletEvent* self);
void QTabletEvent_override_virtual_Clone(void* self, intptr_t slot);
QTabletEvent* QTabletEvent_virtualbase_Clone(const void* self);
void QTabletEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QTabletEvent_virtualbase_IsBeginEvent(const void* self);
void QTabletEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QTabletEvent_virtualbase_IsUpdateEvent(const void* self);
void QTabletEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QTabletEvent_virtualbase_IsEndEvent(const void* self);
void QTabletEvent_Delete(QTabletEvent* self, bool isSubclass);

QNativeGestureEvent* QNativeGestureEvent_new(int typeVal, QPointingDevice* dev, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, double value, unsigned long long sequenceId, unsigned long long intArgument);
QNativeGestureEvent* QNativeGestureEvent_new2(int typeVal, QPointingDevice* dev, int fingerCount, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, double value, QPointF* delta);
QNativeGestureEvent* QNativeGestureEvent_new3(int typeVal, QPointingDevice* dev, int fingerCount, QPointF* localPos, QPointF* scenePos, QPointF* globalPos, double value, QPointF* delta, unsigned long long sequenceId);
void QNativeGestureEvent_virtbase(QNativeGestureEvent* src, QSinglePointEvent** outptr_QSinglePointEvent);
QNativeGestureEvent* QNativeGestureEvent_Clone(const QNativeGestureEvent* self);
int QNativeGestureEvent_GestureType(const QNativeGestureEvent* self);
int QNativeGestureEvent_FingerCount(const QNativeGestureEvent* self);
double QNativeGestureEvent_Value(const QNativeGestureEvent* self);
QPointF* QNativeGestureEvent_Delta(const QNativeGestureEvent* self);
QPoint* QNativeGestureEvent_Pos(const QNativeGestureEvent* self);
QPoint* QNativeGestureEvent_GlobalPos(const QNativeGestureEvent* self);
QPointF* QNativeGestureEvent_LocalPos(const QNativeGestureEvent* self);
QPointF* QNativeGestureEvent_WindowPos(const QNativeGestureEvent* self);
QPointF* QNativeGestureEvent_ScreenPos(const QNativeGestureEvent* self);
void QNativeGestureEvent_override_virtual_Clone(void* self, intptr_t slot);
QNativeGestureEvent* QNativeGestureEvent_virtualbase_Clone(const void* self);
void QNativeGestureEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QNativeGestureEvent_virtualbase_IsBeginEvent(const void* self);
void QNativeGestureEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QNativeGestureEvent_virtualbase_IsUpdateEvent(const void* self);
void QNativeGestureEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QNativeGestureEvent_virtualbase_IsEndEvent(const void* self);
void QNativeGestureEvent_Delete(QNativeGestureEvent* self, bool isSubclass);

QKeyEvent* QKeyEvent_new(int typeVal, int key, int modifiers);
QKeyEvent* QKeyEvent_new2(int typeVal, int key, int modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers);
QKeyEvent* QKeyEvent_new3(int typeVal, int key, int modifiers, struct miqt_string text);
QKeyEvent* QKeyEvent_new4(int typeVal, int key, int modifiers, struct miqt_string text, bool autorep);
QKeyEvent* QKeyEvent_new5(int typeVal, int key, int modifiers, struct miqt_string text, bool autorep, uint16_t count);
QKeyEvent* QKeyEvent_new6(int typeVal, int key, int modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, struct miqt_string text);
QKeyEvent* QKeyEvent_new7(int typeVal, int key, int modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, struct miqt_string text, bool autorep);
QKeyEvent* QKeyEvent_new8(int typeVal, int key, int modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, struct miqt_string text, bool autorep, uint16_t count);
QKeyEvent* QKeyEvent_new9(int typeVal, int key, int modifiers, unsigned int nativeScanCode, unsigned int nativeVirtualKey, unsigned int nativeModifiers, struct miqt_string text, bool autorep, uint16_t count, QInputDevice* device);
void QKeyEvent_virtbase(QKeyEvent* src, QInputEvent** outptr_QInputEvent);
QKeyEvent* QKeyEvent_Clone(const QKeyEvent* self);
int QKeyEvent_Key(const QKeyEvent* self);
bool QKeyEvent_Matches(const QKeyEvent* self, int key);
int QKeyEvent_Modifiers(const QKeyEvent* self);
QKeyCombination* QKeyEvent_KeyCombination(const QKeyEvent* self);
struct miqt_string QKeyEvent_Text(const QKeyEvent* self);
bool QKeyEvent_IsAutoRepeat(const QKeyEvent* self);
int QKeyEvent_Count(const QKeyEvent* self);
unsigned int QKeyEvent_NativeScanCode(const QKeyEvent* self);
unsigned int QKeyEvent_NativeVirtualKey(const QKeyEvent* self);
unsigned int QKeyEvent_NativeModifiers(const QKeyEvent* self);
void QKeyEvent_override_virtual_Clone(void* self, intptr_t slot);
QKeyEvent* QKeyEvent_virtualbase_Clone(const void* self);
void QKeyEvent_override_virtual_SetTimestamp(void* self, intptr_t slot);
void QKeyEvent_virtualbase_SetTimestamp(void* self, unsigned long long timestamp);
void QKeyEvent_Delete(QKeyEvent* self, bool isSubclass);

QFocusEvent* QFocusEvent_new(int typeVal);
QFocusEvent* QFocusEvent_new2(int typeVal, int reason);
void QFocusEvent_virtbase(QFocusEvent* src, QEvent** outptr_QEvent);
QFocusEvent* QFocusEvent_Clone(const QFocusEvent* self);
bool QFocusEvent_GotFocus(const QFocusEvent* self);
bool QFocusEvent_LostFocus(const QFocusEvent* self);
int QFocusEvent_Reason(const QFocusEvent* self);
void QFocusEvent_override_virtual_Clone(void* self, intptr_t slot);
QFocusEvent* QFocusEvent_virtualbase_Clone(const void* self);
void QFocusEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QFocusEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QFocusEvent_Delete(QFocusEvent* self, bool isSubclass);

QPaintEvent* QPaintEvent_new(QRegion* paintRegion);
QPaintEvent* QPaintEvent_new2(QRect* paintRect);
void QPaintEvent_virtbase(QPaintEvent* src, QEvent** outptr_QEvent);
QPaintEvent* QPaintEvent_Clone(const QPaintEvent* self);
QRect* QPaintEvent_Rect(const QPaintEvent* self);
QRegion* QPaintEvent_Region(const QPaintEvent* self);
void QPaintEvent_override_virtual_Clone(void* self, intptr_t slot);
QPaintEvent* QPaintEvent_virtualbase_Clone(const void* self);
void QPaintEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QPaintEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QPaintEvent_Delete(QPaintEvent* self, bool isSubclass);

QMoveEvent* QMoveEvent_new(QPoint* pos, QPoint* oldPos);
void QMoveEvent_virtbase(QMoveEvent* src, QEvent** outptr_QEvent);
QMoveEvent* QMoveEvent_Clone(const QMoveEvent* self);
QPoint* QMoveEvent_Pos(const QMoveEvent* self);
QPoint* QMoveEvent_OldPos(const QMoveEvent* self);
void QMoveEvent_override_virtual_Clone(void* self, intptr_t slot);
QMoveEvent* QMoveEvent_virtualbase_Clone(const void* self);
void QMoveEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QMoveEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QMoveEvent_Delete(QMoveEvent* self, bool isSubclass);

QExposeEvent* QExposeEvent_new(QRegion* m_region);
void QExposeEvent_virtbase(QExposeEvent* src, QEvent** outptr_QEvent);
QExposeEvent* QExposeEvent_Clone(const QExposeEvent* self);
QRegion* QExposeEvent_Region(const QExposeEvent* self);
void QExposeEvent_override_virtual_Clone(void* self, intptr_t slot);
QExposeEvent* QExposeEvent_virtualbase_Clone(const void* self);
void QExposeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QExposeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QExposeEvent_Delete(QExposeEvent* self, bool isSubclass);

QPlatformSurfaceEvent* QPlatformSurfaceEvent_new(int surfaceEventType);
void QPlatformSurfaceEvent_virtbase(QPlatformSurfaceEvent* src, QEvent** outptr_QEvent);
QPlatformSurfaceEvent* QPlatformSurfaceEvent_Clone(const QPlatformSurfaceEvent* self);
int QPlatformSurfaceEvent_SurfaceEventType(const QPlatformSurfaceEvent* self);
void QPlatformSurfaceEvent_override_virtual_Clone(void* self, intptr_t slot);
QPlatformSurfaceEvent* QPlatformSurfaceEvent_virtualbase_Clone(const void* self);
void QPlatformSurfaceEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QPlatformSurfaceEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QPlatformSurfaceEvent_Delete(QPlatformSurfaceEvent* self, bool isSubclass);

QResizeEvent* QResizeEvent_new(QSize* size, QSize* oldSize);
void QResizeEvent_virtbase(QResizeEvent* src, QEvent** outptr_QEvent);
QResizeEvent* QResizeEvent_Clone(const QResizeEvent* self);
QSize* QResizeEvent_Size(const QResizeEvent* self);
QSize* QResizeEvent_OldSize(const QResizeEvent* self);
void QResizeEvent_override_virtual_Clone(void* self, intptr_t slot);
QResizeEvent* QResizeEvent_virtualbase_Clone(const void* self);
void QResizeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QResizeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QResizeEvent_Delete(QResizeEvent* self, bool isSubclass);

QCloseEvent* QCloseEvent_new();
void QCloseEvent_virtbase(QCloseEvent* src, QEvent** outptr_QEvent);
QCloseEvent* QCloseEvent_Clone(const QCloseEvent* self);
void QCloseEvent_override_virtual_Clone(void* self, intptr_t slot);
QCloseEvent* QCloseEvent_virtualbase_Clone(const void* self);
void QCloseEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QCloseEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QCloseEvent_Delete(QCloseEvent* self, bool isSubclass);

QIconDragEvent* QIconDragEvent_new();
void QIconDragEvent_virtbase(QIconDragEvent* src, QEvent** outptr_QEvent);
QIconDragEvent* QIconDragEvent_Clone(const QIconDragEvent* self);
void QIconDragEvent_override_virtual_Clone(void* self, intptr_t slot);
QIconDragEvent* QIconDragEvent_virtualbase_Clone(const void* self);
void QIconDragEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QIconDragEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QIconDragEvent_Delete(QIconDragEvent* self, bool isSubclass);

QShowEvent* QShowEvent_new();
void QShowEvent_virtbase(QShowEvent* src, QEvent** outptr_QEvent);
QShowEvent* QShowEvent_Clone(const QShowEvent* self);
void QShowEvent_override_virtual_Clone(void* self, intptr_t slot);
QShowEvent* QShowEvent_virtualbase_Clone(const void* self);
void QShowEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QShowEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QShowEvent_Delete(QShowEvent* self, bool isSubclass);

QHideEvent* QHideEvent_new();
void QHideEvent_virtbase(QHideEvent* src, QEvent** outptr_QEvent);
QHideEvent* QHideEvent_Clone(const QHideEvent* self);
void QHideEvent_override_virtual_Clone(void* self, intptr_t slot);
QHideEvent* QHideEvent_virtualbase_Clone(const void* self);
void QHideEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QHideEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QHideEvent_Delete(QHideEvent* self, bool isSubclass);

QContextMenuEvent* QContextMenuEvent_new(int reason, QPoint* pos, QPoint* globalPos);
QContextMenuEvent* QContextMenuEvent_new2(int reason, QPoint* pos);
QContextMenuEvent* QContextMenuEvent_new3(int reason, QPoint* pos, QPoint* globalPos, int modifiers);
void QContextMenuEvent_virtbase(QContextMenuEvent* src, QInputEvent** outptr_QInputEvent);
QContextMenuEvent* QContextMenuEvent_Clone(const QContextMenuEvent* self);
int QContextMenuEvent_X(const QContextMenuEvent* self);
int QContextMenuEvent_Y(const QContextMenuEvent* self);
int QContextMenuEvent_GlobalX(const QContextMenuEvent* self);
int QContextMenuEvent_GlobalY(const QContextMenuEvent* self);
QPoint* QContextMenuEvent_Pos(const QContextMenuEvent* self);
QPoint* QContextMenuEvent_GlobalPos(const QContextMenuEvent* self);
int QContextMenuEvent_Reason(const QContextMenuEvent* self);
void QContextMenuEvent_override_virtual_Clone(void* self, intptr_t slot);
QContextMenuEvent* QContextMenuEvent_virtualbase_Clone(const void* self);
void QContextMenuEvent_override_virtual_SetTimestamp(void* self, intptr_t slot);
void QContextMenuEvent_virtualbase_SetTimestamp(void* self, unsigned long long timestamp);
void QContextMenuEvent_Delete(QContextMenuEvent* self, bool isSubclass);

QInputMethodEvent* QInputMethodEvent_new();
QInputMethodEvent* QInputMethodEvent_new2(struct miqt_string preeditText, struct miqt_array /* of QInputMethodEvent__Attribute* */  attributes);
void QInputMethodEvent_virtbase(QInputMethodEvent* src, QEvent** outptr_QEvent);
QInputMethodEvent* QInputMethodEvent_Clone(const QInputMethodEvent* self);
void QInputMethodEvent_SetCommitString(QInputMethodEvent* self, struct miqt_string commitString);
struct miqt_array /* of QInputMethodEvent__Attribute* */  QInputMethodEvent_Attributes(const QInputMethodEvent* self);
struct miqt_string QInputMethodEvent_PreeditString(const QInputMethodEvent* self);
struct miqt_string QInputMethodEvent_CommitString(const QInputMethodEvent* self);
int QInputMethodEvent_ReplacementStart(const QInputMethodEvent* self);
int QInputMethodEvent_ReplacementLength(const QInputMethodEvent* self);
void QInputMethodEvent_SetCommitString2(QInputMethodEvent* self, struct miqt_string commitString, int replaceFrom);
void QInputMethodEvent_SetCommitString3(QInputMethodEvent* self, struct miqt_string commitString, int replaceFrom, int replaceLength);
void QInputMethodEvent_override_virtual_Clone(void* self, intptr_t slot);
QInputMethodEvent* QInputMethodEvent_virtualbase_Clone(const void* self);
void QInputMethodEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QInputMethodEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QInputMethodEvent_Delete(QInputMethodEvent* self, bool isSubclass);

QInputMethodQueryEvent* QInputMethodQueryEvent_new(int queries);
void QInputMethodQueryEvent_virtbase(QInputMethodQueryEvent* src, QEvent** outptr_QEvent);
QInputMethodQueryEvent* QInputMethodQueryEvent_Clone(const QInputMethodQueryEvent* self);
int QInputMethodQueryEvent_Queries(const QInputMethodQueryEvent* self);
void QInputMethodQueryEvent_SetValue(QInputMethodQueryEvent* self, int query, QVariant* value);
QVariant* QInputMethodQueryEvent_Value(const QInputMethodQueryEvent* self, int query);
void QInputMethodQueryEvent_override_virtual_Clone(void* self, intptr_t slot);
QInputMethodQueryEvent* QInputMethodQueryEvent_virtualbase_Clone(const void* self);
void QInputMethodQueryEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QInputMethodQueryEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QInputMethodQueryEvent_Delete(QInputMethodQueryEvent* self, bool isSubclass);

QDropEvent* QDropEvent_new(QPointF* pos, int actions, QMimeData* data, int buttons, int modifiers);
QDropEvent* QDropEvent_new2(QPointF* pos, int actions, QMimeData* data, int buttons, int modifiers, int typeVal);
void QDropEvent_virtbase(QDropEvent* src, QEvent** outptr_QEvent);
QDropEvent* QDropEvent_Clone(const QDropEvent* self);
QPoint* QDropEvent_Pos(const QDropEvent* self);
QPointF* QDropEvent_PosF(const QDropEvent* self);
int QDropEvent_MouseButtons(const QDropEvent* self);
int QDropEvent_KeyboardModifiers(const QDropEvent* self);
QPointF* QDropEvent_Position(const QDropEvent* self);
int QDropEvent_Buttons(const QDropEvent* self);
int QDropEvent_Modifiers(const QDropEvent* self);
int QDropEvent_PossibleActions(const QDropEvent* self);
int QDropEvent_ProposedAction(const QDropEvent* self);
void QDropEvent_AcceptProposedAction(QDropEvent* self);
int QDropEvent_DropAction(const QDropEvent* self);
void QDropEvent_SetDropAction(QDropEvent* self, int action);
QObject* QDropEvent_Source(const QDropEvent* self);
QMimeData* QDropEvent_MimeData(const QDropEvent* self);
void QDropEvent_override_virtual_Clone(void* self, intptr_t slot);
QDropEvent* QDropEvent_virtualbase_Clone(const void* self);
void QDropEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QDropEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QDropEvent_Delete(QDropEvent* self, bool isSubclass);

QDragMoveEvent* QDragMoveEvent_new(QPoint* pos, int actions, QMimeData* data, int buttons, int modifiers);
QDragMoveEvent* QDragMoveEvent_new2(QPoint* pos, int actions, QMimeData* data, int buttons, int modifiers, int typeVal);
void QDragMoveEvent_virtbase(QDragMoveEvent* src, QDropEvent** outptr_QDropEvent);
QDragMoveEvent* QDragMoveEvent_Clone(const QDragMoveEvent* self);
QRect* QDragMoveEvent_AnswerRect(const QDragMoveEvent* self);
void QDragMoveEvent_Accept(QDragMoveEvent* self);
void QDragMoveEvent_Ignore(QDragMoveEvent* self);
void QDragMoveEvent_AcceptWithQRect(QDragMoveEvent* self, QRect* r);
void QDragMoveEvent_IgnoreWithQRect(QDragMoveEvent* self, QRect* r);
void QDragMoveEvent_override_virtual_Clone(void* self, intptr_t slot);
QDragMoveEvent* QDragMoveEvent_virtualbase_Clone(const void* self);
void QDragMoveEvent_Delete(QDragMoveEvent* self, bool isSubclass);

QDragEnterEvent* QDragEnterEvent_new(QPoint* pos, int actions, QMimeData* data, int buttons, int modifiers);
void QDragEnterEvent_virtbase(QDragEnterEvent* src, QDragMoveEvent** outptr_QDragMoveEvent);
QDragEnterEvent* QDragEnterEvent_Clone(const QDragEnterEvent* self);
void QDragEnterEvent_override_virtual_Clone(void* self, intptr_t slot);
QDragEnterEvent* QDragEnterEvent_virtualbase_Clone(const void* self);
void QDragEnterEvent_Delete(QDragEnterEvent* self, bool isSubclass);

QDragLeaveEvent* QDragLeaveEvent_new();
void QDragLeaveEvent_virtbase(QDragLeaveEvent* src, QEvent** outptr_QEvent);
QDragLeaveEvent* QDragLeaveEvent_Clone(const QDragLeaveEvent* self);
void QDragLeaveEvent_override_virtual_Clone(void* self, intptr_t slot);
QDragLeaveEvent* QDragLeaveEvent_virtualbase_Clone(const void* self);
void QDragLeaveEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QDragLeaveEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QDragLeaveEvent_Delete(QDragLeaveEvent* self, bool isSubclass);

QHelpEvent* QHelpEvent_new(int typeVal, QPoint* pos, QPoint* globalPos);
void QHelpEvent_virtbase(QHelpEvent* src, QEvent** outptr_QEvent);
QHelpEvent* QHelpEvent_Clone(const QHelpEvent* self);
int QHelpEvent_X(const QHelpEvent* self);
int QHelpEvent_Y(const QHelpEvent* self);
int QHelpEvent_GlobalX(const QHelpEvent* self);
int QHelpEvent_GlobalY(const QHelpEvent* self);
QPoint* QHelpEvent_Pos(const QHelpEvent* self);
QPoint* QHelpEvent_GlobalPos(const QHelpEvent* self);
void QHelpEvent_override_virtual_Clone(void* self, intptr_t slot);
QHelpEvent* QHelpEvent_virtualbase_Clone(const void* self);
void QHelpEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QHelpEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QHelpEvent_Delete(QHelpEvent* self, bool isSubclass);

QStatusTipEvent* QStatusTipEvent_new(struct miqt_string tip);
void QStatusTipEvent_virtbase(QStatusTipEvent* src, QEvent** outptr_QEvent);
QStatusTipEvent* QStatusTipEvent_Clone(const QStatusTipEvent* self);
struct miqt_string QStatusTipEvent_Tip(const QStatusTipEvent* self);
void QStatusTipEvent_override_virtual_Clone(void* self, intptr_t slot);
QStatusTipEvent* QStatusTipEvent_virtualbase_Clone(const void* self);
void QStatusTipEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QStatusTipEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QStatusTipEvent_Delete(QStatusTipEvent* self, bool isSubclass);

QWhatsThisClickedEvent* QWhatsThisClickedEvent_new(struct miqt_string href);
void QWhatsThisClickedEvent_virtbase(QWhatsThisClickedEvent* src, QEvent** outptr_QEvent);
QWhatsThisClickedEvent* QWhatsThisClickedEvent_Clone(const QWhatsThisClickedEvent* self);
struct miqt_string QWhatsThisClickedEvent_Href(const QWhatsThisClickedEvent* self);
void QWhatsThisClickedEvent_override_virtual_Clone(void* self, intptr_t slot);
QWhatsThisClickedEvent* QWhatsThisClickedEvent_virtualbase_Clone(const void* self);
void QWhatsThisClickedEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QWhatsThisClickedEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QWhatsThisClickedEvent_Delete(QWhatsThisClickedEvent* self, bool isSubclass);

QActionEvent* QActionEvent_new(int typeVal, QAction* action);
QActionEvent* QActionEvent_new2(int typeVal, QAction* action, QAction* before);
void QActionEvent_virtbase(QActionEvent* src, QEvent** outptr_QEvent);
QActionEvent* QActionEvent_Clone(const QActionEvent* self);
QAction* QActionEvent_Action(const QActionEvent* self);
QAction* QActionEvent_Before(const QActionEvent* self);
void QActionEvent_override_virtual_Clone(void* self, intptr_t slot);
QActionEvent* QActionEvent_virtualbase_Clone(const void* self);
void QActionEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QActionEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QActionEvent_Delete(QActionEvent* self, bool isSubclass);

QFileOpenEvent* QFileOpenEvent_new(struct miqt_string file);
QFileOpenEvent* QFileOpenEvent_new2(QUrl* url);
void QFileOpenEvent_virtbase(QFileOpenEvent* src, QEvent** outptr_QEvent);
QFileOpenEvent* QFileOpenEvent_Clone(const QFileOpenEvent* self);
struct miqt_string QFileOpenEvent_File(const QFileOpenEvent* self);
QUrl* QFileOpenEvent_Url(const QFileOpenEvent* self);
bool QFileOpenEvent_OpenFile(const QFileOpenEvent* self, QFile* file, int flags);
void QFileOpenEvent_override_virtual_Clone(void* self, intptr_t slot);
QFileOpenEvent* QFileOpenEvent_virtualbase_Clone(const void* self);
void QFileOpenEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QFileOpenEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QFileOpenEvent_Delete(QFileOpenEvent* self, bool isSubclass);

QToolBarChangeEvent* QToolBarChangeEvent_new(bool t);
void QToolBarChangeEvent_virtbase(QToolBarChangeEvent* src, QEvent** outptr_QEvent);
QToolBarChangeEvent* QToolBarChangeEvent_Clone(const QToolBarChangeEvent* self);
bool QToolBarChangeEvent_Toggle(const QToolBarChangeEvent* self);
void QToolBarChangeEvent_override_virtual_Clone(void* self, intptr_t slot);
QToolBarChangeEvent* QToolBarChangeEvent_virtualbase_Clone(const void* self);
void QToolBarChangeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QToolBarChangeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QToolBarChangeEvent_Delete(QToolBarChangeEvent* self, bool isSubclass);

QShortcutEvent* QShortcutEvent_new(QKeySequence* key, int id);
QShortcutEvent* QShortcutEvent_new2(QKeySequence* key, int id, bool ambiguous);
void QShortcutEvent_virtbase(QShortcutEvent* src, QEvent** outptr_QEvent);
QShortcutEvent* QShortcutEvent_Clone(const QShortcutEvent* self);
QKeySequence* QShortcutEvent_Key(const QShortcutEvent* self);
int QShortcutEvent_ShortcutId(const QShortcutEvent* self);
bool QShortcutEvent_IsAmbiguous(const QShortcutEvent* self);
void QShortcutEvent_override_virtual_Clone(void* self, intptr_t slot);
QShortcutEvent* QShortcutEvent_virtualbase_Clone(const void* self);
void QShortcutEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QShortcutEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QShortcutEvent_Delete(QShortcutEvent* self, bool isSubclass);

QWindowStateChangeEvent* QWindowStateChangeEvent_new(int oldState);
QWindowStateChangeEvent* QWindowStateChangeEvent_new2(int oldState, bool isOverride);
void QWindowStateChangeEvent_virtbase(QWindowStateChangeEvent* src, QEvent** outptr_QEvent);
QWindowStateChangeEvent* QWindowStateChangeEvent_Clone(const QWindowStateChangeEvent* self);
int QWindowStateChangeEvent_OldState(const QWindowStateChangeEvent* self);
bool QWindowStateChangeEvent_IsOverride(const QWindowStateChangeEvent* self);
void QWindowStateChangeEvent_override_virtual_Clone(void* self, intptr_t slot);
QWindowStateChangeEvent* QWindowStateChangeEvent_virtualbase_Clone(const void* self);
void QWindowStateChangeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QWindowStateChangeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QWindowStateChangeEvent_Delete(QWindowStateChangeEvent* self, bool isSubclass);

QTouchEvent* QTouchEvent_new(int eventType);
QTouchEvent* QTouchEvent_new2(int eventType, QPointingDevice* device, int modifiers, uint8_t touchPointStates);
QTouchEvent* QTouchEvent_new3(int eventType, QPointingDevice* device);
QTouchEvent* QTouchEvent_new4(int eventType, QPointingDevice* device, int modifiers);
QTouchEvent* QTouchEvent_new5(int eventType, QPointingDevice* device, int modifiers, struct miqt_array /* of QEventPoint* */  touchPoints);
QTouchEvent* QTouchEvent_new6(int eventType, QPointingDevice* device, int modifiers, uint8_t touchPointStates, struct miqt_array /* of QEventPoint* */  touchPoints);
void QTouchEvent_virtbase(QTouchEvent* src, QPointerEvent** outptr_QPointerEvent);
QTouchEvent* QTouchEvent_Clone(const QTouchEvent* self);
QObject* QTouchEvent_Target(const QTouchEvent* self);
uint8_t QTouchEvent_TouchPointStates(const QTouchEvent* self);
struct miqt_array /* of QEventPoint* */  QTouchEvent_TouchPoints(const QTouchEvent* self);
bool QTouchEvent_IsBeginEvent(const QTouchEvent* self);
bool QTouchEvent_IsUpdateEvent(const QTouchEvent* self);
bool QTouchEvent_IsEndEvent(const QTouchEvent* self);
void QTouchEvent_override_virtual_Clone(void* self, intptr_t slot);
QTouchEvent* QTouchEvent_virtualbase_Clone(const void* self);
void QTouchEvent_override_virtual_IsBeginEvent(void* self, intptr_t slot);
bool QTouchEvent_virtualbase_IsBeginEvent(const void* self);
void QTouchEvent_override_virtual_IsUpdateEvent(void* self, intptr_t slot);
bool QTouchEvent_virtualbase_IsUpdateEvent(const void* self);
void QTouchEvent_override_virtual_IsEndEvent(void* self, intptr_t slot);
bool QTouchEvent_virtualbase_IsEndEvent(const void* self);
void QTouchEvent_override_virtual_SetTimestamp(void* self, intptr_t slot);
void QTouchEvent_virtualbase_SetTimestamp(void* self, unsigned long long timestamp);
void QTouchEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QTouchEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QTouchEvent_Delete(QTouchEvent* self, bool isSubclass);

QScrollPrepareEvent* QScrollPrepareEvent_new(QPointF* startPos);
void QScrollPrepareEvent_virtbase(QScrollPrepareEvent* src, QEvent** outptr_QEvent);
QScrollPrepareEvent* QScrollPrepareEvent_Clone(const QScrollPrepareEvent* self);
QPointF* QScrollPrepareEvent_StartPos(const QScrollPrepareEvent* self);
QSizeF* QScrollPrepareEvent_ViewportSize(const QScrollPrepareEvent* self);
QRectF* QScrollPrepareEvent_ContentPosRange(const QScrollPrepareEvent* self);
QPointF* QScrollPrepareEvent_ContentPos(const QScrollPrepareEvent* self);
void QScrollPrepareEvent_SetViewportSize(QScrollPrepareEvent* self, QSizeF* size);
void QScrollPrepareEvent_SetContentPosRange(QScrollPrepareEvent* self, QRectF* rect);
void QScrollPrepareEvent_SetContentPos(QScrollPrepareEvent* self, QPointF* pos);
void QScrollPrepareEvent_override_virtual_Clone(void* self, intptr_t slot);
QScrollPrepareEvent* QScrollPrepareEvent_virtualbase_Clone(const void* self);
void QScrollPrepareEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QScrollPrepareEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QScrollPrepareEvent_Delete(QScrollPrepareEvent* self, bool isSubclass);

QScrollEvent* QScrollEvent_new(QPointF* contentPos, QPointF* overshoot, int scrollState);
void QScrollEvent_virtbase(QScrollEvent* src, QEvent** outptr_QEvent);
QScrollEvent* QScrollEvent_Clone(const QScrollEvent* self);
QPointF* QScrollEvent_ContentPos(const QScrollEvent* self);
QPointF* QScrollEvent_OvershootDistance(const QScrollEvent* self);
int QScrollEvent_ScrollState(const QScrollEvent* self);
void QScrollEvent_override_virtual_Clone(void* self, intptr_t slot);
QScrollEvent* QScrollEvent_virtualbase_Clone(const void* self);
void QScrollEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QScrollEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QScrollEvent_Delete(QScrollEvent* self, bool isSubclass);

QScreenOrientationChangeEvent* QScreenOrientationChangeEvent_new(QScreen* screen, int orientation);
void QScreenOrientationChangeEvent_virtbase(QScreenOrientationChangeEvent* src, QEvent** outptr_QEvent);
QScreenOrientationChangeEvent* QScreenOrientationChangeEvent_Clone(const QScreenOrientationChangeEvent* self);
QScreen* QScreenOrientationChangeEvent_Screen(const QScreenOrientationChangeEvent* self);
int QScreenOrientationChangeEvent_Orientation(const QScreenOrientationChangeEvent* self);
void QScreenOrientationChangeEvent_override_virtual_Clone(void* self, intptr_t slot);
QScreenOrientationChangeEvent* QScreenOrientationChangeEvent_virtualbase_Clone(const void* self);
void QScreenOrientationChangeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QScreenOrientationChangeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QScreenOrientationChangeEvent_Delete(QScreenOrientationChangeEvent* self, bool isSubclass);

QApplicationStateChangeEvent* QApplicationStateChangeEvent_new(int state);
void QApplicationStateChangeEvent_virtbase(QApplicationStateChangeEvent* src, QEvent** outptr_QEvent);
QApplicationStateChangeEvent* QApplicationStateChangeEvent_Clone(const QApplicationStateChangeEvent* self);
int QApplicationStateChangeEvent_ApplicationState(const QApplicationStateChangeEvent* self);
void QApplicationStateChangeEvent_override_virtual_Clone(void* self, intptr_t slot);
QApplicationStateChangeEvent* QApplicationStateChangeEvent_virtualbase_Clone(const void* self);
void QApplicationStateChangeEvent_override_virtual_SetAccepted(void* self, intptr_t slot);
void QApplicationStateChangeEvent_virtualbase_SetAccepted(void* self, bool accepted);
void QApplicationStateChangeEvent_Delete(QApplicationStateChangeEvent* self, bool isSubclass);

QInputMethodEvent__Attribute* QInputMethodEvent__Attribute_new(int typ, int s, int l, QVariant* val);
QInputMethodEvent__Attribute* QInputMethodEvent__Attribute_new2(int typ, int s, int l);
QInputMethodEvent__Attribute* QInputMethodEvent__Attribute_new3(QInputMethodEvent__Attribute* param1);
void QInputMethodEvent__Attribute_OperatorAssign(QInputMethodEvent__Attribute* self, QInputMethodEvent__Attribute* param1);
void QInputMethodEvent__Attribute_Delete(QInputMethodEvent__Attribute* self, bool isSubclass);

#ifdef __cplusplus
} /* extern C */
#endif 

#endif