/****************************************************************************
** Meta object code from reading C++ file 'definitions.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/definitions.h"
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'definitions.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_ZN13PlaylistStateE_t {};
} // unnamed namespace

template <> constexpr inline auto PlaylistState::qt_create_metaobjectdata<qt_meta_tag_ZN13PlaylistStateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PlaylistState",
        "QML.Element",
        "auto",
        "ClipState",
        "VideoOnly",
        "AudioOnly",
        "Disabled",
        "Unknown"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ClipState'
        QtMocHelpers::EnumData<ClipState>(3, 3, QMC::EnumFlags{}).add({
            {    4, ClipState::VideoOnly },
            {    5, ClipState::AudioOnly },
            {    6, ClipState::Disabled },
            {    7, ClipState::Unknown },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN13PlaylistStateE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN13PlaylistStateE =
    PlaylistState::qt_create_metaobjectdata<qt_meta_tag_ZN13PlaylistStateE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN13PlaylistStateE =
    qt_staticMetaObjectContent_ZN13PlaylistStateE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN13PlaylistStateE =
    qt_staticMetaObjectContent_ZN13PlaylistStateE.relocatingData;

Q_CONSTINIT const QMetaObject PlaylistState::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN13PlaylistStateE.stringdata,
    qt_staticMetaObjectStaticContent_ZN13PlaylistStateE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN13PlaylistStateE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN10FileStatusE_t {};
} // unnamed namespace

template <> constexpr inline auto FileStatus::qt_create_metaobjectdata<qt_meta_tag_ZN10FileStatusE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FileStatus",
        "QML.Element",
        "auto",
        "ClipStatus",
        "StatusReady",
        "StatusProxy",
        "StatusMissing",
        "StatusWaiting",
        "StatusDeleting",
        "StatusProxyOnly"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ClipStatus'
        QtMocHelpers::EnumData<ClipStatus>(3, 3, QMC::EnumFlags{}).add({
            {    4, ClipStatus::StatusReady },
            {    5, ClipStatus::StatusProxy },
            {    6, ClipStatus::StatusMissing },
            {    7, ClipStatus::StatusWaiting },
            {    8, ClipStatus::StatusDeleting },
            {    9, ClipStatus::StatusProxyOnly },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN10FileStatusE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN10FileStatusE =
    FileStatus::qt_create_metaobjectdata<qt_meta_tag_ZN10FileStatusE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN10FileStatusE =
    qt_staticMetaObjectContent_ZN10FileStatusE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN10FileStatusE =
    qt_staticMetaObjectContent_ZN10FileStatusE.relocatingData;

Q_CONSTINIT const QMetaObject FileStatus::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN10FileStatusE.stringdata,
    qt_staticMetaObjectStaticContent_ZN10FileStatusE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN10FileStatusE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN13AssetListTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto AssetListType::qt_create_metaobjectdata<qt_meta_tag_ZN13AssetListTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AssetListType",
        "QML.Element",
        "auto",
        "AssetType",
        "Preferred",
        "Video",
        "Audio",
        "Custom",
        "CustomAudio",
        "Template",
        "TemplateAudio",
        "TemplateCustom",
        "TemplateCustomAudio",
        "Favorites",
        "AudioComposition",
        "VideoShortComposition",
        "VideoComposition",
        "AudioTransition",
        "VideoTransition",
        "LumaTransition",
        "Text",
        "Hidden"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'AssetType'
        QtMocHelpers::EnumData<AssetType>(3, 3, QMC::EnumFlags{}).add({
            {    4, AssetType::Preferred },
            {    5, AssetType::Video },
            {    6, AssetType::Audio },
            {    7, AssetType::Custom },
            {    8, AssetType::CustomAudio },
            {    9, AssetType::Template },
            {   10, AssetType::TemplateAudio },
            {   11, AssetType::TemplateCustom },
            {   12, AssetType::TemplateCustomAudio },
            {   13, AssetType::Favorites },
            {   14, AssetType::AudioComposition },
            {   15, AssetType::VideoShortComposition },
            {   16, AssetType::VideoComposition },
            {   17, AssetType::AudioTransition },
            {   18, AssetType::VideoTransition },
            {   19, AssetType::LumaTransition },
            {   20, AssetType::Text },
            {   21, AssetType::Hidden },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN13AssetListTypeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN13AssetListTypeE =
    AssetListType::qt_create_metaobjectdata<qt_meta_tag_ZN13AssetListTypeE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN13AssetListTypeE =
    qt_staticMetaObjectContent_ZN13AssetListTypeE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN13AssetListTypeE =
    qt_staticMetaObjectContent_ZN13AssetListTypeE.relocatingData;

Q_CONSTINIT const QMetaObject AssetListType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN13AssetListTypeE.stringdata,
    qt_staticMetaObjectStaticContent_ZN13AssetListTypeE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN13AssetListTypeE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN8ClipTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto ClipType::qt_create_metaobjectdata<qt_meta_tag_ZN8ClipTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ClipType",
        "QML.Element",
        "auto",
        "ProducerType",
        "Unknown",
        "Audio",
        "Video",
        "AV",
        "Color",
        "Image",
        "Text",
        "SlideShow",
        "Virtual",
        "Playlist",
        "WebVfx",
        "TextTemplate",
        "QText",
        "Composition",
        "Track",
        "Qml",
        "Animation",
        "Timeline"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ProducerType'
        QtMocHelpers::EnumData<ProducerType>(3, 3, QMC::EnumFlags{}).add({
            {    4, ProducerType::Unknown },
            {    5, ProducerType::Audio },
            {    6, ProducerType::Video },
            {    7, ProducerType::AV },
            {    8, ProducerType::Color },
            {    9, ProducerType::Image },
            {   10, ProducerType::Text },
            {   11, ProducerType::SlideShow },
            {   12, ProducerType::Virtual },
            {   13, ProducerType::Playlist },
            {   14, ProducerType::WebVfx },
            {   15, ProducerType::TextTemplate },
            {   16, ProducerType::QText },
            {   17, ProducerType::Composition },
            {   18, ProducerType::Track },
            {   19, ProducerType::Qml },
            {   20, ProducerType::Animation },
            {   21, ProducerType::Timeline },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN8ClipTypeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN8ClipTypeE =
    ClipType::qt_create_metaobjectdata<qt_meta_tag_ZN8ClipTypeE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN8ClipTypeE =
    qt_staticMetaObjectContent_ZN8ClipTypeE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN8ClipTypeE =
    qt_staticMetaObjectContent_ZN8ClipTypeE.relocatingData;

Q_CONSTINIT const QMetaObject ClipType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN8ClipTypeE.stringdata,
    qt_staticMetaObjectStaticContent_ZN8ClipTypeE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN8ClipTypeE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18SpeechToTextEngineE_t {};
} // unnamed namespace

template <> constexpr inline auto SpeechToTextEngine::qt_create_metaobjectdata<qt_meta_tag_ZN18SpeechToTextEngineE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SpeechToTextEngine",
        "QML.Element",
        "auto",
        "EngineType",
        "EngineNone",
        "EngineVosk",
        "EngineWhisper"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'EngineType'
        QtMocHelpers::EnumData<EngineType>(3, 3, QMC::EnumFlags{}).add({
            {    4, EngineType::EngineNone },
            {    5, EngineType::EngineVosk },
            {    6, EngineType::EngineWhisper },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN18SpeechToTextEngineE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN18SpeechToTextEngineE =
    SpeechToTextEngine::qt_create_metaobjectdata<qt_meta_tag_ZN18SpeechToTextEngineE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN18SpeechToTextEngineE =
    qt_staticMetaObjectContent_ZN18SpeechToTextEngineE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN18SpeechToTextEngineE =
    qt_staticMetaObjectContent_ZN18SpeechToTextEngineE.relocatingData;

Q_CONSTINIT const QMetaObject SpeechToTextEngine::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN18SpeechToTextEngineE.stringdata,
    qt_staticMetaObjectStaticContent_ZN18SpeechToTextEngineE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN18SpeechToTextEngineE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12KeyframeTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto KeyframeType::qt_create_metaobjectdata<qt_meta_tag_ZN12KeyframeTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KeyframeType",
        "QML.Element",
        "auto",
        "KeyframeEnum",
        "Linear",
        "Discrete",
        "Curve",
        "CurveSmooth",
        "BounceIn",
        "BounceOut",
        "CubicIn",
        "CubicOut",
        "ExponentialIn",
        "ExponentialOut",
        "CircularIn",
        "CircularOut",
        "ElasticIn",
        "ElasticOut"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'KeyframeEnum'
        QtMocHelpers::EnumData<KeyframeEnum>(3, 3, QMC::EnumFlags{}).add({
            {    4, KeyframeEnum::Linear },
            {    5, KeyframeEnum::Discrete },
            {    6, KeyframeEnum::Curve },
            {    7, KeyframeEnum::CurveSmooth },
            {    8, KeyframeEnum::BounceIn },
            {    9, KeyframeEnum::BounceOut },
            {   10, KeyframeEnum::CubicIn },
            {   11, KeyframeEnum::CubicOut },
            {   12, KeyframeEnum::ExponentialIn },
            {   13, KeyframeEnum::ExponentialOut },
            {   14, KeyframeEnum::CircularIn },
            {   15, KeyframeEnum::CircularOut },
            {   16, KeyframeEnum::ElasticIn },
            {   17, KeyframeEnum::ElasticOut },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN12KeyframeTypeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN12KeyframeTypeE =
    KeyframeType::qt_create_metaobjectdata<qt_meta_tag_ZN12KeyframeTypeE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN12KeyframeTypeE =
    qt_staticMetaObjectContent_ZN12KeyframeTypeE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN12KeyframeTypeE =
    qt_staticMetaObjectContent_ZN12KeyframeTypeE.relocatingData;

Q_CONSTINIT const QMetaObject KeyframeType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN12KeyframeTypeE.stringdata,
    qt_staticMetaObjectStaticContent_ZN12KeyframeTypeE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN12KeyframeTypeE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12MaskModeTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto MaskModeType::qt_create_metaobjectdata<qt_meta_tag_ZN12MaskModeTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MaskModeType",
        "QML.Element",
        "auto",
        "MaskCreationMode",
        "MaskNone",
        "MaskInput",
        "MaskEdit",
        "MaskPreview"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'MaskCreationMode'
        QtMocHelpers::EnumData<MaskCreationMode>(3, 3, QMC::EnumFlags{}).add({
            {    4, MaskCreationMode::MaskNone },
            {    5, MaskCreationMode::MaskInput },
            {    6, MaskCreationMode::MaskEdit },
            {    7, MaskCreationMode::MaskPreview },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN12MaskModeTypeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN12MaskModeTypeE =
    MaskModeType::qt_create_metaobjectdata<qt_meta_tag_ZN12MaskModeTypeE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN12MaskModeTypeE =
    qt_staticMetaObjectContent_ZN12MaskModeTypeE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN12MaskModeTypeE =
    qt_staticMetaObjectContent_ZN12MaskModeTypeE.relocatingData;

Q_CONSTINIT const QMetaObject MaskModeType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN12MaskModeTypeE.stringdata,
    qt_staticMetaObjectStaticContent_ZN12MaskModeTypeE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN12MaskModeTypeE.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN8ToolTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto ToolType::qt_create_metaobjectdata<qt_meta_tag_ZN8ToolTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ToolType",
        "QML.Element",
        "auto",
        "ProjectTool",
        "SelectTool",
        "RazorTool",
        "SpacerTool",
        "RippleTool",
        "RollTool",
        "SlipTool",
        "SlideTool",
        "MulticamTool"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ProjectTool'
        QtMocHelpers::EnumData<ProjectTool>(3, 3, QMC::EnumFlags{}).add({
            {    4, ProjectTool::SelectTool },
            {    5, ProjectTool::RazorTool },
            {    6, ProjectTool::SpacerTool },
            {    7, ProjectTool::RippleTool },
            {    8, ProjectTool::RollTool },
            {    9, ProjectTool::SlipTool },
            {   10, ProjectTool::SlideTool },
            {   11, ProjectTool::MulticamTool },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN8ToolTypeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN8ToolTypeE =
    ToolType::qt_create_metaobjectdata<qt_meta_tag_ZN8ToolTypeE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN8ToolTypeE =
    qt_staticMetaObjectContent_ZN8ToolTypeE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN8ToolTypeE =
    qt_staticMetaObjectContent_ZN8ToolTypeE.relocatingData;

Q_CONSTINIT const QMetaObject ToolType::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN8ToolTypeE.stringdata,
    qt_staticMetaObjectStaticContent_ZN8ToolTypeE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN8ToolTypeE.metaTypes,
    nullptr
} };

QT_WARNING_POP
