/****************************************************************************
** Meta object code from reading C++ file 'timelinecontroller.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../kdenlive-26.04.1/src/timeline2/view/timelinecontroller.h"
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'timelinecontroller.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN18TimelineControllerE_t {};
} // unnamed namespace

template <> constexpr inline auto TimelineController::qt_create_metaobjectdata<qt_meta_tag_ZN18TimelineControllerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "TimelineController",
        "audioZoomTextChanged",
        "",
        "selectionChanged",
        "selectedMixChanged",
        "frameFormatChanged",
        "trackHeightChanged",
        "scaleFactorChanged",
        "durationChanged",
        "duration",
        "audioTargetChanged",
        "videoTargetChanged",
        "hasAudioTargetChanged",
        "hasVideoTargetChanged",
        "lastAudioTargetChanged",
        "autoScrollChanged",
        "lastVideoTargetChanged",
        "timelineMouseOffsetChanged",
        "activeTrackChanged",
        "activeSubLayerChanged",
        "colorsChanged",
        "trimmingMainClipChanged",
        "rippleChanged",
        "scrubChanged",
        "subtitlesWarningChanged",
        "multicamInChanged",
        "autotrackHeightChanged",
        "seeked",
        "position",
        "zoneChanged",
        "subtitlesListChanged",
        "maxSubLayerChanged",
        "zoneMoved",
        "QPoint",
        "zone",
        "showTransitionModel",
        "tid",
        "std::shared_ptr<AssetParameterModel>",
        "showMixModel",
        "cid",
        "asset",
        "refreshOnly",
        "showItemEffectStack",
        "clipName",
        "std::shared_ptr<EffectStackModel>",
        "QSize",
        "frameSize",
        "showKeyframes",
        "showSubtitle",
        "id",
        "dirtyChunksChanged",
        "renderedChunksChanged",
        "workingPreviewChanged",
        "subtitlesDisabledChanged",
        "subtitlesLockedChanged",
        "useRulerChanged",
        "updateZoom",
        "timelineClipSelected",
        "centerView",
        "effectZoneChanged",
        "masterZonesChanged",
        "ungrabHack",
        "regainFocus",
        "updateAssetPosition",
        "itemId",
        "QUuid",
        "uuid",
        "stopAudioRecord",
        "activeSubtitlePositionChanged",
        "timecodeOffsetChanged",
        "updateClipActions",
        "resetView",
        "setAudioTarget",
        "QMap<int,int>",
        "tracks",
        "switchAudioTarget",
        "trackId",
        "setVideoTarget",
        "track",
        "setActiveTrack",
        "addEffectToCurrentClip",
        "effectData",
        "disablePreview",
        "disable",
        "invalidateItem",
        "invalidateTrack",
        "invalidateMix",
        "ObjectId",
        "owner",
        "checkDuration",
        "slotMultitrackView",
        "enable",
        "refresh",
        "activateTrackAndSelect",
        "trackPosition",
        "notesMode",
        "saveTimelineSelection",
        "QDir",
        "targetDir",
        "setScrollPos",
        "pos",
        "resizeMix",
        "MixAlignment",
        "align",
        "leftFrames",
        "updateZone",
        "oldZone",
        "newZone",
        "withUndo",
        "updateEffectZone",
        "updateTrimmingMode",
        "checkClipPosition",
        "QModelIndex",
        "topLeft",
        "QList<int>",
        "roles",
        "autofitTrackHeight",
        "timelineHeight",
        "collapsedHeight",
        "subtitlesMenuActivatedAsync",
        "ix",
        "subtitlesMenuActivated",
        "switchFocusClip",
        "enableBuildInTransform",
        "showSubtitleManager",
        "page",
        "setTimelineMouseOffset",
        "offset",
        "updateVideoTarget",
        "updateAudioTarget",
        "updateMultiTrack",
        "slotFlashLock",
        "initializePreview",
        "loadSubtitleIndex",
        "editItemDuration",
        "editTitleClip",
        "focusTimelineSequence",
        "editAnimationClip",
        "selectedTrack",
        "selectItems",
        "QVariantList",
        "startFrame",
        "endFrame",
        "addToSelect",
        "selectBottomCompositions",
        "selectSubTitles",
        "ids",
        "isInSelection",
        "switchRecording",
        "record",
        "getActionShortcut",
        "actionName",
        "showConfig",
        "tab",
        "hasActiveTracks",
        "audioZoomText",
        "scaleFactor",
        "fullDuration",
        "audioTarget",
        "lastAudioTarget",
        "keepAudioTargets",
        "keep",
        "audioTargetName",
        "videoTarget",
        "hasAudioTarget",
        "clipTargets",
        "hasVideoTarget",
        "activeTrack",
        "trimmingMainClip",
        "videoColor",
        "QColor",
        "audioColor",
        "titleColor",
        "imageColor",
        "slideshowColor",
        "targetColor",
        "targetTextColor",
        "lockedColor",
        "selectionColor",
        "groupColor",
        "doubleClickInterval",
        "showToolTip",
        "info",
        "showKeyBinding",
        "showTimelineToolInfo",
        "show",
        "subtitlesList",
        "subtitlesWarningDetails",
        "setPosition",
        "ripple",
        "scrub",
        "timecode",
        "frames",
        "simplifiedTC",
        "insertClip",
        "xml",
        "logUndo",
        "refreshView",
        "useTargets",
        "insertClips",
        "binIds",
        "copyItem",
        "pasteItem",
        "insertComposition",
        "transitionId",
        "insertNewMix",
        "isOnCut",
        "insertNewCompositionAtPos",
        "insertNewComposition",
        "clipId",
        "deleteSelectedClips",
        "triggerAction",
        "name",
        "actionText",
        "beginAddTrack",
        "deleteMultipleTracks",
        "groupSelection",
        "unGroupSelection",
        "editMarker",
        "addMarker",
        "addQuickMarker",
        "deleteMarker",
        "resizeMarker",
        "isStart",
        "newPosition",
        "deleteAllMarkers",
        "editGuide",
        "frame",
        "moveGuideById",
        "newFrame",
        "moveGuideWithoutUndo",
        "mid",
        "pauseGuideSorting",
        "pause",
        "resizeGuide",
        "suggestSnapPoint",
        "snapDistance",
        "createRangeMarkerFromZone",
        "comment",
        "type",
        "moveGuidesInRange",
        "start",
        "end",
        "Fun&",
        "undo",
        "redo",
        "switchGuide",
        "deleteOnly",
        "showGui",
        "requestRefresh",
        "showAsset",
        "showTrackAsset",
        "adjustTrackHeight",
        "height",
        "adjustAllTrackHeight",
        "collapseAllTrackHeight",
        "collapse",
        "defaultTrackHeight",
        "exists",
        "headerWidth",
        "setHeaderWidth",
        "width",
        "hideTrack",
        "hide",
        "allTracks",
        "cutClipUnderCursor",
        "subLayer",
        "cutAllClipsUnderCursor",
        "requestSpacerStartOperation",
        "spacerMinPos",
        "spacerMaxPos",
        "spacerSelection",
        "spacerMoveGuides",
        "getGuidePosition",
        "requestSpacerEndOperation",
        "startPosition",
        "endPosition",
        "affectedTrack",
        "selectedGuides",
        "guideStart",
        "adjustFade",
        "effectId",
        "initialDuration",
        "getTrackNameFromMltIndex",
        "trackPos",
        "insertSpace",
        "removeSpace",
        "affectAllTracks",
        "switchEnableState",
        "std::unordered_set<int>",
        "selection",
        "addCompositionToClip",
        "assetId",
        "addEffectToClip",
        "setEffectsEnabled",
        "enabled",
        "requestClipCut",
        "setAudioRef",
        "alignAudio",
        "setTimecodeRef",
        "alignTimecode",
        "urlDropped",
        "droppedFile",
        "endFakeMove",
        "updateView",
        "invalidateTimeline",
        "getItemMovingTrack",
        "pasteEffects",
        "targetId",
        "deleteEffects",
        "fps",
        "addEffectKeyframe",
        "val",
        "removeEffectKeyframe",
        "updateEffectKeyframe",
        "oldFrame",
        "QVariant",
        "normalizedValue",
        "hasKeyframeAt",
        "switchTrackActive",
        "getAvTracksCount",
        "std::pair<int,int>",
        "getMousePosInTimeline",
        "warpCursor",
        "hideCursor",
        "getMousePos",
        "getMouseTrack",
        "getFreeSpace",
        "requestStartTrimmingMode",
        "addToSelection",
        "right",
        "requestEndTrimmingMode",
        "slipPosChanged",
        "ripplePosChanged",
        "requestItemRippleResize",
        "size",
        "allowSingleResize",
        "changeItemSpeed",
        "speed",
        "insertClipZone",
        "binId",
        "getAssetName",
        "isTransition",
        "grabCurrent",
        "showMasterEffects",
        "mixClip",
        "delta",
        "selectedMix",
        "zoneIn",
        "zoneOut",
        "dirtyChunks",
        "renderedChunks",
        "masterEffectZones",
        "workingPreview",
        "useRuler",
        "activeSubLayer",
        "maxSubLayer",
        "lastVideoTarget",
        "autoScroll",
        "subtitlesWarning",
        "subtitlesDisabled",
        "subtitlesLocked",
        "activeSubPosition",
        "autotrackHeight",
        "effectZone",
        "multicamIn",
        "timecodeOffset"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'audioZoomTextChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectionChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedMixChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'frameFormatChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'trackHeightChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'scaleFactorChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'durationChanged'
        QtMocHelpers::SignalData<void(int)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 },
        }}),
        // Signal 'audioTargetChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'videoTargetChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasAudioTargetChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasVideoTargetChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastAudioTargetChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'autoScrollChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastVideoTargetChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'timelineMouseOffsetChanged'
        QtMocHelpers::SignalData<void(int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'activeTrackChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeSubLayerChanged'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'colorsChanged'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'trimmingMainClipChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rippleChanged'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'scrubChanged'
        QtMocHelpers::SignalData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'subtitlesWarningChanged'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'multicamInChanged'
        QtMocHelpers::SignalData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'autotrackHeightChanged'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'seeked'
        QtMocHelpers::SignalData<void(int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 },
        }}),
        // Signal 'zoneChanged'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'subtitlesListChanged'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'maxSubLayerChanged'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'zoneMoved'
        QtMocHelpers::SignalData<void(const QPoint &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Signal 'showTransitionModel'
        QtMocHelpers::SignalData<void(int, std::shared_ptr<AssetParameterModel>)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { 0x80000000 | 37, 2 },
        }}),
        // Signal 'showMixModel'
        QtMocHelpers::SignalData<void(int, const std::shared_ptr<AssetParameterModel> &, bool)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { 0x80000000 | 37, 40 }, { QMetaType::Bool, 41 },
        }}),
        // Signal 'showItemEffectStack'
        QtMocHelpers::SignalData<void(const QString &, std::shared_ptr<EffectStackModel>, QSize, bool)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 43 }, { 0x80000000 | 44, 2 }, { 0x80000000 | 45, 46 }, { QMetaType::Bool, 47 },
        }}),
        // Signal 'showSubtitle'
        QtMocHelpers::SignalData<void(int)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Signal 'dirtyChunksChanged'
        QtMocHelpers::SignalData<void()>(50, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'renderedChunksChanged'
        QtMocHelpers::SignalData<void()>(51, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'workingPreviewChanged'
        QtMocHelpers::SignalData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'subtitlesDisabledChanged'
        QtMocHelpers::SignalData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'subtitlesLockedChanged'
        QtMocHelpers::SignalData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'useRulerChanged'
        QtMocHelpers::SignalData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateZoom'
        QtMocHelpers::SignalData<void(double)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 2 },
        }}),
        // Signal 'timelineClipSelected'
        QtMocHelpers::SignalData<void(bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'centerView'
        QtMocHelpers::SignalData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'effectZoneChanged'
        QtMocHelpers::SignalData<void()>(59, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'masterZonesChanged'
        QtMocHelpers::SignalData<void()>(60, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ungrabHack'
        QtMocHelpers::SignalData<void()>(61, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'regainFocus'
        QtMocHelpers::SignalData<void()>(62, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateAssetPosition'
        QtMocHelpers::SignalData<void(int, const QUuid)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 64 }, { 0x80000000 | 65, 66 },
        }}),
        // Signal 'stopAudioRecord'
        QtMocHelpers::SignalData<void()>(67, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeSubtitlePositionChanged'
        QtMocHelpers::SignalData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'timecodeOffsetChanged'
        QtMocHelpers::SignalData<void()>(69, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateClipActions'
        QtMocHelpers::SlotData<void()>(70, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetView'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setAudioTarget'
        QtMocHelpers::SlotData<void(const QMap<int,int> &)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 74 },
        }}),
        // Slot 'switchAudioTarget'
        QtMocHelpers::SlotData<void(int)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Slot 'setVideoTarget'
        QtMocHelpers::SlotData<void(int)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 78 },
        }}),
        // Slot 'setActiveTrack'
        QtMocHelpers::SlotData<void(int)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 78 },
        }}),
        // Slot 'addEffectToCurrentClip'
        QtMocHelpers::SlotData<void(const QStringList &)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 81 },
        }}),
        // Slot 'disablePreview'
        QtMocHelpers::SlotData<void(bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 83 },
        }}),
        // Slot 'invalidateItem'
        QtMocHelpers::SlotData<void(int)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Slot 'invalidateTrack'
        QtMocHelpers::SlotData<void(int)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 },
        }}),
        // Slot 'invalidateMix'
        QtMocHelpers::SlotData<void(ObjectId)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 87, 88 },
        }}),
        // Slot 'checkDuration'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotMultitrackView'
        QtMocHelpers::SlotData<void(bool, bool)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 91 }, { QMetaType::Bool, 92 },
        }}),
        // Slot 'slotMultitrackView'
        QtMocHelpers::SlotData<void(bool)>(90, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 91 },
        }}),
        // Slot 'slotMultitrackView'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'activateTrackAndSelect'
        QtMocHelpers::SlotData<void(int, bool)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 94 }, { QMetaType::Bool, 95 },
        }}),
        // Slot 'activateTrackAndSelect'
        QtMocHelpers::SlotData<void(int)>(93, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 94 },
        }}),
        // Slot 'saveTimelineSelection'
        QtMocHelpers::SlotData<void(const QDir &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 97, 98 },
        }}),
        // Slot 'setScrollPos'
        QtMocHelpers::SlotData<void(int)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 100 },
        }}),
        // Slot 'resizeMix'
        QtMocHelpers::SlotData<void(int, int, MixAlignment, int)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 9 }, { 0x80000000 | 102, 103 }, { QMetaType::Int, 104 },
        }}),
        // Slot 'resizeMix'
        QtMocHelpers::SlotData<void(int, int, MixAlignment)>(101, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 9 }, { 0x80000000 | 102, 103 },
        }}),
        // Slot 'updateZone'
        QtMocHelpers::SlotData<void(const QPoint, const QPoint, bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 106 }, { 0x80000000 | 33, 107 }, { QMetaType::Bool, 108 },
        }}),
        // Slot 'updateZone'
        QtMocHelpers::SlotData<void(const QPoint, const QPoint)>(105, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 33, 106 }, { 0x80000000 | 33, 107 },
        }}),
        // Slot 'updateEffectZone'
        QtMocHelpers::SlotData<void(const QPoint, const QPoint, bool)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 106 }, { 0x80000000 | 33, 107 }, { QMetaType::Bool, 108 },
        }}),
        // Slot 'updateEffectZone'
        QtMocHelpers::SlotData<void(const QPoint, const QPoint)>(109, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 33, 106 }, { 0x80000000 | 33, 107 },
        }}),
        // Slot 'updateTrimmingMode'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkClipPosition'
        QtMocHelpers::SlotData<void(const QModelIndex &, const QModelIndex &, const QVector<int> &)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 112, 113 }, { 0x80000000 | 112, 2 }, { 0x80000000 | 114, 115 },
        }}),
        // Slot 'autofitTrackHeight'
        QtMocHelpers::SlotData<void(int, int)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 117 }, { QMetaType::Int, 118 },
        }}),
        // Slot 'subtitlesMenuActivatedAsync'
        QtMocHelpers::SlotData<void(int)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 120 },
        }}),
        // Slot 'subtitlesMenuActivated'
        QtMocHelpers::SlotData<void(int)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 120 },
        }}),
        // Slot 'switchFocusClip'
        QtMocHelpers::SlotData<void()>(122, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'enableBuildInTransform'
        QtMocHelpers::SlotData<void()>(123, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showSubtitleManager'
        QtMocHelpers::SlotData<void(int)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 125 },
        }}),
        // Slot 'showSubtitleManager'
        QtMocHelpers::SlotData<void()>(124, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setTimelineMouseOffset'
        QtMocHelpers::SlotData<void(int)>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 127 },
        }}),
        // Slot 'updateVideoTarget'
        QtMocHelpers::SlotData<void()>(128, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateAudioTarget'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateMultiTrack'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotFlashLock'
        QtMocHelpers::SlotData<void(int)>(131, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Slot 'initializePreview'
        QtMocHelpers::SlotData<void()>(132, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'loadSubtitleIndex'
        QtMocHelpers::SlotData<void()>(133, 2, QMC::AccessPrivate, QMetaType::Void),
        // Method 'editItemDuration'
        QtMocHelpers::MethodData<void()>(134, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'editTitleClip'
        QtMocHelpers::MethodData<void(int)>(135, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 64 },
        }}),
        // Method 'editTitleClip'
        QtMocHelpers::MethodData<void()>(135, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'focusTimelineSequence'
        QtMocHelpers::MethodData<void(int)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Method 'editAnimationClip'
        QtMocHelpers::MethodData<void(int)>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 64 },
        }}),
        // Method 'editAnimationClip'
        QtMocHelpers::MethodData<void()>(137, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'selectedTrack'
        QtMocHelpers::MethodData<int() const>(138, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'selectItems'
        QtMocHelpers::MethodData<void(const QVariantList &, int, int, bool, bool, bool)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 140, 74 }, { QMetaType::Int, 141 }, { QMetaType::Int, 142 }, { QMetaType::Bool, 143 },
            { QMetaType::Bool, 144 }, { QMetaType::Bool, 145 },
        }}),
        // Method 'selectItems'
        QtMocHelpers::MethodData<void(const QList<int> &)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 114, 146 },
        }}),
        // Method 'isInSelection'
        QtMocHelpers::MethodData<bool(int)>(147, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 64 },
        }}),
        // Method 'switchRecording'
        QtMocHelpers::MethodData<void(int, bool)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Bool, 149 },
        }}),
        // Method 'switchRecording'
        QtMocHelpers::MethodData<void(int)>(148, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'switchRecording'
        QtMocHelpers::MethodData<void()>(148, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'getActionShortcut'
        QtMocHelpers::MethodData<const QString(const QString)>(150, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 151 },
        }}),
        // Method 'showConfig'
        QtMocHelpers::MethodData<void(int, int)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 125 }, { QMetaType::Int, 153 },
        }}),
        // Method 'hasActiveTracks'
        QtMocHelpers::MethodData<bool() const>(154, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'audioZoomText'
        QtMocHelpers::MethodData<QString() const>(155, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'scaleFactor'
        QtMocHelpers::MethodData<double() const>(156, 2, QMC::AccessPublic, QMetaType::Double),
        // Method 'duration'
        QtMocHelpers::MethodData<int() const>(9, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'fullDuration'
        QtMocHelpers::MethodData<int() const>(157, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'audioTarget'
        QtMocHelpers::MethodData<QVariantList() const>(158, 2, QMC::AccessPublic, 0x80000000 | 140),
        // Method 'lastAudioTarget'
        QtMocHelpers::MethodData<QVariantList() const>(159, 2, QMC::AccessPublic, 0x80000000 | 140),
        // Method 'keepAudioTargets'
        QtMocHelpers::MethodData<void(bool)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 161 },
        }}),
        // Method 'audioTargetName'
        QtMocHelpers::MethodData<const QString(int) const>(162, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 36 },
        }}),
        // Method 'videoTarget'
        QtMocHelpers::MethodData<int() const>(163, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'hasAudioTarget'
        QtMocHelpers::MethodData<int() const>(164, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'clipTargets'
        QtMocHelpers::MethodData<int() const>(165, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'hasVideoTarget'
        QtMocHelpers::MethodData<bool() const>(166, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'activeTrack'
        QtMocHelpers::MethodData<int() const>(167, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'trimmingMainClip'
        QtMocHelpers::MethodData<int() const>(168, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'videoColor'
        QtMocHelpers::MethodData<QColor() const>(169, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'audioColor'
        QtMocHelpers::MethodData<QColor() const>(171, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'titleColor'
        QtMocHelpers::MethodData<QColor() const>(172, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'imageColor'
        QtMocHelpers::MethodData<QColor() const>(173, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'slideshowColor'
        QtMocHelpers::MethodData<QColor() const>(174, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'targetColor'
        QtMocHelpers::MethodData<QColor() const>(175, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'targetTextColor'
        QtMocHelpers::MethodData<QColor() const>(176, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'lockedColor'
        QtMocHelpers::MethodData<QColor() const>(177, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'selectionColor'
        QtMocHelpers::MethodData<QColor() const>(178, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'groupColor'
        QtMocHelpers::MethodData<QColor() const>(179, 2, QMC::AccessPublic, 0x80000000 | 170),
        // Method 'doubleClickInterval'
        QtMocHelpers::MethodData<int() const>(180, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'showToolTip'
        QtMocHelpers::MethodData<void(const QString &) const>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 182 },
        }}),
        // Method 'showToolTip'
        QtMocHelpers::MethodData<void() const>(181, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'showKeyBinding'
        QtMocHelpers::MethodData<void(const QString &) const>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 182 },
        }}),
        // Method 'showKeyBinding'
        QtMocHelpers::MethodData<void() const>(183, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'showTimelineToolInfo'
        QtMocHelpers::MethodData<void(bool) const>(184, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 185 },
        }}),
        // Method 'subtitlesList'
        QtMocHelpers::MethodData<QVariantList() const>(186, 2, QMC::AccessPublic, 0x80000000 | 140),
        // Method 'subtitlesWarningDetails'
        QtMocHelpers::MethodData<void()>(187, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'setPosition'
        QtMocHelpers::MethodData<void(int)>(188, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 },
        }}),
        // Method 'ripple'
        QtMocHelpers::MethodData<bool()>(189, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'scrub'
        QtMocHelpers::MethodData<bool()>(190, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'timecode'
        QtMocHelpers::MethodData<QString(int) const>(191, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 192 },
        }}),
        // Method 'simplifiedTC'
        QtMocHelpers::MethodData<QString(int) const>(193, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 192 },
        }}),
        // Method 'insertClip'
        QtMocHelpers::MethodData<int(int, int, const QString &, bool, bool, bool)>(194, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QString, 195 }, { QMetaType::Bool, 196 },
            { QMetaType::Bool, 197 }, { QMetaType::Bool, 198 },
        }}),
        // Method 'insertClips'
        QtMocHelpers::MethodData<QList<int>(int, int, const QStringList &, bool, bool)>(199, 2, QMC::AccessPublic, 0x80000000 | 114, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QStringList, 200 }, { QMetaType::Bool, 196 },
            { QMetaType::Bool, 197 },
        }}),
        // Method 'copyItem'
        QtMocHelpers::MethodData<int()>(201, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'pasteItem'
        QtMocHelpers::MethodData<bool(int, int)>(202, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 36 },
        }}),
        // Method 'pasteItem'
        QtMocHelpers::MethodData<bool(int)>(202, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 28 },
        }}),
        // Method 'pasteItem'
        QtMocHelpers::MethodData<bool()>(202, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Method 'insertComposition'
        QtMocHelpers::MethodData<int(int, int, QString, bool, int)>(203, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QString, 204 }, { QMetaType::Bool, 196 },
            { QMetaType::Int, 9 },
        }}),
        // Method 'insertComposition'
        QtMocHelpers::MethodData<int(int, int, QString, bool)>(203, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QString, 204 }, { QMetaType::Bool, 196 },
        }}),
        // Method 'insertNewMix'
        QtMocHelpers::MethodData<void(int, int, const QString &)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QString, 204 },
        }}),
        // Method 'isOnCut'
        QtMocHelpers::MethodData<int(int) const>(206, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'insertNewCompositionAtPos'
        QtMocHelpers::MethodData<int(int, int, const QString &)>(207, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 }, { QMetaType::QString, 204 },
        }}),
        // Method 'insertNewComposition'
        QtMocHelpers::MethodData<int(int, int, int, QString, bool)>(208, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 209 }, { QMetaType::Int, 127 }, { QMetaType::QString, 204 },
            { QMetaType::Bool, 196 },
        }}),
        // Method 'deleteSelectedClips'
        QtMocHelpers::MethodData<void()>(210, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'triggerAction'
        QtMocHelpers::MethodData<void(const QString &)>(211, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 212 },
        }}),
        // Method 'actionText'
        QtMocHelpers::MethodData<const QString(const QString &)>(213, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 212 },
        }}),
        // Method 'beginAddTrack'
        QtMocHelpers::MethodData<void(int)>(214, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 },
        }}),
        // Method 'deleteMultipleTracks'
        QtMocHelpers::MethodData<void(int)>(215, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 },
        }}),
        // Method 'groupSelection'
        QtMocHelpers::MethodData<void()>(216, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'unGroupSelection'
        QtMocHelpers::MethodData<void(int)>(217, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'unGroupSelection'
        QtMocHelpers::MethodData<void()>(217, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'editMarker'
        QtMocHelpers::MethodData<void(int, int)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 },
        }}),
        // Method 'editMarker'
        QtMocHelpers::MethodData<void(int)>(218, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'editMarker'
        QtMocHelpers::MethodData<void()>(218, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'addMarker'
        QtMocHelpers::MethodData<void(int, int)>(219, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 },
        }}),
        // Method 'addMarker'
        QtMocHelpers::MethodData<void(int)>(219, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'addMarker'
        QtMocHelpers::MethodData<void()>(219, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'addQuickMarker'
        QtMocHelpers::MethodData<void(int, int)>(220, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 },
        }}),
        // Method 'addQuickMarker'
        QtMocHelpers::MethodData<void(int)>(220, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'addQuickMarker'
        QtMocHelpers::MethodData<void()>(220, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'deleteMarker'
        QtMocHelpers::MethodData<void(int, int)>(221, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 },
        }}),
        // Method 'deleteMarker'
        QtMocHelpers::MethodData<void(int)>(221, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'deleteMarker'
        QtMocHelpers::MethodData<void()>(221, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'resizeMarker'
        QtMocHelpers::MethodData<void(int, int, int, bool, int)>(222, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 }, { QMetaType::Int, 9 }, { QMetaType::Bool, 223 },
            { QMetaType::Int, 224 },
        }}),
        // Method 'resizeMarker'
        QtMocHelpers::MethodData<void(int, int, int, bool)>(222, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 }, { QMetaType::Int, 9 }, { QMetaType::Bool, 223 },
        }}),
        // Method 'resizeMarker'
        QtMocHelpers::MethodData<void(int, int, int)>(222, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 28 }, { QMetaType::Int, 9 },
        }}),
        // Method 'deleteAllMarkers'
        QtMocHelpers::MethodData<void(int)>(225, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'deleteAllMarkers'
        QtMocHelpers::MethodData<void()>(225, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'editGuide'
        QtMocHelpers::MethodData<void(int)>(226, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 227 },
        }}),
        // Method 'editGuide'
        QtMocHelpers::MethodData<void()>(226, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'moveGuideById'
        QtMocHelpers::MethodData<void(int, int)>(228, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 229 },
        }}),
        // Method 'moveGuideWithoutUndo'
        QtMocHelpers::MethodData<int(int, int)>(230, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 231 }, { QMetaType::Int, 229 },
        }}),
        // Method 'pauseGuideSorting'
        QtMocHelpers::MethodData<void(bool)>(232, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 233 },
        }}),
        // Method 'resizeGuide'
        QtMocHelpers::MethodData<void(int, int, bool, int)>(234, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 9 }, { QMetaType::Bool, 223 }, { QMetaType::Int, 224 },
        }}),
        // Method 'resizeGuide'
        QtMocHelpers::MethodData<void(int, int, bool)>(234, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 9 }, { QMetaType::Bool, 223 },
        }}),
        // Method 'resizeGuide'
        QtMocHelpers::MethodData<void(int, int)>(234, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 9 },
        }}),
        // Method 'suggestSnapPoint'
        QtMocHelpers::MethodData<int(int, int)>(235, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 236 },
        }}),
        // Method 'createRangeMarkerFromZone'
        QtMocHelpers::MethodData<bool(const QString &, int)>(237, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 238 }, { QMetaType::Int, 239 },
        }}),
        // Method 'createRangeMarkerFromZone'
        QtMocHelpers::MethodData<bool(const QString &)>(237, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 238 },
        }}),
        // Method 'createRangeMarkerFromZone'
        QtMocHelpers::MethodData<bool()>(237, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Method 'moveGuidesInRange'
        QtMocHelpers::MethodData<bool(int, int, int)>(240, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 241 }, { QMetaType::Int, 242 }, { QMetaType::Int, 127 },
        }}),
        // Method 'moveGuidesInRange'
        QtMocHelpers::MethodData<bool(int, int, int, Fun &, Fun &)>(240, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 241 }, { QMetaType::Int, 242 }, { QMetaType::Int, 127 }, { 0x80000000 | 243, 244 },
            { 0x80000000 | 243, 245 },
        }}),
        // Method 'switchGuide'
        QtMocHelpers::MethodData<void(int, bool, bool)>(246, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 227 }, { QMetaType::Bool, 247 }, { QMetaType::Bool, 248 },
        }}),
        // Method 'switchGuide'
        QtMocHelpers::MethodData<void(int, bool)>(246, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 227 }, { QMetaType::Bool, 247 },
        }}),
        // Method 'switchGuide'
        QtMocHelpers::MethodData<void(int)>(246, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 227 },
        }}),
        // Method 'switchGuide'
        QtMocHelpers::MethodData<void()>(246, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'requestRefresh'
        QtMocHelpers::MethodData<void()>(249, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'showAsset'
        QtMocHelpers::MethodData<void(int)>(250, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Method 'showTrackAsset'
        QtMocHelpers::MethodData<void(int)>(251, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'adjustTrackHeight'
        QtMocHelpers::MethodData<void(int, int)>(252, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 253 },
        }}),
        // Method 'adjustAllTrackHeight'
        QtMocHelpers::MethodData<void(int, int)>(254, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 253 },
        }}),
        // Method 'collapseAllTrackHeight'
        QtMocHelpers::MethodData<void(int, bool, int)>(255, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Bool, 256 }, { QMetaType::Int, 118 },
        }}),
        // Method 'defaultTrackHeight'
        QtMocHelpers::MethodData<void(int)>(257, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'exists'
        QtMocHelpers::MethodData<bool(int)>(258, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 64 },
        }}),
        // Method 'headerWidth'
        QtMocHelpers::MethodData<int() const>(259, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'setHeaderWidth'
        QtMocHelpers::MethodData<void(int)>(260, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 261 },
        }}),
        // Method 'hideTrack'
        QtMocHelpers::MethodData<void(int, bool, bool)>(262, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Bool, 263 }, { QMetaType::Bool, 264 },
        }}),
        // Method 'hideTrack'
        QtMocHelpers::MethodData<void(int, bool)>(262, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Bool, 263 },
        }}),
        // Method 'cutClipUnderCursor'
        QtMocHelpers::MethodData<void(int, int, int)>(265, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 78 }, { QMetaType::Int, 266 },
        }}),
        // Method 'cutClipUnderCursor'
        QtMocHelpers::MethodData<void(int, int)>(265, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 28 }, { QMetaType::Int, 78 },
        }}),
        // Method 'cutClipUnderCursor'
        QtMocHelpers::MethodData<void(int)>(265, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 28 },
        }}),
        // Method 'cutClipUnderCursor'
        QtMocHelpers::MethodData<void()>(265, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'cutAllClipsUnderCursor'
        QtMocHelpers::MethodData<void(int)>(267, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 },
        }}),
        // Method 'cutAllClipsUnderCursor'
        QtMocHelpers::MethodData<void()>(267, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'requestSpacerStartOperation'
        QtMocHelpers::MethodData<int(int, int)>(268, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 28 },
        }}),
        // Method 'spacerMinPos'
        QtMocHelpers::MethodData<int() const>(269, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'spacerMaxPos'
        QtMocHelpers::MethodData<int() const>(270, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'spacerSelection'
        QtMocHelpers::MethodData<QVector<int>(int)>(271, 2, QMC::AccessPublic, 0x80000000 | 114, {{
            { QMetaType::Int, 141 },
        }}),
        // Method 'spacerMoveGuides'
        QtMocHelpers::MethodData<void(const QVector<int> &, int)>(272, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 114, 146 }, { QMetaType::Int, 127 },
        }}),
        // Method 'getGuidePosition'
        QtMocHelpers::MethodData<int(int)>(273, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 146 },
        }}),
        // Method 'requestSpacerEndOperation'
        QtMocHelpers::MethodData<bool(int, int, int, int, const QVector<int> &, int)>(274, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Int, 275 }, { QMetaType::Int, 276 }, { QMetaType::Int, 277 },
            { 0x80000000 | 114, 278 }, { QMetaType::Int, 279 },
        }}),
        // Method 'requestSpacerEndOperation'
        QtMocHelpers::MethodData<bool(int, int, int, int, const QVector<int> &)>(274, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Int, 275 }, { QMetaType::Int, 276 }, { QMetaType::Int, 277 },
            { 0x80000000 | 114, 278 },
        }}),
        // Method 'requestSpacerEndOperation'
        QtMocHelpers::MethodData<bool(int, int, int, int)>(274, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Int, 275 }, { QMetaType::Int, 276 }, { QMetaType::Int, 277 },
        }}),
        // Method 'adjustFade'
        QtMocHelpers::MethodData<void(int, const QString &, int, int)>(280, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::QString, 281 }, { QMetaType::Int, 9 }, { QMetaType::Int, 282 },
        }}),
        // Method 'getTrackNameFromMltIndex'
        QtMocHelpers::MethodData<const QString(int)>(283, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 284 },
        }}),
        // Method 'insertSpace'
        QtMocHelpers::MethodData<void(int, int)>(285, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 227 },
        }}),
        // Method 'insertSpace'
        QtMocHelpers::MethodData<void(int)>(285, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'insertSpace'
        QtMocHelpers::MethodData<void()>(285, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'removeSpace'
        QtMocHelpers::MethodData<void(int, int, bool)>(286, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 227 }, { QMetaType::Bool, 287 },
        }}),
        // Method 'removeSpace'
        QtMocHelpers::MethodData<void(int, int)>(286, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 76 }, { QMetaType::Int, 227 },
        }}),
        // Method 'removeSpace'
        QtMocHelpers::MethodData<void(int)>(286, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'removeSpace'
        QtMocHelpers::MethodData<void()>(286, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'switchEnableState'
        QtMocHelpers::MethodData<void(std::unordered_set<int>)>(288, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 289, 290 },
        }}),
        // Method 'switchEnableState'
        QtMocHelpers::MethodData<void()>(288, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'addCompositionToClip'
        QtMocHelpers::MethodData<int(const QString &, int, int)>(291, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 292 }, { QMetaType::Int, 209 }, { QMetaType::Int, 127 },
        }}),
        // Method 'addCompositionToClip'
        QtMocHelpers::MethodData<int(const QString &, int)>(291, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::QString, 292 }, { QMetaType::Int, 209 },
        }}),
        // Method 'addCompositionToClip'
        QtMocHelpers::MethodData<int(const QString &)>(291, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::QString, 292 },
        }}),
        // Method 'addEffectToClip'
        QtMocHelpers::MethodData<void(const QString &, int)>(293, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 292 }, { QMetaType::Int, 209 },
        }}),
        // Method 'addEffectToClip'
        QtMocHelpers::MethodData<void(const QString &)>(293, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 292 },
        }}),
        // Method 'setEffectsEnabled'
        QtMocHelpers::MethodData<void(int, bool)>(294, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 }, { QMetaType::Bool, 295 },
        }}),
        // Method 'requestClipCut'
        QtMocHelpers::MethodData<void(int, int)>(296, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 }, { QMetaType::Int, 28 },
        }}),
        // Method 'setAudioRef'
        QtMocHelpers::MethodData<void(int)>(297, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 },
        }}),
        // Method 'setAudioRef'
        QtMocHelpers::MethodData<void()>(297, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'alignAudio'
        QtMocHelpers::MethodData<void(int)>(298, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 },
        }}),
        // Method 'alignAudio'
        QtMocHelpers::MethodData<void()>(298, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'setTimecodeRef'
        QtMocHelpers::MethodData<void(int)>(299, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 },
        }}),
        // Method 'setTimecodeRef'
        QtMocHelpers::MethodData<void()>(299, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'alignTimecode'
        QtMocHelpers::MethodData<void(int)>(300, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 },
        }}),
        // Method 'alignTimecode'
        QtMocHelpers::MethodData<void()>(300, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'urlDropped'
        QtMocHelpers::MethodData<void(QStringList, int, int)>(301, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 302 }, { QMetaType::Int, 227 }, { QMetaType::Int, 36 },
        }}),
        // Method 'endFakeMove'
        QtMocHelpers::MethodData<bool(int, int, bool, bool, bool)>(303, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Int, 28 }, { QMetaType::Bool, 304 }, { QMetaType::Bool, 196 },
            { QMetaType::Bool, 305 },
        }}),
        // Method 'getItemMovingTrack'
        QtMocHelpers::MethodData<int(int) const>(306, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 64 },
        }}),
        // Method 'pasteEffects'
        QtMocHelpers::MethodData<void(int)>(307, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 308 },
        }}),
        // Method 'pasteEffects'
        QtMocHelpers::MethodData<void()>(307, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'deleteEffects'
        QtMocHelpers::MethodData<void(int)>(309, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 308 },
        }}),
        // Method 'deleteEffects'
        QtMocHelpers::MethodData<void()>(309, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'fps'
        QtMocHelpers::MethodData<double() const>(310, 2, QMC::AccessPublic, QMetaType::Double),
        // Method 'addEffectKeyframe'
        QtMocHelpers::MethodData<void(int, int, double)>(311, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 227 }, { QMetaType::Double, 312 },
        }}),
        // Method 'removeEffectKeyframe'
        QtMocHelpers::MethodData<void(int, int)>(313, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 227 },
        }}),
        // Method 'updateEffectKeyframe'
        QtMocHelpers::MethodData<void(int, int, int, const QVariant &)>(314, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 315 }, { QMetaType::Int, 229 }, { 0x80000000 | 316, 317 },
        }}),
        // Method 'updateEffectKeyframe'
        QtMocHelpers::MethodData<void(int, int, int)>(314, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 315 }, { QMetaType::Int, 229 },
        }}),
        // Method 'hasKeyframeAt'
        QtMocHelpers::MethodData<bool(int, int)>(318, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 227 },
        }}),
        // Method 'switchTrackActive'
        QtMocHelpers::MethodData<void(int)>(319, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 76 },
        }}),
        // Method 'switchTrackActive'
        QtMocHelpers::MethodData<void()>(319, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'getAvTracksCount'
        QtMocHelpers::MethodData<QPair<int,int>() const>(320, 2, QMC::AccessPublic, 0x80000000 | 321),
        // Method 'getMousePosInTimeline'
        QtMocHelpers::MethodData<const QPoint() const>(322, 2, QMC::AccessPublic, 0x80000000 | 33),
        // Method 'warpCursor'
        QtMocHelpers::MethodData<void(const QPoint &)>(323, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 100 },
        }}),
        // Method 'hideCursor'
        QtMocHelpers::MethodData<void(bool)>(324, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 263 },
        }}),
        // Method 'getMousePos'
        QtMocHelpers::MethodData<int()>(325, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'getMouseTrack'
        QtMocHelpers::MethodData<int()>(326, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'getFreeSpace'
        QtMocHelpers::MethodData<int(int, int)>(327, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 36 }, { QMetaType::Int, 28 },
        }}),
        // Method 'requestStartTrimmingMode'
        QtMocHelpers::MethodData<bool(int, bool, bool)>(328, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Bool, 329 }, { QMetaType::Bool, 330 },
        }}),
        // Method 'requestStartTrimmingMode'
        QtMocHelpers::MethodData<bool(int, bool)>(328, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 209 }, { QMetaType::Bool, 329 },
        }}),
        // Method 'requestStartTrimmingMode'
        QtMocHelpers::MethodData<bool(int)>(328, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 209 },
        }}),
        // Method 'requestStartTrimmingMode'
        QtMocHelpers::MethodData<bool()>(328, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Method 'requestEndTrimmingMode'
        QtMocHelpers::MethodData<void()>(331, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'slipPosChanged'
        QtMocHelpers::MethodData<void(int)>(332, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 127 },
        }}),
        // Method 'ripplePosChanged'
        QtMocHelpers::MethodData<void(int, bool)>(333, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 100 }, { QMetaType::Bool, 330 },
        }}),
        // Method 'requestItemRippleResize'
        QtMocHelpers::MethodData<int(int, int, bool, bool, int, bool)>(334, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 64 }, { QMetaType::Int, 335 }, { QMetaType::Bool, 330 }, { QMetaType::Bool, 196 },
            { QMetaType::Int, 236 }, { QMetaType::Bool, 336 },
        }}),
        // Method 'requestItemRippleResize'
        QtMocHelpers::MethodData<int(int, int, bool, bool, int)>(334, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::Int, 64 }, { QMetaType::Int, 335 }, { QMetaType::Bool, 330 }, { QMetaType::Bool, 196 },
            { QMetaType::Int, 236 },
        }}),
        // Method 'requestItemRippleResize'
        QtMocHelpers::MethodData<int(int, int, bool, bool)>(334, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::Int, 64 }, { QMetaType::Int, 335 }, { QMetaType::Bool, 330 }, { QMetaType::Bool, 196 },
        }}),
        // Method 'requestItemRippleResize'
        QtMocHelpers::MethodData<int(int, int, bool)>(334, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::Int, 64 }, { QMetaType::Int, 335 }, { QMetaType::Bool, 330 },
        }}),
        // Method 'changeItemSpeed'
        QtMocHelpers::MethodData<void(int, double)>(337, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 209 }, { QMetaType::Double, 338 },
        }}),
        // Method 'insertClipZone'
        QtMocHelpers::MethodData<bool(const QString &, int, int)>(339, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 340 }, { QMetaType::Int, 36 }, { QMetaType::Int, 100 },
        }}),
        // Method 'getAssetName'
        QtMocHelpers::MethodData<const QString(const QString &, bool)>(341, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 292 }, { QMetaType::Bool, 342 },
        }}),
        // Method 'grabCurrent'
        QtMocHelpers::MethodData<void()>(343, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'showMasterEffects'
        QtMocHelpers::MethodData<void()>(344, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'mixClip'
        QtMocHelpers::MethodData<void(int, int)>(345, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 39 }, { QMetaType::Int, 346 },
        }}),
        // Method 'mixClip'
        QtMocHelpers::MethodData<void(int)>(345, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 39 },
        }}),
        // Method 'mixClip'
        QtMocHelpers::MethodData<void()>(345, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'selection'
        QtMocHelpers::PropertyData<QList<int>>(290, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'selectedMix'
        QtMocHelpers::PropertyData<int>(347, QMetaType::Int, QMC::DefaultPropertyFlags, 2),
        // property 'scaleFactor'
        QtMocHelpers::PropertyData<double>(156, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'duration'
        QtMocHelpers::PropertyData<int>(9, QMetaType::Int, QMC::DefaultPropertyFlags, 6),
        // property 'fullDuration'
        QtMocHelpers::PropertyData<int>(157, QMetaType::Int, QMC::DefaultPropertyFlags, 6),
        // property 'zoneIn'
        QtMocHelpers::PropertyData<int>(348, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'zoneOut'
        QtMocHelpers::PropertyData<int>(349, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'ripple'
        QtMocHelpers::PropertyData<bool>(189, QMetaType::Bool, QMC::DefaultPropertyFlags, 19),
        // property 'scrub'
        QtMocHelpers::PropertyData<bool>(190, QMetaType::Bool, QMC::DefaultPropertyFlags, 20),
        // property 'dirtyChunks'
        QtMocHelpers::PropertyData<QVariantList>(350, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 33),
        // property 'renderedChunks'
        QtMocHelpers::PropertyData<QVariantList>(351, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 34),
        // property 'masterEffectZones'
        QtMocHelpers::PropertyData<QVariantList>(352, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 43),
        // property 'workingPreview'
        QtMocHelpers::PropertyData<int>(353, QMetaType::Int, QMC::DefaultPropertyFlags, 35),
        // property 'useRuler'
        QtMocHelpers::PropertyData<bool>(354, QMetaType::Bool, QMC::DefaultPropertyFlags, 38),
        // property 'activeTrack'
        QtMocHelpers::PropertyData<int>(167, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'audioZoomText'
        QtMocHelpers::PropertyData<QString>(155, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'activeSubLayer'
        QtMocHelpers::PropertyData<int>(355, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'subtitlesList'
        QtMocHelpers::PropertyData<QVariantList>(186, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 26),
        // property 'maxSubLayer'
        QtMocHelpers::PropertyData<int>(356, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'audioTarget'
        QtMocHelpers::PropertyData<QVariantList>(158, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
        // property 'videoTarget'
        QtMocHelpers::PropertyData<int>(163, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'lastAudioTarget'
        QtMocHelpers::PropertyData<QVariantList>(159, 0x80000000 | 140, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 11),
        // property 'lastVideoTarget'
        QtMocHelpers::PropertyData<int>(357, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'hasAudioTarget'
        QtMocHelpers::PropertyData<int>(164, QMetaType::Int, QMC::DefaultPropertyFlags, 9),
        // property 'hasVideoTarget'
        QtMocHelpers::PropertyData<bool>(166, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'clipTargets'
        QtMocHelpers::PropertyData<int>(165, QMetaType::Int, QMC::DefaultPropertyFlags, 9),
        // property 'autoScroll'
        QtMocHelpers::PropertyData<bool>(358, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'videoColor'
        QtMocHelpers::PropertyData<QColor>(169, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'audioColor'
        QtMocHelpers::PropertyData<QColor>(171, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'titleColor'
        QtMocHelpers::PropertyData<QColor>(172, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'imageColor'
        QtMocHelpers::PropertyData<QColor>(173, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'slideshowColor'
        QtMocHelpers::PropertyData<QColor>(174, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'targetColor'
        QtMocHelpers::PropertyData<QColor>(175, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'targetTextColor'
        QtMocHelpers::PropertyData<QColor>(176, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'lockedColor'
        QtMocHelpers::PropertyData<QColor>(177, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'selectionColor'
        QtMocHelpers::PropertyData<QColor>(178, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'groupColor'
        QtMocHelpers::PropertyData<QColor>(179, 0x80000000 | 170, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'subtitlesWarning'
        QtMocHelpers::PropertyData<bool>(359, QMetaType::Bool, QMC::DefaultPropertyFlags, 21),
        // property 'subtitlesDisabled'
        QtMocHelpers::PropertyData<bool>(360, QMetaType::Bool, QMC::DefaultPropertyFlags, 36),
        // property 'subtitlesLocked'
        QtMocHelpers::PropertyData<bool>(361, QMetaType::Bool, QMC::DefaultPropertyFlags, 37),
        // property 'activeSubPosition'
        QtMocHelpers::PropertyData<int>(362, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 48),
        // property 'autotrackHeight'
        QtMocHelpers::PropertyData<bool>(363, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 23),
        // property 'effectZone'
        QtMocHelpers::PropertyData<QPoint>(364, 0x80000000 | 33, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 42),
        // property 'trimmingMainClip'
        QtMocHelpers::PropertyData<int>(168, QMetaType::Int, QMC::DefaultPropertyFlags, 18),
        // property 'multicamIn'
        QtMocHelpers::PropertyData<int>(365, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 22),
        // property 'timecodeOffset'
        QtMocHelpers::PropertyData<int>(366, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 49),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<TimelineController, qt_meta_tag_ZN18TimelineControllerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject TimelineController::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18TimelineControllerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18TimelineControllerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18TimelineControllerE_t>.metaTypes,
    nullptr
} };

void TimelineController::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<TimelineController *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->audioZoomTextChanged(); break;
        case 1: _t->selectionChanged(); break;
        case 2: _t->selectedMixChanged(); break;
        case 3: _t->frameFormatChanged(); break;
        case 4: _t->trackHeightChanged(); break;
        case 5: _t->scaleFactorChanged(); break;
        case 6: _t->durationChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->audioTargetChanged(); break;
        case 8: _t->videoTargetChanged(); break;
        case 9: _t->hasAudioTargetChanged(); break;
        case 10: _t->hasVideoTargetChanged(); break;
        case 11: _t->lastAudioTargetChanged(); break;
        case 12: _t->autoScrollChanged(); break;
        case 13: _t->lastVideoTargetChanged(); break;
        case 14: _t->timelineMouseOffsetChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->activeTrackChanged(); break;
        case 16: _t->activeSubLayerChanged(); break;
        case 17: _t->colorsChanged(); break;
        case 18: _t->trimmingMainClipChanged(); break;
        case 19: _t->rippleChanged(); break;
        case 20: _t->scrubChanged(); break;
        case 21: _t->subtitlesWarningChanged(); break;
        case 22: _t->multicamInChanged(); break;
        case 23: _t->autotrackHeightChanged(); break;
        case 24: _t->seeked((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 25: _t->zoneChanged(); break;
        case 26: _t->subtitlesListChanged(); break;
        case 27: _t->maxSubLayerChanged(); break;
        case 28: _t->zoneMoved((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 29: _t->showTransitionModel((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<AssetParameterModel>>>(_a[2]))); break;
        case 30: _t->showMixModel((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<AssetParameterModel>>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 31: _t->showItemEffectStack((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::shared_ptr<EffectStackModel>>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 32: _t->showSubtitle((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 33: _t->dirtyChunksChanged(); break;
        case 34: _t->renderedChunksChanged(); break;
        case 35: _t->workingPreviewChanged(); break;
        case 36: _t->subtitlesDisabledChanged(); break;
        case 37: _t->subtitlesLockedChanged(); break;
        case 38: _t->useRulerChanged(); break;
        case 39: _t->updateZoom((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 40: _t->timelineClipSelected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: _t->centerView(); break;
        case 42: _t->effectZoneChanged(); break;
        case 43: _t->masterZonesChanged(); break;
        case 44: _t->ungrabHack(); break;
        case 45: _t->regainFocus(); break;
        case 46: _t->updateAssetPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[2]))); break;
        case 47: _t->stopAudioRecord(); break;
        case 48: _t->activeSubtitlePositionChanged(); break;
        case 49: _t->timecodeOffsetChanged(); break;
        case 50: _t->updateClipActions(); break;
        case 51: _t->resetView(); break;
        case 52: _t->setAudioTarget((*reinterpret_cast<std::add_pointer_t<QMap<int,int>>>(_a[1]))); break;
        case 53: _t->switchAudioTarget((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 54: _t->setVideoTarget((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 55: _t->setActiveTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 56: _t->addEffectToCurrentClip((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 57: _t->disablePreview((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 58: _t->invalidateItem((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 59: _t->invalidateTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 60: _t->invalidateMix((*reinterpret_cast<std::add_pointer_t<ObjectId>>(_a[1]))); break;
        case 61: _t->checkDuration(); break;
        case 62: _t->slotMultitrackView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 63: _t->slotMultitrackView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->slotMultitrackView(); break;
        case 65: _t->activateTrackAndSelect((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 66: _t->activateTrackAndSelect((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 67: _t->saveTimelineSelection((*reinterpret_cast<std::add_pointer_t<QDir>>(_a[1]))); break;
        case 68: _t->setScrollPos((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 69: _t->resizeMix((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<MixAlignment>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 70: _t->resizeMix((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<MixAlignment>>(_a[3]))); break;
        case 71: _t->updateZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 72: _t->updateZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2]))); break;
        case 73: _t->updateEffectZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 74: _t->updateEffectZone((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2]))); break;
        case 75: _t->updateTrimmingMode(); break;
        case 76: _t->checkClipPosition((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[3]))); break;
        case 77: _t->autofitTrackHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 78: _t->subtitlesMenuActivatedAsync((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 79: _t->subtitlesMenuActivated((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 80: _t->switchFocusClip(); break;
        case 81: _t->enableBuildInTransform(); break;
        case 82: _t->showSubtitleManager((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 83: _t->showSubtitleManager(); break;
        case 84: _t->setTimelineMouseOffset((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 85: _t->updateVideoTarget(); break;
        case 86: _t->updateAudioTarget(); break;
        case 87: _t->updateMultiTrack(); break;
        case 88: _t->slotFlashLock((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 89: _t->initializePreview(); break;
        case 90: _t->loadSubtitleIndex(); break;
        case 91: _t->editItemDuration(); break;
        case 92: _t->editTitleClip((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 93: _t->editTitleClip(); break;
        case 94: _t->focusTimelineSequence((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 95: _t->editAnimationClip((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 96: _t->editAnimationClip(); break;
        case 97: { int _r = _t->selectedTrack();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->selectItems((*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6]))); break;
        case 99: _t->selectItems((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 100: { bool _r = _t->isInSelection((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 101: _t->switchRecording((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 102: _t->switchRecording((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 103: _t->switchRecording(); break;
        case 104: { QString _r = _t->getActionShortcut((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 105: _t->showConfig((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 106: { bool _r = _t->hasActiveTracks();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 107: { QString _r = _t->audioZoomText();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 108: { double _r = _t->scaleFactor();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 109: { int _r = _t->duration();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 110: { int _r = _t->fullDuration();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 111: { QVariantList _r = _t->audioTarget();
            if (_a[0]) *reinterpret_cast<QVariantList*>(_a[0]) = std::move(_r); }  break;
        case 112: { QVariantList _r = _t->lastAudioTarget();
            if (_a[0]) *reinterpret_cast<QVariantList*>(_a[0]) = std::move(_r); }  break;
        case 113: _t->keepAudioTargets((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 114: { QString _r = _t->audioTargetName((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 115: { int _r = _t->videoTarget();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 116: { int _r = _t->hasAudioTarget();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 117: { int _r = _t->clipTargets();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 118: { bool _r = _t->hasVideoTarget();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 119: { int _r = _t->activeTrack();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 120: { int _r = _t->trimmingMainClip();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 121: { QColor _r = _t->videoColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 122: { QColor _r = _t->audioColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 123: { QColor _r = _t->titleColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 124: { QColor _r = _t->imageColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 125: { QColor _r = _t->slideshowColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 126: { QColor _r = _t->targetColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 127: { QColor _r = _t->targetTextColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 128: { QColor _r = _t->lockedColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 129: { QColor _r = _t->selectionColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 130: { QColor _r = _t->groupColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 131: { int _r = _t->doubleClickInterval();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 132: _t->showToolTip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 133: _t->showToolTip(); break;
        case 134: _t->showKeyBinding((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 135: _t->showKeyBinding(); break;
        case 136: _t->showTimelineToolInfo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 137: { QVariantList _r = _t->subtitlesList();
            if (_a[0]) *reinterpret_cast<QVariantList*>(_a[0]) = std::move(_r); }  break;
        case 138: _t->subtitlesWarningDetails(); break;
        case 139: _t->setPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 140: { bool _r = _t->ripple();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 141: { bool _r = _t->scrub();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 142: { QString _r = _t->timecode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 143: { QString _r = _t->simplifiedTC((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 144: { int _r = _t->insertClip((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 145: { QList<int> _r = _t->insertClips((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 146: { int _r = _t->copyItem();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 147: { bool _r = _t->pasteItem((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 148: { bool _r = _t->pasteItem((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 149: { bool _r = _t->pasteItem();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 150: { int _r = _t->insertComposition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 151: { int _r = _t->insertComposition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 152: _t->insertNewMix((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 153: { int _r = _t->isOnCut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 154: { int _r = _t->insertNewCompositionAtPos((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 155: { int _r = _t->insertNewComposition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 156: _t->deleteSelectedClips(); break;
        case 157: _t->triggerAction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 158: { QString _r = _t->actionText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 159: _t->beginAddTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 160: _t->deleteMultipleTracks((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 161: _t->groupSelection(); break;
        case 162: _t->unGroupSelection((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 163: _t->unGroupSelection(); break;
        case 164: _t->editMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 165: _t->editMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 166: _t->editMarker(); break;
        case 167: _t->addMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 168: _t->addMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 169: _t->addMarker(); break;
        case 170: _t->addQuickMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 171: _t->addQuickMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 172: _t->addQuickMarker(); break;
        case 173: _t->deleteMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 174: _t->deleteMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 175: _t->deleteMarker(); break;
        case 176: _t->resizeMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); break;
        case 177: _t->resizeMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 178: _t->resizeMarker((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 179: _t->deleteAllMarkers((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 180: _t->deleteAllMarkers(); break;
        case 181: _t->editGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 182: _t->editGuide(); break;
        case 183: _t->moveGuideById((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 184: { int _r = _t->moveGuideWithoutUndo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 185: _t->pauseGuideSorting((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 186: _t->resizeGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 187: _t->resizeGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 188: _t->resizeGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 189: { int _r = _t->suggestSnapPoint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 190: { bool _r = _t->createRangeMarkerFromZone((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 191: { bool _r = _t->createRangeMarkerFromZone((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 192: { bool _r = _t->createRangeMarkerFromZone();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 193: { bool _r = _t->moveGuidesInRange((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 194: { bool _r = _t->moveGuidesInRange((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Fun&>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<Fun&>>(_a[5])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 195: _t->switchGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 196: _t->switchGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 197: _t->switchGuide((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 198: _t->switchGuide(); break;
        case 199: _t->requestRefresh(); break;
        case 200: _t->showAsset((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 201: _t->showTrackAsset((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 202: _t->adjustTrackHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 203: _t->adjustAllTrackHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 204: _t->collapseAllTrackHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 205: _t->defaultTrackHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 206: { bool _r = _t->exists((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 207: { int _r = _t->headerWidth();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 208: _t->setHeaderWidth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 209: _t->hideTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 210: _t->hideTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 211: _t->cutClipUnderCursor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 212: _t->cutClipUnderCursor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 213: _t->cutClipUnderCursor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 214: _t->cutClipUnderCursor(); break;
        case 215: _t->cutAllClipsUnderCursor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 216: _t->cutAllClipsUnderCursor(); break;
        case 217: { int _r = _t->requestSpacerStartOperation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 218: { int _r = _t->spacerMinPos();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 219: { int _r = _t->spacerMaxPos();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 220: { QList<int> _r = _t->spacerSelection((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 221: _t->spacerMoveGuides((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 222: { int _r = _t->getGuidePosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 223: { bool _r = _t->requestSpacerEndOperation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[6])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 224: { bool _r = _t->requestSpacerEndOperation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[5])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 225: { bool _r = _t->requestSpacerEndOperation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 226: _t->adjustFade((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 227: { QString _r = _t->getTrackNameFromMltIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 228: _t->insertSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 229: _t->insertSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 230: _t->insertSpace(); break;
        case 231: _t->removeSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 232: _t->removeSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 233: _t->removeSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 234: _t->removeSpace(); break;
        case 235: _t->switchEnableState((*reinterpret_cast<std::add_pointer_t<std::unordered_set<int>>>(_a[1]))); break;
        case 236: _t->switchEnableState(); break;
        case 237: { int _r = _t->addCompositionToClip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 238: { int _r = _t->addCompositionToClip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 239: { int _r = _t->addCompositionToClip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 240: _t->addEffectToClip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 241: _t->addEffectToClip((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 242: _t->setEffectsEnabled((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 243: _t->requestClipCut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 244: _t->setAudioRef((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 245: _t->setAudioRef(); break;
        case 246: _t->alignAudio((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 247: _t->alignAudio(); break;
        case 248: _t->setTimecodeRef((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 249: _t->setTimecodeRef(); break;
        case 250: _t->alignTimecode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 251: _t->alignTimecode(); break;
        case 252: _t->urlDropped((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 253: { bool _r = _t->endFakeMove((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 254: { int _r = _t->getItemMovingTrack((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 255: _t->pasteEffects((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 256: _t->pasteEffects(); break;
        case 257: _t->deleteEffects((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 258: _t->deleteEffects(); break;
        case 259: { double _r = _t->fps();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 260: _t->addEffectKeyframe((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 261: _t->removeEffectKeyframe((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 262: _t->updateEffectKeyframe((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[4]))); break;
        case 263: _t->updateEffectKeyframe((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 264: { bool _r = _t->hasKeyframeAt((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 265: _t->switchTrackActive((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 266: _t->switchTrackActive(); break;
        case 267: { std::pair<int,int> _r = _t->getAvTracksCount();
            if (_a[0]) *reinterpret_cast<std::pair<int,int>*>(_a[0]) = std::move(_r); }  break;
        case 268: { QPoint _r = _t->getMousePosInTimeline();
            if (_a[0]) *reinterpret_cast<QPoint*>(_a[0]) = std::move(_r); }  break;
        case 269: _t->warpCursor((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 270: _t->hideCursor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 271: { int _r = _t->getMousePos();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 272: { int _r = _t->getMouseTrack();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 273: { int _r = _t->getFreeSpace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 274: { bool _r = _t->requestStartTrimmingMode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 275: { bool _r = _t->requestStartTrimmingMode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 276: { bool _r = _t->requestStartTrimmingMode((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 277: { bool _r = _t->requestStartTrimmingMode();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 278: _t->requestEndTrimmingMode(); break;
        case 279: _t->slipPosChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 280: _t->ripplePosChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 281: { int _r = _t->requestItemRippleResize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 282: { int _r = _t->requestItemRippleResize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 283: { int _r = _t->requestItemRippleResize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 284: { int _r = _t->requestItemRippleResize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 285: _t->changeItemSpeed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 286: { bool _r = _t->insertClipZone((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 287: { QString _r = _t->getAssetName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 288: _t->grabCurrent(); break;
        case 289: _t->showMasterEffects(); break;
        case 290: _t->mixClip((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 291: _t->mixClip((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 292: _t->mixClip(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 76:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 99:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 221:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 223:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 4:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 224:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 4:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::audioZoomTextChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::selectionChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::selectedMixChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::frameFormatChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::trackHeightChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::scaleFactorChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int )>(_a, &TimelineController::durationChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::audioTargetChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::videoTargetChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::hasAudioTargetChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::hasVideoTargetChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::lastAudioTargetChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::autoScrollChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::lastVideoTargetChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int )>(_a, &TimelineController::timelineMouseOffsetChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::activeTrackChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::activeSubLayerChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::colorsChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::trimmingMainClipChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::rippleChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::scrubChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::subtitlesWarningChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::multicamInChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::autotrackHeightChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int )>(_a, &TimelineController::seeked, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::zoneChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::subtitlesListChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::maxSubLayerChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(const QPoint & )>(_a, &TimelineController::zoneMoved, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int , std::shared_ptr<AssetParameterModel> )>(_a, &TimelineController::showTransitionModel, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int , const std::shared_ptr<AssetParameterModel> & , bool )>(_a, &TimelineController::showMixModel, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(const QString & , std::shared_ptr<EffectStackModel> , QSize , bool )>(_a, &TimelineController::showItemEffectStack, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int )>(_a, &TimelineController::showSubtitle, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::dirtyChunksChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::renderedChunksChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::workingPreviewChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::subtitlesDisabledChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::subtitlesLockedChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::useRulerChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(double )>(_a, &TimelineController::updateZoom, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(bool )>(_a, &TimelineController::timelineClipSelected, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::centerView, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::effectZoneChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::masterZonesChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::ungrabHack, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::regainFocus, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)(int , const QUuid )>(_a, &TimelineController::updateAssetPosition, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::stopAudioRecord, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::activeSubtitlePositionChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineController::*)()>(_a, &TimelineController::timecodeOffsetChanged, 49))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<int> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QList<int>*>(_v) = _t->selection(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->selectedMix(); break;
        case 2: *reinterpret_cast<double*>(_v) = _t->scaleFactor(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->duration(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->fullDuration(); break;
        case 5: *reinterpret_cast<int*>(_v) = _t->zoneIn(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->zoneOut(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->ripple(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->scrub(); break;
        case 9: *reinterpret_cast<QVariantList*>(_v) = _t->dirtyChunks(); break;
        case 10: *reinterpret_cast<QVariantList*>(_v) = _t->renderedChunks(); break;
        case 11: *reinterpret_cast<QVariantList*>(_v) = _t->m_masterEffectZones; break;
        case 12: *reinterpret_cast<int*>(_v) = _t->workingPreview(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->useRuler(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->activeTrack(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->audioZoomText(); break;
        case 16: *reinterpret_cast<int*>(_v) = _t->activeSubLayer(); break;
        case 17: *reinterpret_cast<QVariantList*>(_v) = _t->subtitlesList(); break;
        case 18: *reinterpret_cast<int*>(_v) = _t->getMaxSubLayer(); break;
        case 19: *reinterpret_cast<QVariantList*>(_v) = _t->audioTarget(); break;
        case 20: *reinterpret_cast<int*>(_v) = _t->videoTarget(); break;
        case 21: *reinterpret_cast<QVariantList*>(_v) = _t->lastAudioTarget(); break;
        case 22: *reinterpret_cast<int*>(_v) = _t->m_lastVideoTarget; break;
        case 23: *reinterpret_cast<int*>(_v) = _t->hasAudioTarget(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->hasVideoTarget(); break;
        case 25: *reinterpret_cast<int*>(_v) = _t->clipTargets(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->autoScroll(); break;
        case 27: *reinterpret_cast<QColor*>(_v) = _t->videoColor(); break;
        case 28: *reinterpret_cast<QColor*>(_v) = _t->audioColor(); break;
        case 29: *reinterpret_cast<QColor*>(_v) = _t->titleColor(); break;
        case 30: *reinterpret_cast<QColor*>(_v) = _t->imageColor(); break;
        case 31: *reinterpret_cast<QColor*>(_v) = _t->slideshowColor(); break;
        case 32: *reinterpret_cast<QColor*>(_v) = _t->targetColor(); break;
        case 33: *reinterpret_cast<QColor*>(_v) = _t->targetTextColor(); break;
        case 34: *reinterpret_cast<QColor*>(_v) = _t->lockedColor(); break;
        case 35: *reinterpret_cast<QColor*>(_v) = _t->selectionColor(); break;
        case 36: *reinterpret_cast<QColor*>(_v) = _t->groupColor(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->subtitlesWarning(); break;
        case 38: *reinterpret_cast<bool*>(_v) = _t->subtitlesDisabled(); break;
        case 39: *reinterpret_cast<bool*>(_v) = _t->subtitlesLocked(); break;
        case 40: *reinterpret_cast<int*>(_v) = _t->m_activeSubPosition; break;
        case 41: *reinterpret_cast<bool*>(_v) = _t->m_autotrackHeight; break;
        case 42: *reinterpret_cast<QPoint*>(_v) = _t->m_effectZone; break;
        case 43: *reinterpret_cast<int*>(_v) = _t->trimmingMainClip(); break;
        case 44: *reinterpret_cast<int*>(_v) = _t->multicamIn; break;
        case 45: *reinterpret_cast<int*>(_v) = _t->m_timecodeOffset; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 2: _t->setScaleFactor(*reinterpret_cast<double*>(_v)); break;
        case 5: _t->setZoneIn(*reinterpret_cast<int*>(_v)); break;
        case 6: _t->setZoneOut(*reinterpret_cast<int*>(_v)); break;
        case 11:
            if (QtMocHelpers::setProperty(_t->m_masterEffectZones, *reinterpret_cast<QVariantList*>(_v)))
                Q_EMIT _t->masterZonesChanged();
            break;
        case 14: _t->setActiveTrack(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setActiveSubLayer(*reinterpret_cast<int*>(_v)); break;
        case 18: _t->setMaxSubLayer(*reinterpret_cast<int*>(_v)); break;
        case 20: _t->setVideoTarget(*reinterpret_cast<int*>(_v)); break;
        case 22:
            if (QtMocHelpers::setProperty(_t->m_lastVideoTarget, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->lastVideoTargetChanged();
            break;
        case 40:
            if (QtMocHelpers::setProperty(_t->m_activeSubPosition, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->activeSubtitlePositionChanged();
            break;
        case 41:
            if (QtMocHelpers::setProperty(_t->m_autotrackHeight, *reinterpret_cast<bool*>(_v)))
                Q_EMIT _t->autotrackHeightChanged();
            break;
        case 42:
            if (QtMocHelpers::setProperty(_t->m_effectZone, *reinterpret_cast<QPoint*>(_v)))
                Q_EMIT _t->effectZoneChanged();
            break;
        case 44:
            if (QtMocHelpers::setProperty(_t->multicamIn, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->multicamInChanged();
            break;
        case 45:
            if (QtMocHelpers::setProperty(_t->m_timecodeOffset, *reinterpret_cast<int*>(_v)))
                Q_EMIT _t->timecodeOffsetChanged();
            break;
        default: break;
        }
    }
}

const QMetaObject *TimelineController::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *TimelineController::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18TimelineControllerE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int TimelineController::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 293)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 293;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 293)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 293;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 46;
    }
    return _id;
}

// SIGNAL 0
void TimelineController::audioZoomTextChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void TimelineController::selectionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void TimelineController::selectedMixChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void TimelineController::frameFormatChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void TimelineController::trackHeightChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void TimelineController::scaleFactorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void TimelineController::durationChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void TimelineController::audioTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void TimelineController::videoTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void TimelineController::hasAudioTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void TimelineController::hasVideoTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void TimelineController::lastAudioTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void TimelineController::autoScrollChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void TimelineController::lastVideoTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void TimelineController::timelineMouseOffsetChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void TimelineController::activeTrackChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void TimelineController::activeSubLayerChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void TimelineController::colorsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void TimelineController::trimmingMainClipChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void TimelineController::rippleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void TimelineController::scrubChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void TimelineController::subtitlesWarningChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void TimelineController::multicamInChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void TimelineController::autotrackHeightChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void TimelineController::seeked(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void TimelineController::zoneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void TimelineController::subtitlesListChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void TimelineController::maxSubLayerChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void TimelineController::zoneMoved(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void TimelineController::showTransitionModel(int _t1, std::shared_ptr<AssetParameterModel> _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1, _t2);
}

// SIGNAL 30
void TimelineController::showMixModel(int _t1, const std::shared_ptr<AssetParameterModel> & _t2, bool _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1, _t2, _t3);
}

// SIGNAL 31
void TimelineController::showItemEffectStack(const QString & _t1, std::shared_ptr<EffectStackModel> _t2, QSize _t3, bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 32
void TimelineController::showSubtitle(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void TimelineController::dirtyChunksChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void TimelineController::renderedChunksChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void TimelineController::workingPreviewChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void TimelineController::subtitlesDisabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void TimelineController::subtitlesLockedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 37, nullptr);
}

// SIGNAL 38
void TimelineController::useRulerChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void TimelineController::updateZoom(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void TimelineController::timelineClipSelected(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void TimelineController::centerView()
{
    QMetaObject::activate(this, &staticMetaObject, 41, nullptr);
}

// SIGNAL 42
void TimelineController::effectZoneChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 42, nullptr);
}

// SIGNAL 43
void TimelineController::masterZonesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 43, nullptr);
}

// SIGNAL 44
void TimelineController::ungrabHack()
{
    QMetaObject::activate(this, &staticMetaObject, 44, nullptr);
}

// SIGNAL 45
void TimelineController::regainFocus()
{
    QMetaObject::activate(this, &staticMetaObject, 45, nullptr);
}

// SIGNAL 46
void TimelineController::updateAssetPosition(int _t1, const QUuid _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1, _t2);
}

// SIGNAL 47
void TimelineController::stopAudioRecord()
{
    QMetaObject::activate(this, &staticMetaObject, 47, nullptr);
}

// SIGNAL 48
void TimelineController::activeSubtitlePositionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 48, nullptr);
}

// SIGNAL 49
void TimelineController::timecodeOffsetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 49, nullptr);
}
QT_WARNING_POP
