qgis.h

Go to the documentation of this file.

/***************************************************************************
                          qgis.h - QGIS namespace
                             -------------------
    begin                : Sat Jun 30 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGIS_H
#define QGIS_H
 
 
#include <QMetaEnum>
#include <cfloat>
#include <memory>
#include <cmath>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#ifdef SIP_RUN
% ModuleHeaderCode
#include <qgis.h>
% End
 
% ModuleCode
int QgisEvent = QEvent::User + 1;
% End
#endif
 
#ifndef SIP_RUN
// qHash implementation for scoped enum type
// https://gitlab.com/frostasm/programming-knowledge-base/-/snippets/20120
#define QHASH_FOR_CLASS_ENUM(T) \
  inline uint qHash(const T &t, uint seed) { \
    return ::qHash(static_cast<typename std::underlying_type<T>::type>(t), seed); \
  }
#define QHASH_FOR_CLASS_ENUM(T) \ …
#endif
 
class CORE_EXPORT Qgis
{
    Q_GADGET
    Q_CLASSINFO( "RegisterEnumClassesUnscoped", "false" )
 
  public:
 
    static QString version();
 
    static int versionInt();
 
    static QString releaseName();
 
    static const char *QGIS_DEV_VERSION;
 
    static QString devVersion();
 
    // Enumerations
    //
 
    enum class AuthConfigurationStorageCapability: int SIP_ENUM_BASETYPE( IntFlag )
    {
      ClearStorage = 1 << 0, 
 
      ReadConfiguration = 1 << 1, 
      UpdateConfiguration = 1 << 2, 
      DeleteConfiguration = 1 << 3, 
      CreateConfiguration = 1 << 4, 
 
      ReadCertificateIdentity = 1 << 5, 
      UpdateCertificateIdentity = 1 << 6, 
      DeleteCertificateIdentity = 1 << 7, 
      CreateCertificateIdentity = 1 << 8, 
 
      ReadSslCertificateCustomConfig = 1 << 9, 
      UpdateSslCertificateCustomConfig = 1 << 10, 
      DeleteSslCertificateCustomConfig = 1 << 11, 
      CreateSslCertificateCustomConfig = 1 << 12, 
 
      ReadCertificateAuthority = 1 << 13, 
      UpdateCertificateAuthority = 1 << 14, 
      DeleteCertificateAuthority = 1 << 15, 
      CreateCertificateAuthority = 1 << 16, 
 
      ReadCertificateTrustPolicy = 1 << 17, 
      UpdateCertificateTrustPolicy = 1 << 18, 
      DeleteCertificateTrustPolicy = 1 << 19, 
      CreateCertificateTrustPolicy = 1 << 20, 
 
      ReadMasterPassword = 1 << 21, 
      UpdateMasterPassword = 1 << 22, 
      DeleteMasterPassword = 1 << 23, 
      CreateMasterPassword = 1 << 24, 
 
      ReadSetting = 1 << 25, 
      UpdateSetting = 1 << 26, 
      DeleteSetting = 1 << 27, 
      CreateSetting = 1 << 28, 
 
    };
    enum class AuthConfigurationStorageCapability: int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( AuthConfigurationStorageCapability )
 
    
    Q_DECLARE_FLAGS( AuthConfigurationStorageCapabilities, AuthConfigurationStorageCapability )
    Q_FLAG( AuthConfigurationStorageCapabilities )
 
 
    enum MessageLevel
    {
      Info = 0, 
      Warning = 1, 
      Critical = 2, 
      Success = 3, 
      NoLevel = 4, 
    };
    enum MessageLevel {…};
    Q_ENUM( MessageLevel )
 
    
    enum class LayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapLayer, LayerType ) : int
      {
      Vector SIP_MONKEYPATCH_COMPAT_NAME( VectorLayer ), 
      Raster SIP_MONKEYPATCH_COMPAT_NAME( RasterLayer ), 
      Plugin SIP_MONKEYPATCH_COMPAT_NAME( PluginLayer ), 
      Mesh SIP_MONKEYPATCH_COMPAT_NAME( MeshLayer ),    
      VectorTile SIP_MONKEYPATCH_COMPAT_NAME( VectorTileLayer ), 
      Annotation SIP_MONKEYPATCH_COMPAT_NAME( AnnotationLayer ), 
      PointCloud SIP_MONKEYPATCH_COMPAT_NAME( PointCloudLayer ), 
      Group SIP_MONKEYPATCH_COMPAT_NAME( GroupLayer ), 
      TiledScene, 
    };
    enum class LayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapLayer, LayerType ) : int {…};
    Q_ENUM( LayerType )
 
    
    enum class LayerFilter SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapLayerProxyModel, Filter ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RasterLayer = 1,
      NoGeometry = 2,
      PointLayer = 4,
      LineLayer = 8,
      PolygonLayer = 16,
      HasGeometry = PointLayer | LineLayer | PolygonLayer,
      VectorLayer = NoGeometry | HasGeometry,
      PluginLayer = 32,
      WritableLayer = 64,
      MeshLayer = 128, 
      VectorTileLayer = 256, 
      PointCloudLayer = 512, 
      AnnotationLayer = 1024, 
      TiledSceneLayer = 2048, 
      All = RasterLayer | VectorLayer | PluginLayer | MeshLayer | VectorTileLayer | PointCloudLayer | AnnotationLayer | TiledSceneLayer, 
      SpatialLayer = RasterLayer | HasGeometry | PluginLayer | MeshLayer | VectorTileLayer | PointCloudLayer | AnnotationLayer | TiledSceneLayer 
    };
    enum class LayerFilter SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapLayerProxyModel, Filter ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( LayerFilters, LayerFilter )
    Q_FLAG( LayerFilters )
 
    
    enum class LoadStyleFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IgnoreMissingStyleErrors = 1 << 0, 
    };
    enum class LoadStyleFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LoadStyleFlag )
 
    
    Q_DECLARE_FLAGS( LoadStyleFlags, LoadStyleFlag )
    Q_FLAG( LoadStyleFlags )
 
    enum class WkbType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsWkbTypes, Type ) : quint32
      {
      Unknown =  0, 
      Point = 1, 
      LineString = 2, 
      Polygon = 3, 
      Triangle = 17, 
      MultiPoint = 4, 
      MultiLineString = 5, 
      MultiPolygon = 6, 
      GeometryCollection = 7, 
      CircularString = 8, 
      CompoundCurve = 9, 
      CurvePolygon = 10, 
      MultiCurve = 11, 
      MultiSurface = 12, 
      PolyhedralSurface = 15, 
      TIN = 16, 
      NoGeometry = 100, 
      PointZ = 1001, 
      LineStringZ = 1002, 
      PolygonZ = 1003, 
      TriangleZ = 1017, 
      MultiPointZ = 1004, 
      MultiLineStringZ = 1005, 
      MultiPolygonZ = 1006, 
      GeometryCollectionZ = 1007, 
      CircularStringZ = 1008, 
      CompoundCurveZ = 1009, 
      CurvePolygonZ = 1010, 
      MultiCurveZ = 1011, 
      MultiSurfaceZ = 1012, 
      PolyhedralSurfaceZ = 1015, 
      TINZ = 1016, 
      PointM = 2001, 
      LineStringM = 2002, 
      PolygonM = 2003, 
      TriangleM = 2017, 
      MultiPointM = 2004, 
      MultiLineStringM = 2005, 
      MultiPolygonM = 2006, 
      GeometryCollectionM = 2007, 
      CircularStringM = 2008, 
      CompoundCurveM = 2009, 
      CurvePolygonM = 2010, 
      MultiCurveM = 2011, 
      MultiSurfaceM = 2012, 
      PolyhedralSurfaceM = 2015, 
      TINM = 2016, 
      PointZM = 3001, 
      LineStringZM = 3002, 
      PolygonZM = 3003, 
      MultiPointZM = 3004, 
      MultiLineStringZM = 3005, 
      MultiPolygonZM = 3006, 
      GeometryCollectionZM = 3007, 
      CircularStringZM = 3008, 
      CompoundCurveZM = 3009, 
      CurvePolygonZM = 3010, 
      MultiCurveZM = 3011, 
      MultiSurfaceZM = 3012, 
      PolyhedralSurfaceZM = 3015, 
      TINZM = 3016, 
      TriangleZM = 3017, 
      Point25D = 0x80000001, 
      LineString25D, 
      Polygon25D, 
      MultiPoint25D, 
      MultiLineString25D, 
      MultiPolygon25D 
    };
    enum class WkbType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsWkbTypes, Type ) : quint32 {…};
    Q_ENUM( WkbType )
 
    
    enum class GeometryType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsWkbTypes, GeometryType ) : int
      {
      Point SIP_MONKEYPATCH_COMPAT_NAME( PointGeometry ), 
      Line SIP_MONKEYPATCH_COMPAT_NAME( LineGeometry ), 
      Polygon SIP_MONKEYPATCH_COMPAT_NAME( PolygonGeometry ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( UnknownGeometry ), 
      Null SIP_MONKEYPATCH_COMPAT_NAME( NullGeometry ), 
    };
    enum class GeometryType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsWkbTypes, GeometryType ) : int {…};
    Q_ENUM( GeometryType )
 
    
    enum class DataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, DataType ) : int
      {
      UnknownDataType = 0, 
      Byte = 1, 
      Int8 = 14, 
      UInt16 = 2, 
      Int16 = 3, 
      UInt32 = 4, 
      Int32 = 5, 
      Float32 = 6, 
      Float64 = 7, 
      CInt16 = 8, 
      CInt32 = 9, 
      CFloat32 = 10, 
      CFloat64 = 11, 
      ARGB32 = 12, 
      ARGB32_Premultiplied = 13 
    };
    enum class DataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, DataType ) : int {…};
    Q_ENUM( DataType )
 
    
    enum class CaptureTechnique : int
    {
      StraightSegments, 
      CircularString, 
      Streaming, 
      Shape, 
    };
    enum class CaptureTechnique : int {…};
    Q_ENUM( CaptureTechnique )
 
    
    enum class VectorLayerTypeFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SqlQuery = 1 << 0 
    };
    enum class VectorLayerTypeFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorLayerTypeFlag )
    Q_DECLARE_FLAGS( VectorLayerTypeFlags, VectorLayerTypeFlag )
    Q_FLAG( VectorLayerTypeFlags )
 
    enum class PythonEmbeddedMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, PythonMacroMode ) : int
      {
      Never = 0, 
      Ask = 1, 
      SessionOnly = 2, 
      Always = 3, 
      NotForThisSession, 
    };
    enum class PythonEmbeddedMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, PythonMacroMode ) : int {…};
    Q_ENUM( PythonEmbeddedMode )
 
    
    enum class PythonEmbeddedType : int
    {
      Macro = 0,
      ExpressionFunction = 1,
    };
    enum class PythonEmbeddedType : int {…};
    Q_ENUM( PythonEmbeddedType )
 
    
    enum class DataProviderReadFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataProvider, ReadFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      TrustDataSource SIP_MONKEYPATCH_COMPAT_NAME( FlagTrustDataSource ) = 1 << 0, 
      SkipFeatureCount = 1 << 1, 
      LoadDefaultStyle SIP_MONKEYPATCH_COMPAT_NAME( FlagLoadDefaultStyle ) = 1 << 2, 
      SkipGetExtent = 1 << 3, 
      SkipFullScan = 1 << 4, 
      ForceReadOnly = 1 << 5, 
      SkipCredentialsRequest =  1 << 6, 
      ParallelThreadLoading = 1 << 7, 
    };
    enum class DataProviderReadFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataProvider, ReadFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( DataProviderReadFlag )
 
    
    Q_DECLARE_FLAGS( DataProviderReadFlags, DataProviderReadFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataProvider, ReadFlags )
    Q_FLAG( DataProviderReadFlags )
 
    // TODO QGIS 4 -- remove NoCapabilities and rely on VectorProviderCapabilities() instead
 
    enum class VectorProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, Capability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0, 
      AddFeatures = 1, 
      DeleteFeatures = 1 <<  1, 
      ChangeAttributeValues = 1 <<  2, 
      AddAttributes = 1 <<  3, 
      DeleteAttributes = 1 <<  4, 
      CreateSpatialIndex = 1 <<  6, 
      SelectAtId = 1 <<  7, 
      ChangeGeometries = 1 <<  8, 
      SelectEncoding = 1 << 13, 
      CreateAttributeIndex = 1 << 12, 
      SimplifyGeometries = 1 << 14, 
      SimplifyGeometriesWithTopologicalValidation = 1 << 15, 
      TransactionSupport = 1 << 16, 
      CircularGeometries = 1 << 17, 
      ChangeFeatures = 1 << 18, 
      RenameAttributes = 1 << 19, 
      FastTruncate = 1 << 20, 
      ReadLayerMetadata = 1 << 21, 
      WriteLayerMetadata = 1 << 22, 
      CancelSupport = 1 << 23, 
      CreateRenderer = 1 << 24, 
      CreateLabeling = 1 << 25, 
      ReloadData = 1 << 26, 
      FeatureSymbology = 1 << 27, 
      EditingCapabilities = AddFeatures | DeleteFeatures | ChangeAttributeValues | ChangeGeometries | AddAttributes | DeleteAttributes | RenameAttributes, 
    };
    enum class VectorProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, Capability ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorProviderCapabilities, VectorProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsVectorDataProvider, Capabilities )
    Q_FLAG( VectorProviderCapabilities )
 
    enum class FeatureCountState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, FeatureCountState ) : int
      {
      Uncounted = -2, 
      UnknownCount = -1, 
    };
    enum class FeatureCountState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, FeatureCountState ) : int {…};
    Q_ENUM( FeatureCountState )
 
    
    enum class SpatialIndexPresence SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureSource, SpatialIndexPresence ) : int
      {
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( SpatialIndexUnknown ) = 0, 
      NotPresent SIP_MONKEYPATCH_COMPAT_NAME( SpatialIndexNotPresent ) = 1, 
      Present SIP_MONKEYPATCH_COMPAT_NAME( SpatialIndexPresent ) = 2, 
    };
    enum class SpatialIndexPresence SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureSource, SpatialIndexPresence ) : int {…};
    Q_ENUM( SpatialIndexPresence )
 
    
    enum class FeatureAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureSource, FeatureAvailability ) : int
      {
      NoFeaturesAvailable = 0, 
      FeaturesAvailable, 
      FeaturesMaybeAvailable 
    };
    enum class FeatureAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureSource, FeatureAvailability ) : int {…};
    Q_ENUM( FeatureAvailability )
 
    
    enum class VectorDataProviderAttributeEditCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      EditAlias = 1 << 0, 
      EditComment = 1 << 1, 
    };
    enum class VectorDataProviderAttributeEditCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_ENUM( VectorDataProviderAttributeEditCapability )
 
    
    Q_DECLARE_FLAGS( VectorDataProviderAttributeEditCapabilities, VectorDataProviderAttributeEditCapability )
    Q_FLAG( VectorDataProviderAttributeEditCapabilities )
 
    enum class SymbolType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, SymbolType ) : int
      {
      Marker, 
      Line, 
      Fill, 
      Hybrid 
    };
    enum class SymbolType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, SymbolType ) : int {…};
    Q_ENUM( SymbolType )
 
    
    enum class ScaleMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, ScaleMethod ) : int
      {
      ScaleArea,     
      ScaleDiameter  
    };
    enum class ScaleMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, ScaleMethod ) : int {…};
    Q_ENUM( ScaleMethod )
 
    
    enum class SettingsType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSettingsEntryBase, SettingsType ) : int
      {
      Custom, 
      Variant, 
      String, 
      StringList, 
      VariantMap, 
      Bool, 
      Integer, 
      Double, 
      EnumFlag, 
      Color 
    };
    enum class SettingsType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSettingsEntryBase, SettingsType ) : int {…};
    Q_ENUM( SettingsType )
 
    
    enum class SettingsTreeNodeType
    {
      Root, 
      Standard, 
      NamedList, 
    };
    enum class SettingsTreeNodeType {…};
    Q_ENUM( SettingsTreeNodeType )
 
    
    enum class SettingsTreeNodeOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NamedListSelectedItemSetting = 1 << 0, 
    };
    enum class SettingsTreeNodeOption : int SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_ENUM( SettingsTreeNodeOption )
    Q_DECLARE_FLAGS( SettingsTreeNodeOptions, SettingsTreeNodeOption )
    Q_FLAG( SettingsTreeNodeOptions )
 
    enum class PropertyType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProperty, Type ): int
      {
      Invalid SIP_MONKEYPATCH_COMPAT_NAME( InvalidProperty ), 
      Static SIP_MONKEYPATCH_COMPAT_NAME( StaticProperty ), 
      Field SIP_MONKEYPATCH_COMPAT_NAME( FieldBasedProperty ), 
      Expression SIP_MONKEYPATCH_COMPAT_NAME( ExpressionBasedProperty ), 
    };
    enum class PropertyType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProperty, Type ): int {…};
    Q_ENUM( PropertyType )
 
    
    enum class SldExportOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoOptions = 0,                      
      Svg = 1 << 0,                       
      Png = 1 << 1,                       
    };
    enum class SldExportOption : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SldExportOption )
    Q_DECLARE_FLAGS( SldExportOptions, SldExportOption )
    Q_FLAG( SldExportOptions )
 
    enum class SldExportVendorExtension : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoVendorExtension = 0,             
      GeoServerVendorExtension = 1 << 1, 
      DeegreeVendorExtension = 1 << 2,   
    };
    enum class SldExportVendorExtension : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SldExportVendorExtension )
 
 
    
    enum class SettingsOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SaveFormerValue = 1 << 1, 
      SaveEnumFlagAsInt = 1 << 2, 
    };
    enum class SettingsOption : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SettingsOption )
    Q_DECLARE_FLAGS( SettingsOptions, SettingsOption )
    Q_FLAG( SettingsOptions )
 
    enum class SnappingMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSnappingConfig, SnappingMode ) : int
      {
      ActiveLayer = 1, 
      AllLayers = 2, 
      AdvancedConfiguration = 3, 
    };
    enum class SnappingMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSnappingConfig, SnappingMode ) : int {…};
    Q_ENUM( SnappingMode )
 
    
    enum class SnappingType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSnappingConfig, SnappingTypes ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoSnap SIP_MONKEYPATCH_COMPAT_NAME( NoSnapFlag ) = 0, 
      Vertex SIP_MONKEYPATCH_COMPAT_NAME( VertexFlag ) = 1 << 0, 
      Segment SIP_MONKEYPATCH_COMPAT_NAME( SegmentFlag ) = 1 << 1, 
      Area SIP_MONKEYPATCH_COMPAT_NAME( AreaFlag ) = 1 << 2, 
      Centroid SIP_MONKEYPATCH_COMPAT_NAME( CentroidFlag ) = 1 << 3, 
      MiddleOfSegment SIP_MONKEYPATCH_COMPAT_NAME( MiddleOfSegmentFlag ) = 1 << 4, 
      LineEndpoint SIP_MONKEYPATCH_COMPAT_NAME( LineEndpointFlag ) = 1 << 5, 
    };
    enum class SnappingType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSnappingConfig, SnappingTypes ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SnappingType )
    Q_DECLARE_FLAGS( SnappingTypes, SnappingType ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSnappingConfig, SnappingTypeFlag )
    Q_FLAG( SnappingTypes )
 
    enum class SymbolRenderHint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, RenderHint ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DynamicRotation = 1 << 1, 
      IsSymbolLayerSubSymbol = 1 << 2, 
      ForceVectorRendering = 1 << 3, 
      ExcludeSymbolBuffers = 1 << 4, 
    };
    enum class SymbolRenderHint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, RenderHint ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SymbolRenderHint )
    Q_DECLARE_FLAGS( SymbolRenderHints, SymbolRenderHint ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, RenderHints )
    Q_FLAG( SymbolRenderHints )
 
    enum class SymbolRotationMode : int
    {
      RespectMapRotation, 
      IgnoreMapRotation, 
    };
    enum class SymbolRotationMode : int {…};
    Q_ENUM( SymbolRotationMode )
 
 
    
    enum class HorizontalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, HorizontalAnchorPoint ) : int
      {
      Left, 
      Center SIP_MONKEYPATCH_COMPAT_NAME( HCenter ), 
      Right, 
    };
    enum class HorizontalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, HorizontalAnchorPoint ) : int {…};
    Q_ENUM( HorizontalAnchorPoint )
 
    
    enum class VerticalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, VerticalAnchorPoint ) : int
      {
      Top, 
      Center SIP_MONKEYPATCH_COMPAT_NAME( VCenter ), 
      Bottom, 
      Baseline, 
    };
    enum class VerticalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, VerticalAnchorPoint ) : int {…};
    Q_ENUM( VerticalAnchorPoint )
 
    
    enum class FeatureRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AffectsLabeling = 1 << 0, 
    };
    enum class FeatureRendererFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( FeatureRendererFlag )
 
    
    Q_DECLARE_FLAGS( FeatureRendererFlags, FeatureRendererFlag )
    Q_FLAG( FeatureRendererFlags )
 
    enum class SymbolFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RendererShouldUseSymbolLevels = 1 << 0, 
      AffectsLabeling = 1 << 1, 
    };
    enum class SymbolFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SymbolFlag )
    Q_DECLARE_FLAGS( SymbolFlags, SymbolFlag )
    Q_FLAG( SymbolFlags )
 
    enum class SymbolPreviewFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, PreviewFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FlagIncludeCrosshairsForMarkerSymbols = 1 << 0, 
    };
    enum class SymbolPreviewFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, PreviewFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SymbolPreviewFlag )
    Q_DECLARE_FLAGS( SymbolPreviewFlags, SymbolPreviewFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, SymbolPreviewFlags )
    Q_FLAG( SymbolPreviewFlags )
 
    enum class SymbolLayerFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DisableFeatureClipping = 1 << 0, 
      CanCalculateMaskGeometryPerFeature = 1 << 1, 
      AffectsLabeling = 1 << 2, 
    };
    enum class SymbolLayerFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SymbolLayerFlag )
    Q_DECLARE_FLAGS( SymbolLayerFlags, SymbolLayerFlag )
    Q_FLAG( SymbolLayerFlags )
 
    enum class SymbolLayerUserFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DisableSelectionRecoloring = 1 << 0, 
    };
    enum class SymbolLayerUserFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SymbolLayerUserFlag )
 
    
    Q_DECLARE_FLAGS( SymbolLayerUserFlags, SymbolLayerUserFlag )
    Q_FLAG( SymbolLayerUserFlags )
 
    enum class BrowserItemType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, Type ) : int
      {
      Collection, 
      Directory, 
      Layer, 
      Error, 
      Favorites, 
      Project, 
      Custom, 
      Fields, 
      Field, 
    };
    enum class BrowserItemType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, Type ) : int {…};
    Q_ENUM( BrowserItemType )
 
    
    enum class BrowserItemState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, State ) : int
      {
      NotPopulated, 
      Populating, 
      Populated, 
    };
    enum class BrowserItemState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, State ) : int {…};
    Q_ENUM( BrowserItemState )
 
    
    enum class BrowserItemCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, Capability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0, 
      SetCrs = 1 << 0, 
      Fertile = 1 << 1, 
      Fast = 1 << 2, 
      Collapse = 1 << 3, 
      Rename = 1 << 4, 
      Delete = 1 << 5, 
      ItemRepresentsFile = 1 << 6, 
      RefreshChildrenWhenItemIsRefreshed = 1 << 7, 
      ReadOnly = 1 << 8, 
    };
    enum class BrowserItemCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, Capability ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( BrowserItemCapability )
    Q_DECLARE_FLAGS( BrowserItemCapabilities, BrowserItemCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataItem, Capabilities )
    Q_FLAG( BrowserItemCapabilities )
 
    enum class DataItemProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataProvider, DataCapability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities SIP_MONKEYPATCH_COMPAT_NAME( NoDataCapabilities ) = 0, 
      Files SIP_MONKEYPATCH_COMPAT_NAME( File ) = 1, 
      Directories SIP_MONKEYPATCH_COMPAT_NAME( Dir ) = 1 << 1, 
      Databases SIP_MONKEYPATCH_COMPAT_NAME( Database ) = 1 << 2, 
      NetworkSources SIP_MONKEYPATCH_COMPAT_NAME( Net ) = 1 << 3, 
    };
    enum class DataItemProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataProvider, DataCapability ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( DataItemProviderCapability )
 
    
    Q_DECLARE_FLAGS( DataItemProviderCapabilities, DataItemProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataProvider, DataCapabilities )
    Q_FLAG( DataItemProviderCapabilities )
 
    enum class BrowserLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayerItem, LayerType ) : int
      {
      NoType, 
      Vector, 
      Raster, 
      Point, 
      Line, 
      Polygon, 
      TableLayer, 
      Database, 
      Table, 
      Plugin, 
      Mesh, 
      VectorTile, 
      PointCloud, 
      TiledScene, 
    };
    enum class BrowserLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayerItem, LayerType ) : int {…};
    Q_ENUM( BrowserLayerType )
 
    
    enum class BrowserDirectoryMonitoring : int
    {
      Default, 
      NeverMonitor, 
      AlwaysMonitor, 
    };
    enum class BrowserDirectoryMonitoring : int {…};
    Q_ENUM( BrowserDirectoryMonitoring )
 
    
    enum class HttpMethod : int
    {
      Get = 0, 
      Post = 1, 
      Head, 
      Put, 
      Delete, 
    };
    enum class HttpMethod : int {…};
    Q_ENUM( HttpMethod )
 
    
    enum class VectorExportResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayerExporter, ExportError ) : int
      {
      Success SIP_MONKEYPATCH_COMPAT_NAME( NoError ) = 0, 
      ErrorCreatingDataSource SIP_MONKEYPATCH_COMPAT_NAME( ErrCreateDataSource ), 
      ErrorCreatingLayer SIP_MONKEYPATCH_COMPAT_NAME( ErrCreateLayer ), 
      ErrorAttributeTypeUnsupported SIP_MONKEYPATCH_COMPAT_NAME( ErrAttributeTypeUnsupported ), 
      ErrorAttributeCreationFailed SIP_MONKEYPATCH_COMPAT_NAME( ErrAttributeCreationFailed ), 
      ErrorProjectingFeatures SIP_MONKEYPATCH_COMPAT_NAME( ErrProjection ), 
      ErrorFeatureWriteFailed SIP_MONKEYPATCH_COMPAT_NAME( ErrFeatureWriteFailed ), 
      ErrorInvalidLayer SIP_MONKEYPATCH_COMPAT_NAME( ErrInvalidLayer ), 
      ErrorInvalidProvider SIP_MONKEYPATCH_COMPAT_NAME( ErrInvalidProvider ), 
      ErrorProviderUnsupportedFeature SIP_MONKEYPATCH_COMPAT_NAME( ErrProviderUnsupportedFeature ), 
      ErrorConnectionFailed SIP_MONKEYPATCH_COMPAT_NAME( ErrConnectionFailed ), 
      UserCanceled SIP_MONKEYPATCH_COMPAT_NAME( ErrUserCanceled ), 
    };
    enum class VectorExportResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayerExporter, ExportError ) : int {…};
    Q_ENUM( VectorExportResult )
 
    
    enum class VectorFileWriterCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FieldAliases = 1 << 0, 
      FieldComments = 1 << 2, 
    };
    enum class VectorFileWriterCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorFileWriterCapability )
 
    
    Q_DECLARE_FLAGS( VectorFileWriterCapabilities, VectorFileWriterCapability )
    Q_FLAG( VectorFileWriterCapabilities )
 
    enum class SqlLayerDefinitionCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SubsetStringFilter = 1 << 1,  
      GeometryColumn = 1 << 2,      
      PrimaryKeys = 1 << 3,         
      UnstableFeatureIds = 1 << 4   
    };
    enum class SqlLayerDefinitionCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( SqlLayerDefinitionCapability )
    Q_DECLARE_FLAGS( SqlLayerDefinitionCapabilities, SqlLayerDefinitionCapability )
    Q_FLAG( SqlLayerDefinitionCapabilities )
 
    enum class SqlKeywordCategory : int
    {
      Keyword,      
      Constant,     
      Function,     
      Geospatial,   
      Operator,     
      Math,         
      Aggregate,    
      String,       
      Identifier    
    };
    enum class SqlKeywordCategory : int {…};
    Q_ENUM( SqlKeywordCategory )
 
    
    enum class DriveType : int
    {
      Unknown, 
      Invalid, 
      Removable, 
      Fixed, 
      Remote, 
      CdRom, 
      RamDisk, 
      Cloud, 
    };
    enum class DriveType : int {…};
    Q_ENUM( DriveType )
 
    
    enum class ActionStart SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsNetworkContentFetcherRegistry, FetchingMode ) : int
      {
      Deferred SIP_MONKEYPATCH_COMPAT_NAME( DownloadLater ), 
      Immediate SIP_MONKEYPATCH_COMPAT_NAME( DownloadImmediately ), 
    };
    enum class ActionStart SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsNetworkContentFetcherRegistry, FetchingMode ) : int {…};
    Q_ENUM( ActionStart )
 
    
    enum class UnplacedLabelVisibility : int
    {
      FollowEngineSetting, 
      NeverShow, 
    };
    enum class UnplacedLabelVisibility : int {…};
    Q_ENUM( UnplacedLabelVisibility )
 
    
    enum class LabelOverlapHandling : int
    {
      PreventOverlap, 
      AllowOverlapIfRequired, 
      AllowOverlapAtNoCost, 
    };
    enum class LabelOverlapHandling : int {…};
    Q_ENUM( LabelOverlapHandling )
 
    
    enum class LabelPrioritization : int
    {
      PreferCloser, 
      PreferPositionOrdering, 
    };
    enum class LabelPrioritization : int {…};
    Q_ENUM( LabelPrioritization )
 
    
    enum class LabelPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, Placement ) : int
      {
      AroundPoint, 
      OverPoint, 
      Line, 
      Curved, 
      Horizontal, 
      Free, 
      OrderedPositionsAroundPoint, 
      PerimeterCurved, 
      OutsidePolygons, 
    };
    enum class LabelPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, Placement ) : int {…};
    Q_ENUM( LabelPlacement )
 
    
    enum class LabelPredefinedPointPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, PredefinedPointPosition ) : int
      {
      TopLeft, 
      TopSlightlyLeft, 
      TopMiddle, 
      TopSlightlyRight, 
      TopRight, 
      MiddleLeft, 
      MiddleRight, 
      BottomLeft, 
      BottomSlightlyLeft, 
      BottomMiddle, 
      BottomSlightlyRight, 
      BottomRight, 
      OverPoint, 
    };
    enum class LabelPredefinedPointPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, PredefinedPointPosition ) : int {…};
    Q_ENUM( LabelPredefinedPointPosition )
 
    
    enum class LabelOffsetType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, OffsetType ) : int
      {
      FromPoint, 
      FromSymbolBounds, 
    };
    enum class LabelOffsetType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, OffsetType ) : int {…};
    Q_ENUM( LabelOffsetType )
 
    
    enum class LabelQuadrantPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, QuadrantPosition ) : int
      {
      AboveLeft SIP_MONKEYPATCH_COMPAT_NAME( QuadrantAboveLeft ), 
      Above SIP_MONKEYPATCH_COMPAT_NAME( QuadrantAbove ), 
      AboveRight SIP_MONKEYPATCH_COMPAT_NAME( QuadrantAboveRight ), 
      Left SIP_MONKEYPATCH_COMPAT_NAME( QuadrantLeft ), 
      Over SIP_MONKEYPATCH_COMPAT_NAME( QuadrantOver ), 
      Right SIP_MONKEYPATCH_COMPAT_NAME( QuadrantRight ), 
      BelowLeft SIP_MONKEYPATCH_COMPAT_NAME( QuadrantBelowLeft ), 
      Below SIP_MONKEYPATCH_COMPAT_NAME( QuadrantBelow ), 
      BelowRight SIP_MONKEYPATCH_COMPAT_NAME( QuadrantBelowRight ), 
    };
    enum class LabelQuadrantPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, QuadrantPosition ) : int {…};
    Q_ENUM( LabelQuadrantPosition )
 
    
    enum class LabelLinePlacementFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabeling, LinePlacementFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      OnLine = 1, 
      AboveLine = 2, 
      BelowLine = 4, 
      MapOrientation = 8, 
    };
    enum class LabelLinePlacementFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabeling, LinePlacementFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LabelLinePlacementFlag )
 
    
    Q_DECLARE_FLAGS( LabelLinePlacementFlags, LabelLinePlacementFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsLabeling, LinePlacementFlags )
    Q_FLAG( LabelLinePlacementFlags )
 
    enum class LabelPolygonPlacementFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabeling, PolygonPlacementFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AllowPlacementOutsideOfPolygon = 1 << 0, 
      AllowPlacementInsideOfPolygon = 1 << 1, 
    };
    enum class LabelPolygonPlacementFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabeling, PolygonPlacementFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LabelPolygonPlacementFlag )
 
    
    Q_DECLARE_FLAGS( LabelPolygonPlacementFlags, LabelPolygonPlacementFlag )
    Q_FLAG( LabelPolygonPlacementFlags )
 
    enum class UpsideDownLabelHandling SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, UpsideDownLabels ) : int
      {
      FlipUpsideDownLabels SIP_MONKEYPATCH_COMPAT_NAME( Upright ), 
      AllowUpsideDownWhenRotationIsDefined SIP_MONKEYPATCH_COMPAT_NAME( ShowDefined ), 
      AlwaysAllowUpsideDown SIP_MONKEYPATCH_COMPAT_NAME( ShowAll ) 
    };
    enum class UpsideDownLabelHandling SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, UpsideDownLabels ) : int {…};
    Q_ENUM( UpsideDownLabelHandling )
 
    
    enum class LabelMultiLineAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, MultiLineAlign ) : int
      {
      Left SIP_MONKEYPATCH_COMPAT_NAME( MultiLeft ) = 0, 
      Center SIP_MONKEYPATCH_COMPAT_NAME( MultiCenter ), 
      Right SIP_MONKEYPATCH_COMPAT_NAME( MultiRight ), 
      FollowPlacement SIP_MONKEYPATCH_COMPAT_NAME( MultiFollowPlacement ), 
      Justify SIP_MONKEYPATCH_COMPAT_NAME( MultiJustify ), 
    };
    enum class LabelMultiLineAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, MultiLineAlign ) : int {…};
    Q_ENUM( LabelMultiLineAlignment )
 
    
    enum class FileFilterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProviderMetadata, FilterType ) : int
      {
      Vector SIP_MONKEYPATCH_COMPAT_NAME( FilterVector ) = 1, 
      Raster SIP_MONKEYPATCH_COMPAT_NAME( FilterRaster ), 
      Mesh SIP_MONKEYPATCH_COMPAT_NAME( FilterMesh ), 
      MeshDataset SIP_MONKEYPATCH_COMPAT_NAME( FilterMeshDataset ), 
      PointCloud SIP_MONKEYPATCH_COMPAT_NAME( FilterPointCloud ), 
      VectorTile, 
      TiledScene, 
    };
    enum class FileFilterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProviderMetadata, FilterType ) : int {…};
    Q_ENUM( FileFilterType )
 
    
    enum class UriCleaningFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RemoveCredentials = 1 << 0, 
      RedactCredentials = 1 << 1, 
    };
    enum class UriCleaningFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( UriCleaningFlag )
 
    
    Q_DECLARE_FLAGS( UriCleaningFlags, UriCleaningFlag )
    Q_FLAG( UriCleaningFlags )
 
    enum class SublayerQueryFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FastScan = 1 << 0, 
      ResolveGeometryType = 1 << 1, 
      CountFeatures = 1 << 2, 
      IncludeSystemTables = 1 << 3, 
    };
    enum class SublayerQueryFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( SublayerQueryFlags, SublayerQueryFlag )
    Q_ENUM( SublayerQueryFlag )
    Q_FLAG( SublayerQueryFlags )
 
    
    enum class SublayerFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SystemTable = 1 << 0, 
    };
    enum class SublayerFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( SublayerFlags, SublayerFlag )
    Q_ENUM( SublayerFlag )
    Q_FLAG( SublayerFlags )
 
    
    enum class ShaderInterpolationMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsColorRampShader, Type ) : int
      {
      Linear SIP_MONKEYPATCH_COMPAT_NAME( Interpolated ) = 0, 
      Discrete = 1, 
      Exact = 2, 
    };
    enum class ShaderInterpolationMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsColorRampShader, Type ) : int {…};
    Q_ENUM( ShaderInterpolationMethod )
 
    
    enum class ShaderClassificationMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsColorRampShader, ClassificationMode ) : int
      {
      Continuous = 1, 
      EqualInterval = 2, 
      Quantile = 3, 
    };
    enum class ShaderClassificationMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsColorRampShader, ClassificationMode ) : int {…};
    Q_ENUM( ShaderClassificationMethod )
 
    
    enum class RasterPipeInterfaceRole SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterPipe, Role ) : int
      {
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( UnknownRole ) = 0, 
      Provider SIP_MONKEYPATCH_COMPAT_NAME( ProviderRole ) = 1, 
      Renderer SIP_MONKEYPATCH_COMPAT_NAME( RendererRole ) = 2, 
      Brightness SIP_MONKEYPATCH_COMPAT_NAME( BrightnessRole ) = 3, 
      Resampler SIP_MONKEYPATCH_COMPAT_NAME( ResamplerRole ) = 4, 
      Projector SIP_MONKEYPATCH_COMPAT_NAME( ProjectorRole ) = 5, 
      Nuller SIP_MONKEYPATCH_COMPAT_NAME( NullerRole ) = 6, 
      HueSaturation SIP_MONKEYPATCH_COMPAT_NAME( HueSaturationRole ) = 7, 
    };
    enum class RasterPipeInterfaceRole SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterPipe, Role ) : int {…};
    Q_ENUM( RasterPipeInterfaceRole )
 
    
    enum class RasterResamplingStage SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterPipe, ResamplingStage ) : int
      {
      ResampleFilter, 
      Provider, 
    };
    enum class RasterResamplingStage SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterPipe, ResamplingStage ) : int {…};
    Q_ENUM( RasterResamplingStage )
 
    
    enum class RasterResamplingMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ResamplingMethod ) : int
      {
      Nearest, 
      Bilinear, 
      Cubic, 
      CubicSpline, 
      Lanczos, 
      Average, 
      Mode, 
      Gauss 
    };
    enum class RasterResamplingMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ResamplingMethod ) : int {…};
    Q_ENUM( RasterResamplingMethod )
 
    
    enum class RasterRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      InternalLayerOpacityHandling = 1 << 0, 
      UseNoDataForOutOfRangePixels = 1 << 1, 
    };
    enum class RasterRendererFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_DECLARE_FLAGS( RasterRendererFlags, RasterRendererFlag )
 
    Q_ENUM( RasterRendererFlag )
    Q_FLAG( RasterRendererFlags )
 
    
    enum class RasterRendererCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      UsesMultipleBands = 1 << 0, 
    };
    enum class RasterRendererCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterRendererCapability )
 
    
    Q_DECLARE_FLAGS( RasterRendererCapabilities, RasterRendererCapability )
    Q_FLAG( RasterRendererCapabilities )
 
    enum class RasterRangeLimit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, Limits ) : int
      {
      NotSet SIP_MONKEYPATCH_COMPAT_NAME( None_ ), 
      MinimumMaximum SIP_MONKEYPATCH_COMPAT_NAME( MinMax ), 
      StdDev, 
      CumulativeCut 
    };
    enum class RasterRangeLimit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, Limits ) : int {…};
    Q_ENUM( RasterRangeLimit )
 
    
    enum class RasterRangeExtent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, Extent ) : int
      {
      WholeRaster SIP_MONKEYPATCH_COMPAT_NAME( None_ ), 
      FixedCanvas SIP_MONKEYPATCH_COMPAT_NAME( CurrentCanvas ), 
      UpdatedCanvas, 
    };
    enum class RasterRangeExtent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, Extent ) : int {…};
    Q_ENUM( RasterRangeExtent )
 
    
    enum class RasterRangeAccuracy SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, StatAccuracy ): int
      {
      Exact, 
      Estimated, 
    };
    enum class RasterRangeAccuracy SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, StatAccuracy ): int {…};
    Q_ENUM( RasterRangeAccuracy )
 
    
    enum class RasterAttributeTableFieldUsage : int
    {
      Generic = 0, 
      PixelCount = 1, 
      Name = 2, 
      Min = 3, 
      Max = 4, 
      MinMax = 5, 
      Red = 6, 
      Green = 7, 
      Blue = 8, 
      Alpha = 9, 
      RedMin = 10, 
      GreenMin = 11, 
      BlueMin = 12, 
      AlphaMin = 13, 
      RedMax = 14, 
      GreenMax = 15, 
      BlueMax = 16, 
      AlphaMax = 17, 
      MaxCount   
    };
    enum class RasterAttributeTableFieldUsage : int {…};
    Q_ENUM( RasterAttributeTableFieldUsage )
 
    
    enum class RasterAttributeTableType : int
    {
      Thematic = 0,
      Athematic = 1
    };
    enum class RasterAttributeTableType : int {…};
    Q_ENUM( RasterAttributeTableType )
 
    
    enum class RasterExportType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterFileWriter, Mode ) : int
      {
      Raw = 0, 
      RenderedImage SIP_MONKEYPATCH_COMPAT_NAME( Image ) = 1 
    };
    enum class RasterExportType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterFileWriter, Mode ) : int {…};
    Q_ENUM( RasterExportType )
 
    
    enum class RasterFileWriterResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterFileWriter, WriterError ) : int
      {
      Success SIP_MONKEYPATCH_COMPAT_NAME( NoError ) = 0, 
      SourceProviderError = 1, 
      DestinationProviderError SIP_MONKEYPATCH_COMPAT_NAME( DestProviderError ) = 2, 
      CreateDatasourceError = 3, 
      WriteError = 4, 
      NoDataConflict = 5, 
      Canceled SIP_MONKEYPATCH_COMPAT_NAME( WriteCanceled ) = 6, 
    };
    enum class RasterFileWriterResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterFileWriter, WriterError ) : int {…};
    Q_ENUM( RasterFileWriterResult )
 
    
    enum class MeshEditingErrorType : int
    {
      NoError, 
      InvalidFace, 
      TooManyVerticesInFace, 
      FlatFace, 
      UniqueSharedVertex, 
      InvalidVertex, 
      ManifoldFace, 
    };
    enum class MeshEditingErrorType : int {…};
    Q_ENUM( MeshEditingErrorType )
 
    
    enum class FilePathType : int
    {
      Absolute, 
      Relative, 
    };
    enum class FilePathType : int {…};
    Q_ENUM( FilePathType )
 
    
    enum class SublayerPromptMode : int
    {
      AlwaysAsk, 
      AskExcludingRasterBands, 
      NeverAskSkip, 
      NeverAskLoadAll, 
    };
    enum class SublayerPromptMode : int {…};
    Q_ENUM( SublayerPromptMode )
 
    
    enum class FieldOrigin SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFields, FieldOrigin ) : int
      {
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( OriginUnknown ), 
      Provider SIP_MONKEYPATCH_COMPAT_NAME( OriginProvider ), 
      Join SIP_MONKEYPATCH_COMPAT_NAME( OriginJoin ), 
      Edit SIP_MONKEYPATCH_COMPAT_NAME( OriginEdit ), 
      Expression SIP_MONKEYPATCH_COMPAT_NAME( OriginExpression ) 
    };
    enum class FieldOrigin SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFields, FieldOrigin ) : int {…};
    Q_ENUM( FieldOrigin )
 
    
    enum class FieldConfigurationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoFlag = 0, 
      NotSearchable = 1 << 1, 
      HideFromWms = 1 << 2, 
      HideFromWfs = 1 << 3, 
    };
    enum class FieldConfigurationFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( FieldConfigurationFlag )
 
    
    Q_DECLARE_FLAGS( FieldConfigurationFlags, FieldConfigurationFlag )
    Q_FLAG( FieldConfigurationFlags )
 
    enum class FieldMetadataProperty : int
    {
      GeometryCrs = 0x1000, 
      GeometryWkbType = 0x1001, 
      CustomProperty = 0x100000, 
    };
    enum class FieldMetadataProperty : int {…};
    Q_ENUM( FieldMetadataProperty )
 
    
    enum class SelectionRenderingMode : int
    {
      Default, 
      CustomColor, 
      CustomSymbol, 
    };
    enum class SelectionRenderingMode : int {…};
    Q_ENUM( SelectionRenderingMode )
 
    
    enum class SelectBehavior SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayer, SelectBehavior ) : int
      {
      SetSelection, 
      AddToSelection, 
      IntersectSelection, 
      RemoveFromSelection, 
    };
    enum class SelectBehavior SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayer, SelectBehavior ) : int {…};
    Q_ENUM( SelectBehavior )
 
    
    enum class SelectGeometryRelationship : int
    {
      Intersect, 
      Within, 
    };
    enum class SelectGeometryRelationship : int {…};
    Q_ENUM( SelectGeometryRelationship )
 
    
    enum class SelectionFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SingleFeatureSelection = 1 << 0, 
      ToggleSelection = 1 << 1, 
    };
    enum class SelectionFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_DECLARE_FLAGS( SelectionFlags, SelectionFlag )
 
    Q_ENUM( SelectionFlag )
    Q_FLAG( SelectionFlags )
 
    
    enum class VectorEditResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayer, EditResult ) : int
      {
      Success = 0, 
      EmptyGeometry = 1, 
      EditFailed = 2, 
      FetchFeatureFailed = 3, 
      InvalidLayer = 4, 
    };
    enum class VectorEditResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayer, EditResult ) : int {…};
    Q_ENUM( VectorEditResult )
 
    
    enum class VertexMarkerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbolLayerUtils, VertexMarkerType ) : int
      {
      SemiTransparentCircle, 
      Cross, 
      NoMarker, 
    };
    enum class VertexMarkerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbolLayerUtils, VertexMarkerType ) : int {…};
    Q_ENUM( VertexMarkerType )
 
    
    enum class ContentStatus : int
    {
      NotStarted, 
      Running, 
      Finished, 
      Failed, 
      Canceled, 
    };
    enum class ContentStatus : int {…};
    Q_ENUM( ContentStatus )
 
    
    enum class GpsConnectionType : int
    {
      Automatic, 
      Internal, 
      Serial, 
      Gpsd, 
    };
    enum class GpsConnectionType : int {…};
    Q_ENUM( GpsConnectionType )
 
    
    enum class DeviceConnectionStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, GpsConnectionStatus ) : int
      {
      Disconnected, 
      Connecting, 
      Connected, 
    };
    enum class DeviceConnectionStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, GpsConnectionStatus ) : int {…};
    Q_ENUM( DeviceConnectionStatus )
 
    
    enum class GpsFixStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGpsInformation, FixStatus ) : int
      {
      NoData, 
      NoFix, 
      Fix2D, 
      Fix3D 
    };
    enum class GpsFixStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGpsInformation, FixStatus ) : int {…};
    Q_ENUM( GpsFixStatus );
 
 
    enum class GnssConstellation
    {
      Unknown, 
      Gps, 
      Glonass, 
      Galileo, 
      BeiDou, 
      Qzss, 
      Navic, 
      Sbas, 
    };
    enum class GnssConstellation {…};
    Q_ENUM( GnssConstellation );
 
    enum class GpsQualityIndicator
    {
      Unknown = -1, 
      Invalid, 
      GPS, 
      DGPS, 
      PPS, 
      RTK, 
      FloatRTK, 
      Estimated, 
      Manual, 
      Simulation, 
    };
    enum class GpsQualityIndicator {…};
    Q_ENUM( GpsQualityIndicator )
 
    
    enum class GpsNavigationStatus : int
    {
      NotValid, 
      Safe, 
      Caution, 
      Unsafe, 
    };
    enum class GpsNavigationStatus : int {…};
    Q_ENUM( GpsNavigationStatus );
 
    enum class GpsInformationComponent : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Location = 1 << 0, 
      Altitude = 1 << 1, 
      GroundSpeed = 1 << 2, 
      Bearing = 1 << 3, 
      TotalTrackLength = 1 << 4, 
      TrackDistanceFromStart = 1 << 5, 
      Pdop = 1 << 6, 
      Hdop = 1 << 7, 
      Vdop = 1 << 8, 
      HorizontalAccuracy = 1 << 9, 
      VerticalAccuracy = 1 << 10, 
      HvAccuracy = 1 << 11, 
      SatellitesUsed = 1 << 12, 
      Timestamp = 1 << 13, 
      TrackStartTime = 1 << 14, 
      TrackEndTime = 1 << 15, 
      TrackDistanceSinceLastPoint = 1 << 16, 
      TrackTimeSinceLastPoint = 1 << 17, 
      GeoidalSeparation = 1 << 18, 
      EllipsoidAltitude = 1 << 19, 
    };
    enum class GpsInformationComponent : int SIP_ENUM_BASETYPE( IntFlag ) {…};
 
    Q_DECLARE_FLAGS( GpsInformationComponents, GpsInformationComponent )
    Q_ENUM( GpsInformationComponent )
    Q_FLAG( GpsInformationComponents )
 
    
    enum class BabelFormatCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Import = 1 << 0, 
      Export = 1 << 1, 
      Waypoints = 1 << 2, 
      Routes = 1 << 3, 
      Tracks = 1 << 4, 
    };
    enum class BabelFormatCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( BabelFormatCapabilities, BabelFormatCapability )
    Q_ENUM( BabelFormatCapability )
    Q_FLAG( BabelFormatCapabilities )
 
    
    enum class BabelCommandFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      QuoteFilePaths = 1 << 0, 
    };
    enum class BabelCommandFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( BabelCommandFlags, BabelCommandFlag )
    Q_ENUM( BabelCommandFlag )
    Q_FLAG( BabelCommandFlags )
 
    
    enum class GpsFeatureType : int
    {
      Waypoint, 
      Route, 
      Track, 
    };
    enum class GpsFeatureType : int {…};
    Q_ENUM( GpsFeatureType )
 
    
    enum class GeometryOperationResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, OperationResult ) : int
      {
      Success = 0, 
      NothingHappened = 1000, 
      InvalidBaseGeometry, 
      InvalidInputGeometryType, 
      SelectionIsEmpty, 
      SelectionIsGreaterThanOne, 
      GeometryEngineError, 
      LayerNotEditable, 
      // Add part issues
      AddPartSelectedGeometryNotFound, 
      AddPartNotMultiGeometry, 
      // Add ring issues
      AddRingNotClosed, 
      AddRingNotValid, 
      AddRingCrossesExistingRings, 
      AddRingNotInExistingFeature, 
      // Split features
      SplitCannotSplitPoint, 
      GeometryTypeHasChanged, 
    };
    enum class GeometryOperationResult SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, OperationResult ) : int {…};
    Q_ENUM( GeometryOperationResult )
 
    
    enum class GeometryValidityFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, ValidityFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AllowSelfTouchingHoles SIP_MONKEYPATCH_COMPAT_NAME( FlagAllowSelfTouchingHoles ) = 1 << 0, 
    };
    enum class GeometryValidityFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, ValidityFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( GeometryValidityFlags, GeometryValidityFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsGeometry, ValidityFlags )
    Q_ENUM( GeometryValidityFlag )
    Q_FLAG( GeometryValidityFlags )
 
    
    enum class GeometryValidationEngine SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, ValidationMethod ) : int
      {
      QgisInternal SIP_MONKEYPATCH_COMPAT_NAME( ValidatorQgisInternal ), 
      Geos SIP_MONKEYPATCH_COMPAT_NAME( ValidatorGeos ), 
    };
    enum class GeometryValidationEngine SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, ValidationMethod ) : int {…};
    Q_ENUM( GeometryValidationEngine )
 
    
    enum class BufferSide SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, BufferSide ) : int
      {
      Left SIP_MONKEYPATCH_COMPAT_NAME( SideLeft ) = 0, 
      Right SIP_MONKEYPATCH_COMPAT_NAME( SideRight ), 
    };
    enum class BufferSide SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, BufferSide ) : int {…};
    Q_ENUM( BufferSide )
 
    
    enum class EndCapStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, EndCapStyle ) : int
      {
      Round SIP_MONKEYPATCH_COMPAT_NAME( CapRound ) = 1, 
      Flat SIP_MONKEYPATCH_COMPAT_NAME( CapFlat ), 
      Square SIP_MONKEYPATCH_COMPAT_NAME( CapSquare ), 
    };
    enum class EndCapStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, EndCapStyle ) : int {…};
    Q_ENUM( EndCapStyle )
 
    
    enum class JoinStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, JoinStyle ) : int
      {
      Round SIP_MONKEYPATCH_COMPAT_NAME( JoinStyleRound ) = 1, 
      Miter SIP_MONKEYPATCH_COMPAT_NAME( JoinStyleMiter ), 
      Bevel SIP_MONKEYPATCH_COMPAT_NAME( JoinStyleBevel ), 
    };
    enum class JoinStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, JoinStyle ) : int {…};
    Q_ENUM( JoinStyle )
 
    
    enum class GeosCreationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RejectOnInvalidSubGeometry = 1 << 0,  
      SkipEmptyInteriorRings = 1 << 1,      
    };
    enum class GeosCreationFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( GeosCreationFlag )
 
    
    Q_DECLARE_FLAGS( GeosCreationFlags, GeosCreationFlag )
    Q_FLAG( GeosCreationFlags )
 
    enum class CoverageValidityResult : int
    {
      Invalid = 0, 
      Valid = 1, 
      Error = 2, 
    };
    enum class CoverageValidityResult : int {…};
    Q_ENUM( CoverageValidityResult )
 
    
    enum class MakeValidMethod : int
    {
      Linework = 0, 
      Structure = 1, 
    };
    enum class MakeValidMethod : int {…};
    Q_ENUM( MakeValidMethod )
 
    
    enum class FeatureRequestFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoFlags            = 0, 
      NoGeometry         = 1,  
      SubsetOfAttributes = 2,  
      ExactIntersect     = 4,   
      IgnoreStaticNodesDuringExpressionCompilation = 8, 
      EmbeddedSymbols    = 16,  
    };
    enum class FeatureRequestFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( FeatureRequestFlag )
 
    
    Q_DECLARE_FLAGS( FeatureRequestFlags, FeatureRequestFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsFeatureRequest, Flags )
    Q_FLAG( FeatureRequestFlags )
 
    enum class FeatureRequestFilterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, FilterType ) : int
      {
      NoFilter SIP_MONKEYPATCH_COMPAT_NAME( FilterNone ), 
      Fid SIP_MONKEYPATCH_COMPAT_NAME( FilterFid ), 
      Expression SIP_MONKEYPATCH_COMPAT_NAME( FilterExpression ), 
      Fids SIP_MONKEYPATCH_COMPAT_NAME( FilterFids ) 
    };
    enum class FeatureRequestFilterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, FilterType ) : int {…};
    Q_ENUM( FeatureRequestFilterType )
 
    
    enum class InvalidGeometryCheck SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, InvalidGeometryCheck ) : int
      {
      NoCheck SIP_MONKEYPATCH_COMPAT_NAME( GeometryNoCheck ) = 0, 
      SkipInvalid SIP_MONKEYPATCH_COMPAT_NAME( GeometrySkipInvalid ) = 1, 
      AbortOnInvalid SIP_MONKEYPATCH_COMPAT_NAME( GeometryAbortOnInvalid ) = 2, 
    };
    enum class InvalidGeometryCheck SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureRequest, InvalidGeometryCheck ) : int {…};
    Q_ENUM( InvalidGeometryCheck )
 
    
    enum class SpatialFilterType : int
    {
      NoFilter, 
      BoundingBox, 
      DistanceWithin, 
    };
    enum class SpatialFilterType : int {…};
    Q_ENUM( SpatialFilterType )
 
    
    enum class FileOperationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IncludeMetadataFile = 1 << 0, 
      IncludeStyleFile = 1 << 1, 
    };
    enum class FileOperationFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( FileOperationFlags, FileOperationFlag )
    Q_ENUM( FileOperationFlag )
    Q_FLAG( FileOperationFlags )
 
    
    enum class MapLayerProperty : int SIP_ENUM_BASETYPE( IntFlag )
    {
      UsersCannotToggleEditing = 1 << 0, 
      IsBasemapLayer = 1 << 1, 
    };
    enum class MapLayerProperty : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( MapLayerProperties, MapLayerProperty )
    Q_ENUM( MapLayerProperty )
    Q_FLAG( MapLayerProperties )
 
    
    enum class AutoRefreshMode : int
    {
      Disabled = 0, 
      ReloadData = 1, 
      RedrawOnly = 2, 
    };
    enum class AutoRefreshMode : int {…};
    Q_ENUM( AutoRefreshMode )
 
    
    enum class DataProviderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IsBasemapSource = 1 << 1, 
      FastExtent2D = 1 << 2, 
      FastExtent3D = 1 << 3, 
    };
    enum class DataProviderFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( DataProviderFlags, DataProviderFlag )
    Q_ENUM( DataProviderFlag )
    Q_FLAG( DataProviderFlags )
 
    
    enum class CrsType : int
    {
      Unknown, 
      Geodetic, 
      Geocentric, 
      Geographic2d, 
      Geographic3d, 
      Vertical, 
      Projected, 
      Compound, 
      Temporal, 
      Engineering, 
      Bound, 
      Other, 
      DerivedProjected, 
    };
    enum class CrsType : int {…};
    Q_ENUM( CrsType )
 
    
    enum class CrsAxisDirection : int
    {
      North, 
      NorthNorthEast, 
      NorthEast, 
      EastNorthEast, 
      East, 
      EastSouthEast, 
      SouthEast, 
      SouthSouthEast, 
      South, 
      SouthSouthWest, 
      SouthWest, 
      WestSouthWest, 
      West, 
      WestNorthWest, 
      NorthWest, 
      NorthNorthWest, 
      GeocentricX, 
      GeocentricY, 
      GeocentricZ, 
      Up, 
      Down, 
      Forward, 
      Aft, 
      Port, 
      Starboard, 
      Clockwise, 
      CounterClockwise, 
      ColumnPositive, 
      ColumnNegative, 
      RowPositive, 
      RowNegative, 
      DisplayRight, 
      DisplayLeft, 
      DisplayUp, 
      DisplayDown, 
      Future, 
      Past, 
      Towards, 
      AwayFrom, 
      Unspecified, 
    };
    enum class CrsAxisDirection : int {…};
    Q_ENUM( CrsAxisDirection )
 
    
    enum class CoordinateOrder : int
    {
      Default, 
      XY, 
      YX, 
    };
    enum class CoordinateOrder : int {…};
    Q_ENUM( CoordinateOrder )
 
    
    enum class CrsIdentifierType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, IdentifierType ) : int
      {
      ShortString, 
      MediumString, 
      FullString, 
    };
    enum class CrsIdentifierType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, IdentifierType ) : int {…};
    Q_ENUM( CrsIdentifierType )
 
    
    enum class CrsWktVariant SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, WktVariant ) : int
      {
      Wkt1Gdal SIP_MONKEYPATCH_COMPAT_NAME( WKT1_GDAL ), 
      Wkt1Esri SIP_MONKEYPATCH_COMPAT_NAME( WKT1_ESRI ), 
      Wkt2_2015 SIP_MONKEYPATCH_COMPAT_NAME( WKT2_2015 ), 
      Wkt2_2015Simplified SIP_MONKEYPATCH_COMPAT_NAME( WKT2_2015_SIMPLIFIED ), 
      Wkt2_2019  SIP_MONKEYPATCH_COMPAT_NAME( WKT2_2019 ), 
      Wkt2_2019Simplified  SIP_MONKEYPATCH_COMPAT_NAME( WKT2_2019_SIMPLIFIED ), 
      Preferred SIP_MONKEYPATCH_COMPAT_NAME( WKT_PREFERRED ) = Wkt2_2019, 
      PreferredSimplified  SIP_MONKEYPATCH_COMPAT_NAME( WKT_PREFERRED_SIMPLIFIED ) = Wkt2_2019Simplified, 
      PreferredGdal SIP_MONKEYPATCH_COMPAT_NAME( WKT_PREFERRED_GDAL ) = Wkt2_2019, 
    };
    enum class CrsWktVariant SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, WktVariant ) : int {…};
    Q_ENUM( CrsWktVariant )
 
    
    enum class Axis : int
    {
      X, 
      Y, 
      Z 
    };
    enum class Axis : int {…};
    Q_ENUM( Axis )
 
    
    enum class AnnotationItemFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ScaleDependentBoundingBox = 1 << 0, 
      SupportsReferenceScale = 1 << 1, 
      SupportsCallouts = 1 << 2, 
    };
    enum class AnnotationItemFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( AnnotationItemFlags, AnnotationItemFlag )
    Q_ENUM( AnnotationItemFlag )
    Q_FLAG( AnnotationItemFlags )
 
    
    enum class AnnotationPlacementMode : int
    {
      SpatialBounds = 0, 
      FixedSize, 
      RelativeToMapFrame, 
    };
    enum class AnnotationPlacementMode : int {…};
    Q_ENUM( AnnotationPlacementMode )
 
    
    enum class AnnotationItemGuiFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FlagNoCreationTools = 1 << 0,  
    };
    enum class AnnotationItemGuiFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( AnnotationItemGuiFlags, AnnotationItemGuiFlag )
    Q_ENUM( AnnotationItemGuiFlag )
    Q_FLAG( AnnotationItemGuiFlags )
 
    
    enum class AnnotationItemNodeType : int
    {
      VertexHandle, 
      CalloutHandle, 
    };
    enum class AnnotationItemNodeType : int {…};
    Q_ENUM( AnnotationItemNodeType )
 
    
    enum class AnnotationItemEditOperationResult : int
    {
      Success, 
      Invalid, 
      ItemCleared, 
    };
    enum class AnnotationItemEditOperationResult : int {…};
    Q_ENUM( AnnotationItemEditOperationResult )
 
    
    enum class TemporalNavigationMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, NavigationMode ) : int
      {
      Disabled SIP_MONKEYPATCH_COMPAT_NAME( NavigationOff ), 
      Animated, 
      FixedRange, 
      Movie, 
    };
    enum class TemporalNavigationMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, NavigationMode ) : int {…};
    Q_ENUM( TemporalNavigationMode )
 
    
    enum class AnimationState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, AnimationState ) : int
      {
      Forward, 
      Reverse, 
      Idle, 
    };
    enum class AnimationState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, AnimationState ) : int {…};
    Q_ENUM( AnimationState )
 
    
    enum class PlaybackOperation : int
    {
      SkipToStart, 
      PreviousFrame, 
      PlayReverse, 
      Pause, 
      PlayForward, 
      NextFrame, 
      SkipToEnd, 
    };
    enum class PlaybackOperation : int {…};
    Q_ENUM( PlaybackOperation )
 
    
    enum class VectorTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayerTemporalProperties, TemporalMode ) : int
      {
      FixedTemporalRange SIP_MONKEYPATCH_COMPAT_NAME( ModeFixedTemporalRange ) = 0, 
      FeatureDateTimeInstantFromField SIP_MONKEYPATCH_COMPAT_NAME( ModeFeatureDateTimeInstantFromField ), 
      FeatureDateTimeStartAndEndFromFields SIP_MONKEYPATCH_COMPAT_NAME( ModeFeatureDateTimeStartAndEndFromFields ), 
      FeatureDateTimeStartAndDurationFromFields SIP_MONKEYPATCH_COMPAT_NAME( ModeFeatureDateTimeStartAndDurationFromFields ), 
      FeatureDateTimeStartAndEndFromExpressions SIP_MONKEYPATCH_COMPAT_NAME( ModeFeatureDateTimeStartAndEndFromExpressions ), 
      RedrawLayerOnly SIP_MONKEYPATCH_COMPAT_NAME( ModeRedrawLayerOnly ), 
    };
    enum class VectorTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayerTemporalProperties, TemporalMode ) : int {…};
    Q_ENUM( VectorTemporalMode )
 
    
    enum class VectorTemporalLimitMode : int
    {
      IncludeBeginExcludeEnd = 0, 
      IncludeBeginIncludeEnd, 
    };
    enum class VectorTemporalLimitMode : int {…};
    Q_ENUM( VectorTemporalLimitMode )
 
    
    enum class VectorDataProviderTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProviderTemporalCapabilities, TemporalMode ) : int
      {
      HasFixedTemporalRange SIP_MONKEYPATCH_COMPAT_NAME( ProviderHasFixedTemporalRange ) = 0, 
      StoresFeatureDateTimeInstantInField SIP_MONKEYPATCH_COMPAT_NAME( ProviderStoresFeatureDateTimeInstantInField ), 
      StoresFeatureDateTimeStartAndEndInSeparateFields SIP_MONKEYPATCH_COMPAT_NAME( ProviderStoresFeatureDateTimeStartAndEndInSeparateFields ), 
    };
    enum class VectorDataProviderTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProviderTemporalCapabilities, TemporalMode ) : int {…};
    Q_ENUM( VectorDataProviderTemporalMode )
 
    
    enum class RasterTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterLayerTemporalProperties, TemporalMode ) : int
      {
      FixedTemporalRange SIP_MONKEYPATCH_COMPAT_NAME( ModeFixedTemporalRange ) = 0, 
      TemporalRangeFromDataProvider SIP_MONKEYPATCH_COMPAT_NAME( ModeTemporalRangeFromDataProvider ) = 1, 
      RedrawLayerOnly SIP_MONKEYPATCH_COMPAT_NAME( ModeRedrawLayerOnly ) = 2, 
      FixedRangePerBand = 3, 
      RepresentsTemporalValues = 4, 
      FixedDateTime = 5, 
    };
    enum class RasterTemporalMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterLayerTemporalProperties, TemporalMode ) : int {…};
    Q_ENUM( RasterTemporalMode )
 
    
    enum class TemporalIntervalMatchMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProviderTemporalCapabilities, IntervalHandlingMethod ) : int
      {
      MatchUsingWholeRange, 
      MatchExactUsingStartOfRange, 
      MatchExactUsingEndOfRange, 
      FindClosestMatchToStartOfRange, 
      FindClosestMatchToEndOfRange 
    };
    enum class TemporalIntervalMatchMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProviderTemporalCapabilities, IntervalHandlingMethod ) : int {…};
    Q_ENUM( TemporalIntervalMatchMethod )
 
    
    enum class RasterTemporalCapabilityFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RequestedTimesMustExactlyMatchAllAvailableTemporalRanges = 1 << 0, 
    };
    enum class RasterTemporalCapabilityFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterTemporalCapabilityFlag )
 
    
    Q_DECLARE_FLAGS( RasterTemporalCapabilityFlags, RasterTemporalCapabilityFlag )
    Q_FLAG( RasterTemporalCapabilityFlags )
 
    enum class TransformDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateTransform, TransformDirection ) : int
      {
      Forward SIP_MONKEYPATCH_COMPAT_NAME( ForwardTransform ), 
      Reverse SIP_MONKEYPATCH_COMPAT_NAME( ReverseTransform ) 
    };
    enum class TransformDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateTransform, TransformDirection ) : int {…};
    Q_ENUM( TransformDirection )
 
    
    enum class CoordinateTransformationFlag  : int SIP_ENUM_BASETYPE( IntFlag )
    {
      BallparkTransformsAreAppropriate = 1 << 0, 
      IgnoreImpossibleTransformations = 1 << 1, 
    };
    enum class CoordinateTransformationFlag  : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( CoordinateTransformationFlag )
 
    
    Q_DECLARE_FLAGS( CoordinateTransformationFlags, CoordinateTransformationFlag )
    Q_FLAG( CoordinateTransformationFlags )
 
    enum class MapSettingsFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapSettings, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Antialiasing             = 0x01,  
      DrawEditingInfo          = 0x02,  
      ForceVectorOutput        = 0x04,  
      UseAdvancedEffects       = 0x08,  
      DrawLabeling             = 0x10,  
      UseRenderingOptimization = 0x20,  
      DrawSelection            = 0x40,  
      DrawSymbolBounds         = 0x80,  
      RenderMapTile            = 0x100, 
      RenderPartialOutput      = 0x200, 
      RenderPreviewJob         = 0x400, 
      RenderBlocking           = 0x800, 
      LosslessImageRendering   = 0x1000, 
      Render3DMap              = 0x2000, 
      HighQualityImageTransforms = 0x4000, 
      SkipSymbolRendering      = 0x8000, 
      ForceRasterMasks         = 0x10000,  
      RecordProfile            = 0x20000, 
      AlwaysUseGlobalMasks     = 0x40000, 
    };
    enum class MapSettingsFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapSettings, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( MapSettingsFlags, MapSettingsFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsMapSettings, Flags )
    Q_ENUM( MapSettingsFlag )
    Q_FLAG( MapSettingsFlags )
 
    
    enum class RenderContextFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRenderContext, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DrawEditingInfo          = 0x01,  
      ForceVectorOutput        = 0x02,  
      UseAdvancedEffects       = 0x04,  
      UseRenderingOptimization = 0x08,  
      DrawSelection            = 0x10,  
      DrawSymbolBounds         = 0x20,  
      RenderMapTile            = 0x40,  
      Antialiasing             = 0x80,  
      RenderPartialOutput      = 0x100, 
      RenderPreviewJob         = 0x200, 
      RenderBlocking           = 0x400, 
      RenderSymbolPreview      = 0x800, 
      LosslessImageRendering   = 0x1000, 
      ApplyScalingWorkaroundForTextRendering = 0x2000, 
      Render3DMap              = 0x4000, 
      ApplyClipAfterReprojection = 0x8000, 
      RenderingSubSymbol       = 0x10000, 
      HighQualityImageTransforms = 0x20000, 
      SkipSymbolRendering      = 0x40000, 
      RecordProfile            = 0x80000, 
      AlwaysUseGlobalMasks     = 0x100000, 
      DisableSymbolClippingToExtent = 0x200000, 
    };
    enum class RenderContextFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRenderContext, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_DECLARE_FLAGS( RenderContextFlags, RenderContextFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsRenderContext, Flags )
    Q_ENUM( RenderContextFlag )
    Q_FLAG( RenderContextFlags )
 
    
    enum class MapLayerRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RenderPartialOutputs = 1 << 0,  
      RenderPartialOutputOverPreviousCachedImage = 1 << 1,
      AffectsLabeling = 1 << 2, 
    };
    enum class MapLayerRendererFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( MapLayerRendererFlag )
 
    
    Q_DECLARE_FLAGS( MapLayerRendererFlags, MapLayerRendererFlag )
    Q_FLAG( MapLayerRendererFlags )
 
    // refs for below dox: https://github.com/qgis/QGIS/pull/1286#issuecomment-39806854
    // https://github.com/qgis/QGIS/pull/8573#issuecomment-445585826
 
    enum class TextRenderFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRenderContext, TextRenderFormat ) : int
      {
      AlwaysOutlines SIP_MONKEYPATCH_COMPAT_NAME( TextFormatAlwaysOutlines ), 
      AlwaysText SIP_MONKEYPATCH_COMPAT_NAME( TextFormatAlwaysText ), 
      PreferText, 
    };
    enum class TextRenderFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRenderContext, TextRenderFormat ) : int {…};
    Q_ENUM( TextRenderFormat )
 
    
    enum class LabelingFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelingEngineSettings, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      UseAllLabels          = 1 << 1, 
      UsePartialCandidates  = 1 << 2, 
      // TODO QGIS 4.0: remove
      RenderOutlineLabels   = 1 << 3, 
      DrawLabelRectOnly     = 1 << 4, 
      DrawCandidates        = 1 << 5, 
      DrawUnplacedLabels    = 1 << 6, 
      CollectUnplacedLabels = 1 << 7, 
      DrawLabelMetrics      = 1 << 8, 
    };
    enum class LabelingFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelingEngineSettings, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LabelingFlag )
 
    
    Q_DECLARE_FLAGS( LabelingFlags, LabelingFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsLabelingEngineSettings, Flags )
    Q_FLAG( LabelingFlags )
 
    enum class LabelPlacementEngineVersion SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelingEngineSettings, PlacementEngineVersion ) : int
      {
      Version1 SIP_MONKEYPATCH_COMPAT_NAME( PlacementEngineVersion1 ), 
      Version2 SIP_MONKEYPATCH_COMPAT_NAME( PlacementEngineVersion2 ), 
    };
    enum class LabelPlacementEngineVersion SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelingEngineSettings, PlacementEngineVersion ) : int {…};
    Q_ENUM( LabelPlacementEngineVersion )
 
    
    enum class TextOrientation SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextFormat, TextOrientation ) : int
      {
      Horizontal SIP_MONKEYPATCH_COMPAT_NAME( HorizontalOrientation ), 
      Vertical SIP_MONKEYPATCH_COMPAT_NAME( VerticalOrientation ), 
      RotationBased SIP_MONKEYPATCH_COMPAT_NAME( RotationBasedOrientation ), 
    };
    enum class TextOrientation SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextFormat, TextOrientation ) : int {…};
    Q_ENUM( TextOrientation )
 
    
    enum class TextLayoutMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, DrawMode ) : int
      {
      Rectangle SIP_MONKEYPATCH_COMPAT_NAME( Rect ), 
      Point, 
      Labeling SIP_MONKEYPATCH_COMPAT_NAME( Label ), 
      RectangleCapHeightBased, 
      RectangleAscentBased, 
    };
    enum class TextLayoutMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, DrawMode ) : int {…};
    Q_ENUM( TextLayoutMode )
 
    
    enum class TextComponent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, TextPart ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Text = 1 << 0, 
      Buffer = 1 << 1, 
      Background = 1 << 2, 
      Shadow = 1 << 3, 
    };
    enum class TextComponent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, TextPart ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( TextComponent )
 
    
    Q_DECLARE_FLAGS( TextComponents, TextComponent )
    Q_FLAG( TextComponents )
 
    enum class TextHorizontalAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, HAlignment ) : int
      {
      Left SIP_MONKEYPATCH_COMPAT_NAME( AlignLeft ), 
      Center SIP_MONKEYPATCH_COMPAT_NAME( AlignCenter ), 
      Right SIP_MONKEYPATCH_COMPAT_NAME( AlignRight ), 
      Justify SIP_MONKEYPATCH_COMPAT_NAME( AlignJustify ), 
    };
    enum class TextHorizontalAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, HAlignment ) : int {…};
    Q_ENUM( TextHorizontalAlignment )
 
    
    enum class TextVerticalAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, VAlignment ) : int
      {
      Top SIP_MONKEYPATCH_COMPAT_NAME( AlignTop ), 
      VerticalCenter SIP_MONKEYPATCH_COMPAT_NAME( AlignVCenter ), 
      Bottom SIP_MONKEYPATCH_COMPAT_NAME( AlignBottom ), 
    };
    enum class TextVerticalAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRenderer, VAlignment ) : int {…};
    Q_ENUM( TextVerticalAlignment )
 
    
    enum class TextCharacterVerticalAlignment : int
    {
      Normal, 
      SuperScript, 
      SubScript, 
    };
    enum class TextCharacterVerticalAlignment : int {…};
    Q_ENUM( TextCharacterVerticalAlignment )
 
    
    enum class VectorSimplificationAlgorithm SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorSimplifyMethod, SimplifyAlgorithm ) : int
      {
      Distance = 0, 
      SnapToGrid = 1, 
      Visvalingam = 2, 
      SnappedToGridGlobal = 3, 
    };
    enum class VectorSimplificationAlgorithm SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorSimplifyMethod, SimplifyAlgorithm ) : int {…};
    Q_ENUM( VectorSimplificationAlgorithm )
 
    
    enum class VectorRenderingSimplificationFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorSimplifyMethod, SimplifyHint ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoSimplification           = 0, 
      GeometrySimplification     = 1, 
      AntialiasingSimplification = 2, 
      FullSimplification         = 3, 
    };
    enum class VectorRenderingSimplificationFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorSimplifyMethod, SimplifyHint ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorRenderingSimplificationFlag )
 
    
    Q_DECLARE_FLAGS( VectorRenderingSimplificationFlags, VectorRenderingSimplificationFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsVectorSimplifyMethod, SimplifyHints )
    Q_FLAG( VectorRenderingSimplificationFlags )
 
    enum class RenderSubcomponentProperty : int
    {
      Generic, 
      ShadowOffset, 
      BlurSize, 
      GlowSpread, 
    };
    enum class RenderSubcomponentProperty : int {…};
    Q_ENUM( RenderSubcomponentProperty )
 
    
    enum class VertexType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVertexId, VertexType ) : int
      {
      Segment SIP_MONKEYPATCH_COMPAT_NAME( SegmentVertex ) = 1, 
      Curve SIP_MONKEYPATCH_COMPAT_NAME( CurveVertex ) = 2, 
    };
    enum class VertexType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVertexId, VertexType ) : int {…};
    Q_ENUM( VertexType )
 
    
    enum class MarkerShape SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSimpleMarkerSymbolLayerBase, Shape ) : int
      {
      Square, 
      Diamond, 
      Pentagon, 
      Hexagon, 
      Triangle, 
      EquilateralTriangle, 
      Star, 
      Arrow, 
      Circle, 
      Cross, 
      CrossFill, 
      Cross2, 
      Line, 
      ArrowHead, 
      ArrowHeadFilled, 
      SemiCircle, 
      ThirdCircle, 
      QuarterCircle, 
      QuarterSquare, 
      HalfSquare, 
      DiagonalHalfSquare, 
      RightHalfTriangle, 
      LeftHalfTriangle, 
      Octagon, 
      SquareWithCorners, 
      AsteriskFill, 
      HalfArc, 
      ThirdArc, 
      QuarterArc, 
      ParallelogramRight, 
      ParallelogramLeft, 
      Trapezoid, 
      Shield, 
      DiamondStar, 
      Heart, 
      Decagon, 
      RoundedSquare, 
    };
    enum class MarkerShape SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSimpleMarkerSymbolLayerBase, Shape ) : int {…};
    Q_ENUM( MarkerShape )
 
    
    enum class MarkerLinePlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemplatedLineSymbolLayerBase, Placement ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Interval = 1 << 0, 
      Vertex = 1 << 1, 
      LastVertex = 1 << 2, 
      FirstVertex = 1 << 3, 
      CentralPoint = 1 << 4, 
      CurvePoint = 1 << 5, 
      SegmentCenter = 1 << 6, 
      InnerVertices = 1 << 7, 
    };
    enum class MarkerLinePlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemplatedLineSymbolLayerBase, Placement ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( MarkerLinePlacement )
    Q_DECLARE_FLAGS( MarkerLinePlacements, MarkerLinePlacement )
    Q_FLAG( MarkerLinePlacements )
 
    enum class LinearReferencingPlacement : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IntervalCartesian2D = 1 << 0, 
      IntervalZ = 1 << 1, 
      IntervalM = 1 << 2, 
      Vertex = 1 << 3, 
    };
    enum class LinearReferencingPlacement : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LinearReferencingPlacement )
 
    
    enum class LinearReferencingLabelSource : int
    {
      CartesianDistance2D, 
      Z, 
      M, 
    };
    enum class LinearReferencingLabelSource : int {…};
    Q_ENUM( LinearReferencingLabelSource )
 
    
    enum class GradientColorSource SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientColorType ) : int
      {
      SimpleTwoColor, 
      ColorRamp, 
    };
    enum class GradientColorSource SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientColorType ) : int {…};
    Q_ENUM( GradientColorSource )
 
    
    enum class GradientType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientType ) : int
      {
      Linear, 
      Radial, 
      Conical, 
    };
    enum class GradientType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientType ) : int {…};
    Q_ENUM( GradientType )
 
    
    enum class SymbolCoordinateReference SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientCoordinateMode ) : int
      {
      Feature, 
      Viewport, 
    };
    enum class SymbolCoordinateReference SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientCoordinateMode ) : int {…};
    Q_ENUM( SymbolCoordinateReference )
 
    
    enum class GradientSpread SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientSpread ) : int
      {
      Pad, 
      Reflect, 
      Repeat, 
    };
    enum class GradientSpread SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientSpread ) : int {…};
    Q_ENUM( GradientSpread )
 
    
    enum class PointCountMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRandomMarkerFillSymbolLayer, CountMethod ) : int
      {
      Absolute SIP_MONKEYPATCH_COMPAT_NAME( AbsoluteCount ), 
      DensityBased SIP_MONKEYPATCH_COMPAT_NAME( DensityBasedCount ), 
    };
    enum class PointCountMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRandomMarkerFillSymbolLayer, CountMethod ) : int {…};
    Q_ENUM( PointCountMethod )
 
    
    enum class MarkerClipMode : int
    {
      NoClipping, 
      Shape, 
      CentroidWithin, 
      CompletelyWithin, 
    };
    enum class MarkerClipMode : int {…};
    Q_ENUM( MarkerClipMode )
 
    
    enum class LineClipMode : int
    {
      ClipPainterOnly, 
      ClipToIntersection, 
      NoClipping, 
    };
    enum class LineClipMode : int {…};
    Q_ENUM( LineClipMode )
 
    
    enum class DashPatternLineEndingRule : int
    {
      NoRule, 
      FullDash, 
      HalfDash, 
      FullGap, 
      HalfGap, 
    };
    enum class DashPatternLineEndingRule : int {…};
    Q_ENUM( DashPatternLineEndingRule )
 
    
    enum class DashPatternSizeAdjustment : int
    {
      ScaleBothDashAndGap, 
      ScaleDashOnly, 
      ScaleGapOnly, 
    };
    enum class DashPatternSizeAdjustment : int {…};
    Q_ENUM( DashPatternSizeAdjustment )
 
    
    enum class GraduatedMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGraduatedSymbolRenderer, GraduatedMethod ) : int
      {
      Color SIP_MONKEYPATCH_COMPAT_NAME( GraduatedColor ), 
      Size SIP_MONKEYPATCH_COMPAT_NAME( GraduatedSize ), 
    };
    enum class GraduatedMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGraduatedSymbolRenderer, GraduatedMethod ) : int {…};
    Q_ENUM( GraduatedMethod )
 
    
    enum class PlotAxisSuffixPlacement
    {
      NoLabels, 
      EveryLabel, 
      FirstLabel, 
      LastLabel, 
      FirstAndLastLabels, 
    };
    enum class PlotAxisSuffixPlacement {…};
    Q_ENUM( PlotAxisSuffixPlacement )
 
    
    enum class DpiMode
    {
      All = 7, 
      Off = 0, 
      QGIS = 1, 
      UMN = 2, 
      GeoServer = 4, 
    };
    enum class DpiMode {…};
    Q_ENUM( DpiMode )
 
    
    enum class TilePixelRatio
    {
      Undefined = 0, 
      StandardDpi = 1, 
      HighDpi = 2, 
    };
    enum class TilePixelRatio {…};
    Q_ENUM( TilePixelRatio )
 
    // NOTE -- the hardcoded numbers here must match QFont::Capitalization!
 
    
    enum class Capitalization SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStringUtils, Capitalization ) : int
      {
      MixedCase = 0, 
      AllUppercase = 1, 
      AllLowercase = 2,  
      ForceFirstLetterToCapital = 4, 
      SmallCaps = 5, 
      TitleCase = 1004, 
      UpperCamelCase = 1005, 
      AllSmallCaps = 1006, 
    };
    enum class Capitalization SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStringUtils, Capitalization ) : int {…};
    Q_ENUM( Capitalization )
 
    
    enum class TextRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      WrapLines = 1 << 0, 
    };
    enum class TextRendererFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( TextRendererFlag )
    Q_DECLARE_FLAGS( TextRendererFlags, TextRendererFlag )
    Q_FLAG( TextRendererFlags )
 
    enum class ScaleToTileZoomLevelMethod : int
    {
      MapBox, 
      Esri, 
    };
    enum class ScaleToTileZoomLevelMethod : int {…};
    Q_ENUM( ScaleToTileZoomLevelMethod );
 
    enum class AngularDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCurve, Orientation ) : int
      {
      Clockwise, 
      CounterClockwise, 
      NoOrientation, 
    };
    enum class AngularDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCurve, Orientation ) : int {…};
    Q_ENUM( AngularDirection )
 
    
    enum class RendererUsage : int
    {
      View, 
      Export, 
      Unknown, 
    };
    enum class RendererUsage : int {…};
    Q_ENUM( RendererUsage )
 
    
    enum class MapCanvasFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowMainAnnotationLayer = 1 << 0, 
    };
    enum class MapCanvasFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( MapCanvasFlag )
 
    
    Q_DECLARE_FLAGS( MapCanvasFlags, MapCanvasFlag )
    Q_FLAG( MapCanvasFlags )
 
    enum class ViewSyncModeFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Sync3DTo2D = 1 << 0, 
      Sync2DTo3D = 1 << 1, 
    };
    enum class ViewSyncModeFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ViewSyncModeFlag )
    Q_DECLARE_FLAGS( ViewSyncModeFlags, ViewSyncModeFlag )
 
    enum class MapRecenteringMode
    {
      Always, 
      WhenOutsideVisibleExtent, 
      Never, 
    };
    enum class MapRecenteringMode {…};
    Q_ENUM( MapRecenteringMode )
 
    
    enum class HistoryProviderBackend : int SIP_ENUM_BASETYPE( IntFlag )
    {
      LocalProfile = 1 << 0, 
//      Project = 1 << 1, //!< QGIS Project  (not yet implemented)
    };
    enum class HistoryProviderBackend : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( HistoryProviderBackend )
    Q_DECLARE_FLAGS( HistoryProviderBackends, HistoryProviderBackend )
    Q_FLAG( HistoryProviderBackends )
 
    enum class QueryStorageBackend : int
    {
      LocalProfile, 
      CurrentProject, 
    };
    enum class QueryStorageBackend : int {…};
    Q_ENUM( QueryStorageBackend )
 
    
    enum class ProcessingSourceType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessing, SourceType ) : int
      {
      MapLayer SIP_MONKEYPATCH_COMPAT_NAME( TypeMapLayer ) = -2, 
      VectorAnyGeometry SIP_MONKEYPATCH_COMPAT_NAME( TypeVectorAnyGeometry ) = -1, 
      VectorPoint SIP_MONKEYPATCH_COMPAT_NAME( TypeVectorPoint ) = 0, 
      VectorLine SIP_MONKEYPATCH_COMPAT_NAME( TypeVectorLine ) = 1, 
      VectorPolygon SIP_MONKEYPATCH_COMPAT_NAME( TypeVectorPolygon ) = 2, 
      Raster SIP_MONKEYPATCH_COMPAT_NAME( TypeRaster ) = 3, 
      File SIP_MONKEYPATCH_COMPAT_NAME( TypeFile ) = 4, 
      Vector SIP_MONKEYPATCH_COMPAT_NAME( TypeVector ) = 5, 
      Mesh SIP_MONKEYPATCH_COMPAT_NAME( TypeMesh ) = 6, 
      Plugin SIP_MONKEYPATCH_COMPAT_NAME( TypePlugin ) = 7, 
      PointCloud SIP_MONKEYPATCH_COMPAT_NAME( TypePointCloud ) = 8, 
      Annotation SIP_MONKEYPATCH_COMPAT_NAME( TypeAnnotation ) = 9, 
      VectorTile SIP_MONKEYPATCH_COMPAT_NAME( TypeVectorTile ) = 10 
    };
    enum class ProcessingSourceType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessing, SourceType ) : int {…};
    Q_ENUM( ProcessingSourceType )
 
 
    
    enum class ProcessingProviderFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingProvider, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DeemphasiseSearchResults SIP_MONKEYPATCH_COMPAT_NAME( FlagDeemphasiseSearchResults ) = 1 << 1, 
      CompatibleWithVirtualRaster SIP_MONKEYPATCH_COMPAT_NAME( FlagCompatibleWithVirtualRaster ) = 1 << 2, 
    };
    enum class ProcessingProviderFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingProvider, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingProviderFlag );
 
    Q_DECLARE_FLAGS( ProcessingProviderFlags, ProcessingProviderFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingProvider, Flags )
    Q_FLAG( ProcessingProviderFlags )
 
    
    enum class ProcessingAlgorithmFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingAlgorithm, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      HideFromToolbox SIP_MONKEYPATCH_COMPAT_NAME( FlagHideFromToolbox ) = 1 << 1, 
      HideFromModeler SIP_MONKEYPATCH_COMPAT_NAME( FlagHideFromModeler ) = 1 << 2, 
      SupportsBatch SIP_MONKEYPATCH_COMPAT_NAME( FlagSupportsBatch ) = 1 << 3,  
      CanCancel SIP_MONKEYPATCH_COMPAT_NAME( FlagCanCancel ) = 1 << 4, 
      RequiresMatchingCrs SIP_MONKEYPATCH_COMPAT_NAME( FlagRequiresMatchingCrs ) = 1 << 5, 
      NoThreading SIP_MONKEYPATCH_COMPAT_NAME( FlagNoThreading ) = 1 << 6, 
      DisplayNameIsLiteral SIP_MONKEYPATCH_COMPAT_NAME( FlagDisplayNameIsLiteral ) = 1 << 7, 
      SupportsInPlaceEdits SIP_MONKEYPATCH_COMPAT_NAME( FlagSupportsInPlaceEdits ) = 1 << 8, 
      KnownIssues SIP_MONKEYPATCH_COMPAT_NAME( FlagKnownIssues ) = 1 << 9, 
      CustomException SIP_MONKEYPATCH_COMPAT_NAME( FlagCustomException ) = 1 << 10, 
      PruneModelBranchesBasedOnAlgorithmResults SIP_MONKEYPATCH_COMPAT_NAME( FlagPruneModelBranchesBasedOnAlgorithmResults ) = 1 << 11, 
      SkipGenericModelLogging SIP_MONKEYPATCH_COMPAT_NAME( FlagSkipGenericModelLogging ) = 1 << 12, 
      NotAvailableInStandaloneTool SIP_MONKEYPATCH_COMPAT_NAME( FlagNotAvailableInStandaloneTool ) = 1 << 13, 
      RequiresProject SIP_MONKEYPATCH_COMPAT_NAME( FlagRequiresProject ) = 1 << 14, 
      SecurityRisk = 1 << 15, 
      Deprecated SIP_MONKEYPATCH_COMPAT_NAME( FlagDeprecated ) = HideFromToolbox | HideFromModeler, 
    };
    enum class ProcessingAlgorithmFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingAlgorithm, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingAlgorithmFlag );
 
    Q_DECLARE_FLAGS( ProcessingAlgorithmFlags, ProcessingAlgorithmFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingAlgorithm, Flags )
    Q_FLAG( ProcessingAlgorithmFlags )
 
    
    enum class ProcessingAlgorithmDocumentationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RegeneratesPrimaryKey = 1 << 0, 
      RegeneratesPrimaryKeyInSomeScenarios = 1 << 1, 
    };
    enum class ProcessingAlgorithmDocumentationFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingAlgorithmDocumentationFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingAlgorithmDocumentationFlags, ProcessingAlgorithmDocumentationFlag )
    Q_FLAG( ProcessingAlgorithmDocumentationFlags )
 
    enum class ProcessingPropertyAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingAlgorithm, PropertyAvailability ) : int
      {
      NotAvailable, 
      Available, 
    };
    enum class ProcessingPropertyAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingAlgorithm, PropertyAvailability ) : int {…};
    Q_ENUM( ProcessingPropertyAvailability )
 
    
    enum class ProcessingLogLevel SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingContext, LogLevel ) : int
      {
      DefaultLevel = 0, 
      Verbose, 
      ModelDebug, 
    };
    enum class ProcessingLogLevel SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingContext, LogLevel ) : int {…};
    Q_ENUM( ProcessingLogLevel )
 
    
    enum class ProcessingFeatureSourceDefinitionFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingFeatureSourceDefinition, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      OverrideDefaultGeometryCheck SIP_MONKEYPATCH_COMPAT_NAME( FlagOverrideDefaultGeometryCheck ) = 1 << 0, 
      CreateIndividualOutputPerInputFeature SIP_MONKEYPATCH_COMPAT_NAME( FlagCreateIndividualOutputPerInputFeature ) = 1 << 1, 
    };
    enum class ProcessingFeatureSourceDefinitionFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingFeatureSourceDefinition, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingFeatureSourceDefinitionFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingFeatureSourceDefinitionFlags, ProcessingFeatureSourceDefinitionFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingFeatureSourceDefinition, Flags )
    Q_FLAG( ProcessingFeatureSourceDefinitionFlags )
 
    enum class ProcessingFeatureSourceFlag SIP_ENUM_BASETYPE( IntFlag ) SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingFeatureSource, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SkipGeometryValidityChecks SIP_MONKEYPATCH_COMPAT_NAME( FlagSkipGeometryValidityChecks ) = 1 << 1, 
    };
    enum class ProcessingFeatureSourceFlag SIP_ENUM_BASETYPE( IntFlag ) SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingFeatureSource, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingFeatureSourceFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingFeatureSourceFlags, ProcessingFeatureSourceFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingFeatureSource, Flags )
    Q_FLAG( ProcessingFeatureSourceFlags )
 
    enum class ProcessingParameterTypeFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterType, ParameterFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ExposeToModeler = 1 
    };
    enum class ProcessingParameterTypeFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterType, ParameterFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingParameterTypeFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingParameterTypeFlags, ProcessingParameterTypeFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingParameterType, ParameterFlags )
    Q_FLAG( ProcessingParameterTypeFlags )
 
    enum class ProcessingParameterFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterDefinition, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Advanced SIP_MONKEYPATCH_COMPAT_NAME( FlagAdvanced ) = 1 << 1, 
      Hidden SIP_MONKEYPATCH_COMPAT_NAME( FlagHidden ) = 1 << 2, 
      Optional SIP_MONKEYPATCH_COMPAT_NAME( FlagOptional ) = 1 << 3, 
      IsModelOutput SIP_MONKEYPATCH_COMPAT_NAME( FlagIsModelOutput ) = 1 << 4, 
    };
    enum class ProcessingParameterFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterDefinition, Flag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProcessingParameterFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingParameterFlags, ProcessingParameterFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProcessingParameterDefinition, Flags )
    Q_FLAG( ProcessingParameterFlags )
 
    enum class ProcessingFileParameterBehavior SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterFile, Behavior ) : int
      {
      File = 0, 
      Folder, 
    };
    enum class ProcessingFileParameterBehavior SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterFile, Behavior ) : int {…};
    Q_ENUM( ProcessingFileParameterBehavior )
 
    
    enum class ProcessingNumberParameterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterNumber, Type ) : int
      {
      Integer, 
      Double, 
    };
    enum class ProcessingNumberParameterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterNumber, Type ) : int {…};
    Q_ENUM( ProcessingNumberParameterType )
 
    
    enum class ProcessingFieldParameterDataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterField, DataType ) : int
      {
      Any = -1, 
      Numeric = 0, 
      String = 1, 
      DateTime = 2, 
      Binary = 3, 
      Boolean = 4, 
    };
    enum class ProcessingFieldParameterDataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterField, DataType ) : int {…};
    Q_ENUM( ProcessingFieldParameterDataType )
 
    
    enum class ProcessingDateTimeParameterDataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterDateTime, Type ) : int
      {
      DateTime, 
      Date, 
      Time, 
    };
    enum class ProcessingDateTimeParameterDataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterDateTime, Type ) : int {…};
    Q_ENUM( ProcessingDateTimeParameterDataType )
 
    
    enum class ProcessingModelChildParameterSource : int
    {
      ModelParameter, 
      ChildOutput, 
      StaticValue, 
      Expression, 
      ExpressionText, 
      ModelOutput, 
    };
    enum class ProcessingModelChildParameterSource : int {…};
    Q_ENUM( ProcessingModelChildParameterSource )
 
    
    enum class ProcessingModelChildAlgorithmExecutionStatus : int
    {
      NotExecuted, 
      Success, 
      Failed, 
    };
    enum class ProcessingModelChildAlgorithmExecutionStatus : int {…};
    Q_ENUM( ProcessingModelChildAlgorithmExecutionStatus )
 
    
    enum class ProcessingTinInputLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterTinInputLayers, Type ) : int
      {
      Vertices, 
      StructureLines, 
      BreakLines 
    };
    enum class ProcessingTinInputLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterTinInputLayers, Type ) : int {…};
    Q_ENUM( ProcessingTinInputLayerType )
 
    
    enum class CrsDefinitionFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, Format ) : int
      {
      Wkt SIP_MONKEYPATCH_COMPAT_NAME( FormatWkt ), 
      Proj SIP_MONKEYPATCH_COMPAT_NAME( FormatProj ), 
    };
    enum class CrsDefinitionFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, Format ) : int {…};
    Q_ENUM( CrsDefinitionFormat )
 
    
    enum class FieldDomainSplitPolicy : int
    {
      DefaultValue, 
      Duplicate, 
      GeometryRatio, 
      UnsetField, 
    };
    enum class FieldDomainSplitPolicy : int {…};
    Q_ENUM( FieldDomainSplitPolicy )
 
    
    enum class FieldDomainMergePolicy : int
    {
      DefaultValue, 
      Sum, 
      GeometryWeighted, 
      UnsetField, 
      LargestGeometry, 
      MinimumValue, 
      MaximumValue, 
      SetToNull, 
    };
    enum class FieldDomainMergePolicy : int {…};
    Q_ENUM( FieldDomainMergePolicy )
 
    
    enum class FieldDuplicatePolicy : int
    {
      DefaultValue, 
      Duplicate, 
      UnsetField, 
    };
    enum class FieldDuplicatePolicy : int {…};
    Q_ENUM( FieldDuplicatePolicy )
 
    
    enum class FieldDomainType : int
    {
      Coded, 
      Range, 
      Glob, 
    };
    enum class FieldDomainType : int {…};
    Q_ENUM( FieldDomainType )
 
    
    enum class TransactionMode : int
    {
      Disabled = 0, 
      AutomaticGroups = 1, 
      BufferedGroups = 2, 
    };
    enum class TransactionMode : int {…};
    Q_ENUM( TransactionMode )
 
    
    enum class AltitudeClamping : int
    {
      Absolute, 
      Relative, 
      Terrain, 
    };
    enum class AltitudeClamping : int {…};
    Q_ENUM( AltitudeClamping )
 
    
    enum class AltitudeBinding : int
    {
      Vertex, 
      Centroid, 
    };
    enum class AltitudeBinding : int {…};
    Q_ENUM( AltitudeBinding )
 
    
    enum class RangeLimits : int
    {
      IncludeBoth = 0, 
      IncludeLowerExcludeUpper, 
      ExcludeLowerIncludeUpper, 
      ExcludeBoth, 
    };
    enum class RangeLimits : int {…};
    Q_ENUM( RangeLimits )
 
    
    enum class RasterElevationMode : int
    {
      FixedElevationRange = 0, 
      RepresentsElevationSurface = 1, 
      FixedRangePerBand = 2, 
      DynamicRangePerBand = 3, 
    };
    enum class RasterElevationMode : int {…};
    Q_ENUM( RasterElevationMode )
 
    
    enum class MeshElevationMode : int
    {
      FixedElevationRange = 0, 
      FromVertices = 1, 
      FixedRangePerGroup = 2, 
    };
    enum class MeshElevationMode : int {…};
    Q_ENUM( MeshElevationMode )
 
    
    enum class BetweenLineConstraint SIP_MONKEYPATCH_SCOPEENUM : int
    {
      NoConstraint,  
      Perpendicular, 
      Parallel       
    };
    enum class BetweenLineConstraint SIP_MONKEYPATCH_SCOPEENUM : int {…};
    Q_ENUM( BetweenLineConstraint )
 
    
    enum class LineExtensionSide : int
    {
      BeforeVertex, 
      AfterVertex, 
      NoVertex, 
    };
    enum class LineExtensionSide : int {…};
    Q_ENUM( LineExtensionSide )
 
 
    
    enum class CadConstraintType : int
    {
      Generic,      
      Angle,        
      Distance,     
      XCoordinate,  
      YCoordinate,  
      ZValue,       
      MValue,       
    };
    enum class CadConstraintType : int {…};
    Q_ENUM( CadConstraintType )
 
 
    
    enum class ProjectFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      EvaluateDefaultValuesOnProviderSide = 1 << 0, 
      TrustStoredLayerStatistics = 1 << 1, 
      RememberLayerEditStatusBetweenSessions = 1 << 2, 
      RememberAttributeTableWindowsBetweenSessions = 1 << 3, 
    };
    enum class ProjectFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProjectFlag )
    Q_DECLARE_FLAGS( ProjectFlags, ProjectFlag )
    Q_FLAG( ProjectFlags )
 
    enum class PlotToolFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowContextMenu = 1 << 0, 
    };
    enum class PlotToolFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( PlotToolFlag )
    Q_DECLARE_FLAGS( PlotToolFlags, PlotToolFlag )
    Q_FLAG( PlotToolFlags )
 
 
    enum class Point3DShape : int
    {
      Cylinder, 
      Sphere, 
      Cone, 
      Cube, 
      Torus, 
      Plane, 
      ExtrudedText, 
      Model, 
      Billboard, 
    };
    enum class Point3DShape : int {…};
    Q_ENUM( Point3DShape )
 
    
    enum class LightSourceType : int
    {
      Point, 
      Directional, 
    };
    enum class LightSourceType : int {…};
    Q_ENUM( LightSourceType )
 
    
    enum class NavigationMode : int
    {
      TerrainBased, 
      Walk, 
      GlobeTerrainBased  
    };
    enum class NavigationMode : int {…};
    Q_ENUM( NavigationMode )
 
    
    enum class SceneMode : int
    {
      Local,   
      Globe    
    };
    enum class SceneMode : int {…};
    Q_ENUM( SceneMode )
 
    
    enum class VerticalAxisInversion : int
    {
      Never, 
      WhenDragging, 
      Always, 
    };
    enum class VerticalAxisInversion : int {…};
    Q_ENUM( VerticalAxisInversion )
 
    
    enum class ProfileSurfaceSymbology : int
    {
      Line, 
      FillBelow, 
      FillAbove, 
    };
    enum class ProfileSurfaceSymbology : int {…};
    Q_ENUM( ProfileSurfaceSymbology );
 
    enum class VectorProfileType : int
    {
      IndividualFeatures, 
      ContinuousSurface, 
    };
    enum class VectorProfileType : int {…};
    Q_ENUM( VectorProfileType );
 
    enum class ProfileGeneratorFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RespectsMaximumErrorMapUnit = 1 << 0, 
      RespectsDistanceRange = 1 << 1, 
      RespectsElevationRange = 1 << 2, 
    };
    enum class ProfileGeneratorFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProfileGeneratorFlag )
    Q_DECLARE_FLAGS( ProfileGeneratorFlags, ProfileGeneratorFlag )
    Q_FLAG( ProfileGeneratorFlags )
 
    enum class ProfileExportType : int
    {
      Features3D, 
      Profile2D, 
      DistanceVsElevationTable, 
    };
    enum class ProfileExportType : int {…};
    Q_ENUM( ProfileExportType );
 
    enum class PointCloudSymbol SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, PointSymbol ) : int
      {
      Square, 
      Circle, 
    };
    enum class PointCloudSymbol SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, PointSymbol ) : int {…};
    Q_ENUM( PointCloudSymbol )
 
    
    enum class PointCloudDrawOrder SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, DrawOrder ) : int
      {
      Default, 
      BottomToTop, 
      TopToBottom, 
    };
    enum class PointCloudDrawOrder SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, DrawOrder ) : int {…};
    Q_ENUM( PointCloudDrawOrder )
 
    
    enum class AvoidIntersectionsMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, AvoidIntersectionsMode ) : int
      {
      AllowIntersections, 
      AvoidIntersectionsCurrentLayer, 
      AvoidIntersectionsLayers, 
    };
    enum class AvoidIntersectionsMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, AvoidIntersectionsMode ) : int {…};
    Q_ENUM( AvoidIntersectionsMode )
 
    
    enum class ProjectFileFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, FileFormat ) : int
      {
      Qgz, 
      Qgs, 
    };
    enum class ProjectFileFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, FileFormat ) : int {…};
    Q_ENUM( ProjectFileFormat )
 
    
    enum class ProjectReadFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, ReadFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DontResolveLayers SIP_MONKEYPATCH_COMPAT_NAME( FlagDontResolveLayers ) = 1 << 0, 
      DontLoadLayouts SIP_MONKEYPATCH_COMPAT_NAME( FlagDontLoadLayouts ) = 1 << 1, 
      TrustLayerMetadata SIP_MONKEYPATCH_COMPAT_NAME( FlagTrustLayerMetadata ) = 1 << 2, 
      DontStoreOriginalStyles SIP_MONKEYPATCH_COMPAT_NAME( FlagDontStoreOriginalStyles ) = 1 << 3, 
      DontLoad3DViews SIP_MONKEYPATCH_COMPAT_NAME( FlagDontLoad3DViews ) = 1 << 4, 
      DontLoadProjectStyles = 1 << 5, 
      ForceReadOnlyLayers = 1 << 6, 
      DontUpgradeAnnotations = 1 << 7, 
    };
    enum class ProjectReadFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, ReadFlag ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProjectReadFlag )
 
    
    Q_DECLARE_FLAGS( ProjectReadFlags, ProjectReadFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsProject, ReadFlags )
    Q_FLAG( ProjectReadFlags )
 
    enum class ProjectCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ProjectStyles = 1 << 0, 
    };
    enum class ProjectCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProjectCapability )
 
    
    Q_DECLARE_FLAGS( ProjectCapabilities, ProjectCapability )
    Q_FLAG( ProjectCapabilities )
 
    enum class MapBoxGlStyleSourceType : int
    {
      Vector, 
      Raster, 
      RasterDem, 
      GeoJson, 
      Image, 
      Video, 
      Unknown, 
    };
    enum class MapBoxGlStyleSourceType : int {…};
    Q_ENUM( MapBoxGlStyleSourceType )
 
    
    enum class ArcGisRestServiceType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsArcGisPortalUtils, ItemType ) : int
      {
      FeatureServer SIP_MONKEYPATCH_COMPAT_NAME( FeatureService ), 
      MapServer SIP_MONKEYPATCH_COMPAT_NAME( MapService ), 
      ImageServer SIP_MONKEYPATCH_COMPAT_NAME( ImageService ), 
      GlobeServer, 
      GPServer, 
      GeocodeServer, 
      Unknown, 
    };
    enum class ArcGisRestServiceType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsArcGisPortalUtils, ItemType ) : int {…};
    Q_ENUM( ArcGisRestServiceType )
 
    
    enum class RelationshipType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationType ) : int
      {
      Normal, 
      Generated, 
    };
    enum class RelationshipType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationType ) : int {…};
    Q_ENUM( RelationshipType )
 
    
    enum class RelationshipStrength SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationStrength ) : int
      {
      Association, 
      Composition, 
    };
    enum class RelationshipStrength SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationStrength ) : int {…};
    Q_ENUM( RelationshipStrength )
 
    
    enum class RelationshipCardinality : int
    {
      OneToOne, 
      OneToMany, 
      ManyToOne, 
      ManyToMany, 
    };
    enum class RelationshipCardinality : int {…};
    Q_ENUM( RelationshipCardinality )
 
    
    enum class RelationshipCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      MultipleFieldKeys = 1 << 0, 
      ForwardPathLabel = 1 << 1, 
      BackwardPathLabel = 1 << 2, 
    };
    enum class RelationshipCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RelationshipCapability )
 
    
    Q_DECLARE_FLAGS( RelationshipCapabilities, RelationshipCapability )
    Q_FLAG( RelationshipCapabilities )
 
    enum class CoordinateDisplayType : int
    {
      MapCrs, 
      MapGeographic, 
      CustomCrs, 
    };
    enum class CoordinateDisplayType : int {…};
    Q_ENUM( CoordinateDisplayType )
 
    
    enum class SettingsOrigin : int
    {
      Any, 
      Global, 
      Local, 
    };
    enum class SettingsOrigin : int {…};
    Q_ENUM( SettingsOrigin )
 
    
    enum class ScriptLanguage : int
    {
      Css, 
      QgisExpression, 
      Html, 
      JavaScript, 
      Json, 
      Python, 
      R, 
      Sql, 
      Batch, 
      Bash, 
      Unknown, 
    };
    enum class ScriptLanguage : int {…};
    Q_ENUM( ScriptLanguage )
 
    
    enum class ScriptLanguageCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Reformat = 1 << 0, 
      CheckSyntax = 1 << 1, 
      ToggleComment = 1 << 2, 
    };
    enum class ScriptLanguageCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ScriptLanguageCapability )
 
    
    Q_DECLARE_FLAGS( ScriptLanguageCapabilities, ScriptLanguageCapability )
    Q_FLAG( ScriptLanguageCapabilities )
 
    enum class LayerTreeInsertionMethod : int
    {
      AboveInsertionPoint, 
      TopOfTree, 
      OptimalInInsertionGroup, 
    };
    enum class LayerTreeInsertionMethod : int {…};
    Q_ENUM( LayerTreeInsertionMethod )
 
    
    enum class LayerTreeFilterFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SkipVisibilityCheck = 1 << 0, 
    };
    enum class LayerTreeFilterFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LayerTreeFilterFlag )
 
    
    Q_DECLARE_FLAGS( LayerTreeFilterFlags, LayerTreeFilterFlag )
    Q_FLAG( LayerTreeFilterFlags )
 
    enum class LegendComponent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLegendStyle, Style ) : int
      {
      Undefined, 
      Hidden, 
      Title, 
      Group, 
      Subgroup, 
      Symbol, 
      SymbolLabel, 
    };
    enum class LegendComponent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLegendStyle, Style ) : int {…};
    Q_ENUM( LegendComponent )
 
    
    enum class LegendJsonRenderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowRuleDetails = 1 << 0, 
    };
    enum class LegendJsonRenderFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( LegendJsonRenderFlag )
    Q_DECLARE_FLAGS( LegendJsonRenderFlags, LegendJsonRenderFlag )
    Q_FLAG( LegendJsonRenderFlags )
 
    enum class ActionType : int
    {
      Invalid, 
      MapLayerAction, 
      AttributeAction 
    };
    enum class ActionType : int {…};
    Q_ENUM( ActionType )
 
    
    enum class MapLayerActionTarget : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Layer = 1 << 0, 
      SingleFeature = 1 << 1, 
      MultipleFeatures = 1 << 2, 
      AllActions = Layer | SingleFeature | MultipleFeatures
    };
    enum class MapLayerActionTarget : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( MapLayerActionTarget )
 
    
    Q_DECLARE_FLAGS( MapLayerActionTargets, MapLayerActionTarget )
    Q_FLAG( MapLayerActionTargets )
 
    enum class MapLayerActionFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      EnabledOnlyWhenEditable = 1 << 1, 
      EnableOnlyWhenHasGeometry = 1 << 2, 
    };
    enum class MapLayerActionFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( MapLayerActionFlag )
 
    
    Q_DECLARE_FLAGS( MapLayerActionFlags, MapLayerActionFlag )
    Q_FLAG( MapLayerActionFlags )
 
    enum class AttributeActionType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAction, ActionType ) : int
      {
      Generic, 
      GenericPython, 
      Mac, 
      Windows, 
      Unix, 
      OpenUrl, 
      SubmitUrlEncoded, 
      SubmitUrlMultipart, 
    };
    enum class AttributeActionType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAction, ActionType ) : int {…};
    Q_ENUM( AttributeActionType )
 
    
    enum class MetadataDateType
    {
      Created, 
      Published, 
      Revised, 
      Superseded, 
    };
    enum class MetadataDateType {…};
    Q_ENUM( MetadataDateType )
 
    
    enum class RasterColorInterpretation SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, ColorInterpretation ) : int
      {
      Undefined SIP_MONKEYPATCH_COMPAT_NAME( UndefinedColorInterpretation ) = 0, 
      GrayIndex = 1,          
      PaletteIndex = 2,       
      RedBand = 3,            
      GreenBand = 4,          
      BlueBand = 5,           
      AlphaBand = 6,          
      HueBand = 7,            
      SaturationBand = 8,     
      LightnessBand = 9,      
      CyanBand = 10,          
      MagentaBand = 11,       
      YellowBand = 12,        
      BlackBand = 13,         
      YCbCr_YBand = 14,       
      YCbCr_CbBand = 15,      
      YCbCr_CrBand = 16,      
      ContinuousPalette = 17, 
 
      // Note: values between PanBand and SAR_P_Band match additions done in
      // GDAL 3.10, except that the numeric values of the constant don't match GDAL ones
 
      PanBand = 18,           
      CoastalBand = 19,       
      RedEdgeBand = 20,       
      NIRBand = 21,           
      SWIRBand = 22,          
      MWIRBand = 23,          
      LWIRBand = 24,          
      TIRBand = 25,           
      OtherIRBand = 26,       
      SAR_Ka_Band = 27,       
      SAR_K_Band = 28,        
      SAR_Ku_Band = 30,       
      SAR_X_Band = 31,        
      SAR_C_Band = 32,        
      SAR_S_Band = 33,        
      SAR_L_Band = 34,        
      SAR_P_Band = 35,        
    };
    enum class RasterColorInterpretation SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, ColorInterpretation ) : int {…};
    Q_ENUM( RasterColorInterpretation )
 
    
    enum class RasterLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterLayer, LayerType ) : int
      {
      GrayOrUndefined, 
      Palette, 
      MultiBand SIP_MONKEYPATCH_COMPAT_NAME( Multiband ), 
      SingleBandColorData SIP_MONKEYPATCH_COMPAT_NAME( ColorLayer ), 
    };
    enum class RasterLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterLayer, LayerType ) : int {…};
    Q_ENUM( RasterLayerType )
 
    
    enum class RasterDrawingStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, DrawingStyle ) : int
      {
      Undefined SIP_MONKEYPATCH_COMPAT_NAME( UndefinedDrawingStyle ),
      SingleBandGray, 
      SingleBandPseudoColor, 
      PalettedColor, 
      PalettedSingleBandGray, 
      PalettedSingleBandPseudoColor, 
      PalettedMultiBandColor, 
      MultiBandSingleBandGray, 
      MultiBandSingleBandPseudoColor, 
      MultiBandColor, 
      SingleBandColorData SIP_MONKEYPATCH_COMPAT_NAME( SingleBandColorDataStyle ), 
    };
    enum class RasterDrawingStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, DrawingStyle ) : int {…};
    Q_ENUM( RasterDrawingStyle )
 
    
    enum class RasterPyramidFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, RasterPyramidsFormat ) : int
      {
      GeoTiff SIP_MONKEYPATCH_COMPAT_NAME( PyramidsGTiff ) = 0, 
      Internal SIP_MONKEYPATCH_COMPAT_NAME( PyramidsInternal ) = 1, 
      Erdas SIP_MONKEYPATCH_COMPAT_NAME( PyramidsErdas ) = 2 
    };
    enum class RasterPyramidFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, RasterPyramidsFormat ) : int {…};
    Q_ENUM( RasterPyramidFormat )
 
    
    enum class RasterBuildPyramidOption SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, RasterBuildPyramids ) : int
      {
      No SIP_MONKEYPATCH_COMPAT_NAME( PyramidsFlagNo ) = 0, 
      Yes SIP_MONKEYPATCH_COMPAT_NAME( PyramidsFlagYes ) = 1, 
      CopyExisting SIP_MONKEYPATCH_COMPAT_NAME( PyramidsCopyExisting ) = 2 
    };
    enum class RasterBuildPyramidOption SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, RasterBuildPyramids ) : int {…};
    Q_ENUM( RasterBuildPyramidOption )
 
    
    enum class RasterIdentifyFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, IdentifyFormat ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Undefined SIP_MONKEYPATCH_COMPAT_NAME( IdentifyFormatUndefined ) = 0, 
      Value SIP_MONKEYPATCH_COMPAT_NAME( IdentifyFormatValue ) = 1, 
      Text SIP_MONKEYPATCH_COMPAT_NAME( IdentifyFormatText ) = 1 << 1, 
      Html SIP_MONKEYPATCH_COMPAT_NAME( IdentifyFormatHtml ) = 1 << 2, 
      Feature SIP_MONKEYPATCH_COMPAT_NAME( IdentifyFormatFeature ) = 1 << 3, 
    };
    enum class RasterIdentifyFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRaster, IdentifyFormat ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterIdentifyFormat )
 
    // TODO QGIS 4 -- remove NoCapabilities and rely on RasterInterfaceCapabilities() instead
    // remove deprecated members
    // Remove "Identify" member, and replace with combinations of IdentifyValue/IdentifyText/etc
 
    
    enum class RasterInterfaceCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterInterface, Capability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0, 
      Size = 1 << 1, 
      Create = 1 << 2, 
      Remove = 1 << 3, 
      BuildPyramids = 1 << 4, 
      Identify = 1 << 5, 
      IdentifyValue = 1 << 6, 
      IdentifyText = 1 << 7, 
      IdentifyHtml = 1 << 8, 
      IdentifyFeature = 1 << 9, 
      Prefetch = 1 << 10, 
    };
    enum class RasterInterfaceCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterInterface, Capability ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterInterfaceCapability )
 
    
    Q_DECLARE_FLAGS( RasterInterfaceCapabilities, RasterInterfaceCapability )
    Q_FLAG( RasterInterfaceCapabilities )
 
    // TODO QGIS 4 -- remove NoProviderCapabilities and rely on RasterProviderCapabilities() instead
 
    enum class RasterProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ProviderCapability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoProviderCapabilities = 0, 
      ReadLayerMetadata = 1 << 1, 
      WriteLayerMetadata = 1 << 2, 
      ProviderHintBenefitsFromResampling = 1 << 3, 
      ProviderHintCanPerformProviderResampling = 1 << 4, 
      ReloadData = 1 << 5, 
      DpiDependentData = 1 << 6, 
      NativeRasterAttributeTable = 1 << 7, 
      BuildPyramids = 1 << 8, 
    };
    enum class RasterProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ProviderCapability ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterProviderCapability )
 
    
    Q_DECLARE_FLAGS( RasterProviderCapabilities, RasterProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsRasterDataProvider, ProviderCapabilities )
    Q_FLAG( RasterProviderCapabilities )
 
    enum class ElevationMapCombineMethod : int
    {
      HighestElevation, 
      NewerElevation, 
    };
    enum class ElevationMapCombineMethod : int {…};
    Q_ENUM( ElevationMapCombineMethod )
 
    
    enum class BlendMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPainting, BlendMode ) : int
      {
      Normal SIP_MONKEYPATCH_COMPAT_NAME( BlendNormal ), 
      Lighten SIP_MONKEYPATCH_COMPAT_NAME( BlendLighten ), 
      Screen SIP_MONKEYPATCH_COMPAT_NAME( BlendScreen ), 
      Dodge SIP_MONKEYPATCH_COMPAT_NAME( BlendDodge ), 
      Addition SIP_MONKEYPATCH_COMPAT_NAME( BlendAddition ), 
      Darken SIP_MONKEYPATCH_COMPAT_NAME( BlendDarken ), 
      Multiply SIP_MONKEYPATCH_COMPAT_NAME( BlendMultiply ), 
      Burn SIP_MONKEYPATCH_COMPAT_NAME( BlendBurn ), 
      Overlay SIP_MONKEYPATCH_COMPAT_NAME( BlendOverlay ), 
      SoftLight SIP_MONKEYPATCH_COMPAT_NAME( BlendSoftLight ), 
      HardLight SIP_MONKEYPATCH_COMPAT_NAME( BlendHardLight ), 
      Difference SIP_MONKEYPATCH_COMPAT_NAME( BlendDifference ), 
      Subtract SIP_MONKEYPATCH_COMPAT_NAME( BlendSubtract ), 
      Source SIP_MONKEYPATCH_COMPAT_NAME( BlendSource ), 
      DestinationOver SIP_MONKEYPATCH_COMPAT_NAME( BlendDestinationOver ), 
      Clear SIP_MONKEYPATCH_COMPAT_NAME( BlendClear ), 
      Destination SIP_MONKEYPATCH_COMPAT_NAME( BlendDestination ), 
      SourceIn SIP_MONKEYPATCH_COMPAT_NAME( BlendSourceIn ), 
      DestinationIn SIP_MONKEYPATCH_COMPAT_NAME( BlendDestinationIn ), 
      SourceOut SIP_MONKEYPATCH_COMPAT_NAME( BlendSourceOut ), 
      DestinationOut SIP_MONKEYPATCH_COMPAT_NAME( BlendDestinationOut ), 
      SourceAtop SIP_MONKEYPATCH_COMPAT_NAME( BlendSourceAtop ), 
      DestinationAtop SIP_MONKEYPATCH_COMPAT_NAME( BlendDestinationAtop ), 
      Xor SIP_MONKEYPATCH_COMPAT_NAME( BlendXor ), 
    };
    enum class BlendMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPainting, BlendMode ) : int {…};
    Q_ENUM( BlendMode )
 
    
    enum class SystemOfMeasurement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, SystemOfMeasurement ) : int
      {
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( UnknownSystem ) = 0, 
      Metric SIP_MONKEYPATCH_COMPAT_NAME( MetricSystem ), 
      Imperial SIP_MONKEYPATCH_COMPAT_NAME( ImperialSystem ), 
      USCS SIP_MONKEYPATCH_COMPAT_NAME( USCSSystem ), 
    };
    enum class SystemOfMeasurement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, SystemOfMeasurement ) : int {…};
    Q_ENUM( SystemOfMeasurement )
 
    
    enum class MapToolUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTolerance, UnitType ) : int
      {
      Layer SIP_MONKEYPATCH_COMPAT_NAME( LayerUnits ), 
      Pixels, 
      Project  SIP_MONKEYPATCH_COMPAT_NAME( ProjectUnits ) 
    };
    enum class MapToolUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTolerance, UnitType ) : int {…};
    Q_ENUM( MapToolUnit )
 
    
    enum class UnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, UnitType ) : int
      {
      Distance SIP_MONKEYPATCH_COMPAT_NAME( TypeDistance ) = 0, 
      Area SIP_MONKEYPATCH_COMPAT_NAME( TypeArea ), 
      Volume SIP_MONKEYPATCH_COMPAT_NAME( TypeVolume ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( TypeUnknown ), 
      Temporal SIP_MONKEYPATCH_COMPAT_NAME( TypeTemporal ), 
    };
    enum class UnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, UnitType ) : int {…};
    Q_ENUM( UnitType )
 
    
    enum class DistanceUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, DistanceUnit ) : int
      {
      Meters SIP_MONKEYPATCH_COMPAT_NAME( DistanceMeters ), 
      Kilometers SIP_MONKEYPATCH_COMPAT_NAME( DistanceKilometers ), 
      Feet SIP_MONKEYPATCH_COMPAT_NAME( DistanceFeet ), 
      NauticalMiles SIP_MONKEYPATCH_COMPAT_NAME( DistanceNauticalMiles ), 
      Yards SIP_MONKEYPATCH_COMPAT_NAME( DistanceYards ), 
      Miles SIP_MONKEYPATCH_COMPAT_NAME( DistanceMiles ), 
      Degrees SIP_MONKEYPATCH_COMPAT_NAME( DistanceDegrees ), 
      Centimeters SIP_MONKEYPATCH_COMPAT_NAME( DistanceCentimeters ), 
      Millimeters SIP_MONKEYPATCH_COMPAT_NAME( DistanceMillimeters ), 
      Inches, 
      ChainsInternational, 
      ChainsBritishBenoit1895A, 
      ChainsBritishBenoit1895B, 
      ChainsBritishSears1922Truncated, 
      ChainsBritishSears1922, 
      ChainsClarkes, 
      ChainsUSSurvey, 
      FeetBritish1865, 
      FeetBritish1936, 
      FeetBritishBenoit1895A, 
      FeetBritishBenoit1895B, 
      FeetBritishSears1922Truncated, 
      FeetBritishSears1922, 
      FeetClarkes, 
      FeetGoldCoast, 
      FeetIndian, 
      FeetIndian1937, 
      FeetIndian1962, 
      FeetIndian1975, 
      FeetUSSurvey, 
      LinksInternational, 
      LinksBritishBenoit1895A, 
      LinksBritishBenoit1895B, 
      LinksBritishSears1922Truncated, 
      LinksBritishSears1922, 
      LinksClarkes, 
      LinksUSSurvey, 
      YardsBritishBenoit1895A, 
      YardsBritishBenoit1895B, 
      YardsBritishSears1922Truncated, 
      YardsBritishSears1922, 
      YardsClarkes, 
      YardsIndian, 
      YardsIndian1937, 
      YardsIndian1962, 
      YardsIndian1975, 
      MilesUSSurvey, 
      Fathoms, 
      MetersGermanLegal, 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( DistanceUnknownUnit ), 
    };
    enum class DistanceUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, DistanceUnit ) : int {…};
    Q_ENUM( DistanceUnit )
 
    
    enum class DistanceUnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, DistanceUnitType ) : int
      {
      Standard, 
      Geographic, 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( UnknownType ),  
    };
    enum class DistanceUnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, DistanceUnitType ) : int {…};
    Q_ENUM( DistanceUnitType )
 
    
    enum class AreaUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, AreaUnit ) : int
      {
      SquareMeters SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareMeters ), 
      SquareKilometers SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareKilometers ), 
      SquareFeet SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareFeet ), 
      SquareYards SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareYards ), 
      SquareMiles SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareMiles ), 
      Hectares SIP_MONKEYPATCH_COMPAT_NAME( AreaHectares ), 
      Acres SIP_MONKEYPATCH_COMPAT_NAME( AreaAcres ), 
      SquareNauticalMiles SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareNauticalMiles ), 
      SquareDegrees SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareDegrees ), 
      SquareCentimeters SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareCentimeters ), 
      SquareMillimeters SIP_MONKEYPATCH_COMPAT_NAME( AreaSquareMillimeters ), 
      SquareInches, 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( AreaUnknownUnit ), 
    };
    enum class AreaUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, AreaUnit ) : int {…};
    Q_ENUM( AreaUnit )
 
    
    enum class VolumeUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, VolumeUnit ) : int
      {
      CubicMeters SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicMeters ), 
      CubicFeet SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicFeet ), 
      CubicYards SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicYards ), 
      Barrel SIP_MONKEYPATCH_COMPAT_NAME( VolumeBarrel ), 
      CubicDecimeter SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicDecimeter ), 
      Liters SIP_MONKEYPATCH_COMPAT_NAME( VolumeLiters ), 
      GallonUS SIP_MONKEYPATCH_COMPAT_NAME( VolumeGallonUS ), 
      CubicInch SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicInch ), 
      CubicCentimeter SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicCentimeter ), 
      CubicDegrees SIP_MONKEYPATCH_COMPAT_NAME( VolumeCubicDegrees ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( VolumeUnknownUnit ), 
    };
    enum class VolumeUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, VolumeUnit ) : int {…};
    Q_ENUM( VolumeUnit )
 
    
    enum class AngleUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, AngleUnit ) : int
      {
      Degrees SIP_MONKEYPATCH_COMPAT_NAME( AngleDegrees ), 
      Radians SIP_MONKEYPATCH_COMPAT_NAME( AngleRadians ), 
      Gon SIP_MONKEYPATCH_COMPAT_NAME( AngleGon ), 
      MinutesOfArc SIP_MONKEYPATCH_COMPAT_NAME( AngleMinutesOfArc ), 
      SecondsOfArc SIP_MONKEYPATCH_COMPAT_NAME( AngleSecondsOfArc ), 
      Turn SIP_MONKEYPATCH_COMPAT_NAME( AngleTurn ), 
      MilliradiansSI SIP_MONKEYPATCH_COMPAT_NAME( AngleMilliradiansSI ), 
      MilNATO SIP_MONKEYPATCH_COMPAT_NAME( AngleMilNATO ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( AngleUnknownUnit ), 
    };
    enum class AngleUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, AngleUnit ) : int {…};
    Q_ENUM( AngleUnit )
 
    
    enum class TemporalUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, TemporalUnit ) : int
      {
      Milliseconds SIP_MONKEYPATCH_COMPAT_NAME( TemporalMilliseconds ), 
      Seconds SIP_MONKEYPATCH_COMPAT_NAME( TemporalSeconds ), 
      Minutes SIP_MONKEYPATCH_COMPAT_NAME( TemporalMinutes ), 
      Hours SIP_MONKEYPATCH_COMPAT_NAME( TemporalHours ), 
      Days SIP_MONKEYPATCH_COMPAT_NAME( TemporalDays ), 
      Weeks SIP_MONKEYPATCH_COMPAT_NAME( TemporalWeeks ), 
      Months SIP_MONKEYPATCH_COMPAT_NAME( TemporalMonths ),  
      Years SIP_MONKEYPATCH_COMPAT_NAME( TemporalYears ), 
      Decades SIP_MONKEYPATCH_COMPAT_NAME( TemporalDecades ), 
      Centuries SIP_MONKEYPATCH_COMPAT_NAME( TemporalCenturies ), 
      IrregularStep SIP_MONKEYPATCH_COMPAT_NAME( TemporalIrregularStep ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( TemporalUnknownUnit ) 
    };
    enum class TemporalUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, TemporalUnit ) : int {…};
    Q_ENUM( TemporalUnit )
 
    
    enum class RenderUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, RenderUnit ) : int
      {
      Millimeters SIP_MONKEYPATCH_COMPAT_NAME( RenderMillimeters ), 
      MapUnits SIP_MONKEYPATCH_COMPAT_NAME( RenderMapUnits ), 
      Pixels SIP_MONKEYPATCH_COMPAT_NAME( RenderPixels ), 
      Percentage SIP_MONKEYPATCH_COMPAT_NAME( RenderPercentage ), 
      Points SIP_MONKEYPATCH_COMPAT_NAME( RenderPoints ), 
      Inches SIP_MONKEYPATCH_COMPAT_NAME( RenderInches ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( RenderUnknownUnit ), 
      MetersInMapUnits SIP_MONKEYPATCH_COMPAT_NAME( RenderMetersInMapUnits ), 
    };
    enum class RenderUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, RenderUnit ) : int {…};
    Q_ENUM( RenderUnit )
 
    
    enum class LayoutUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, LayoutUnit ) : int
      {
      Millimeters SIP_MONKEYPATCH_COMPAT_NAME( LayoutMillimeters ), 
      Centimeters SIP_MONKEYPATCH_COMPAT_NAME( LayoutCentimeters ), 
      Meters SIP_MONKEYPATCH_COMPAT_NAME( LayoutMeters ), 
      Inches SIP_MONKEYPATCH_COMPAT_NAME( LayoutInches ), 
      Feet SIP_MONKEYPATCH_COMPAT_NAME( LayoutFeet ), 
      Points SIP_MONKEYPATCH_COMPAT_NAME( LayoutPoints ), 
      Picas SIP_MONKEYPATCH_COMPAT_NAME( LayoutPicas ), 
      Pixels SIP_MONKEYPATCH_COMPAT_NAME( LayoutPixels ) 
    };
    enum class LayoutUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, LayoutUnit ) : int {…};
    Q_ENUM( LayoutUnit )
 
    
    enum class LayoutUnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, LayoutUnitType ) : int
      {
      PaperUnits SIP_MONKEYPATCH_COMPAT_NAME( LayoutPaperUnits ), 
      ScreenUnits SIP_MONKEYPATCH_COMPAT_NAME( LayoutScreenUnits ) 
    };
    enum class LayoutUnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, LayoutUnitType ) : int {…};
    Q_ENUM( LayoutUnitType )
 
    
    enum class PictureFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemPicture, Format ) : int
      {
      SVG SIP_MONKEYPATCH_COMPAT_NAME( FormatSVG ) = 0, 
      Raster SIP_MONKEYPATCH_COMPAT_NAME( FormatRaster ), 
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( FormatUnknown ), 
    };
    enum class PictureFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemPicture, Format ) : int {…};
    Q_ENUM( PictureFormat )
 
    
    enum class ScaleCalculationMethod : int
    {
      HorizontalTop = 0, 
      HorizontalMiddle, 
      HorizontalBottom, 
      HorizontalAverage, 
      AtEquator, 
    };
    enum class ScaleCalculationMethod : int {…};
    Q_ENUM( ScaleCalculationMethod )
 
    
    enum class ScaleBarAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, Alignment ) : int
      {
      Left SIP_MONKEYPATCH_COMPAT_NAME( AlignLeft ) = 0, 
      Middle SIP_MONKEYPATCH_COMPAT_NAME( AlignMiddle ), 
      Right SIP_MONKEYPATCH_COMPAT_NAME( AlignRight ), 
    };
    enum class ScaleBarAlignment SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, Alignment ) : int {…};
    Q_ENUM( ScaleBarAlignment )
 
    
    enum class ScaleBarSegmentSizeMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, SegmentSizeMode ) : int
      {
      Fixed SIP_MONKEYPATCH_COMPAT_NAME( SegmentSizeFixed ) = 0, 
      FitWidth SIP_MONKEYPATCH_COMPAT_NAME( SegmentSizeFitWidth ) = 1 
    };
    enum class ScaleBarSegmentSizeMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, SegmentSizeMode ) : int {…};
    Q_ENUM( ScaleBarSegmentSizeMode )
 
    
    enum class ScaleBarDistanceLabelVerticalPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, LabelVerticalPlacement ) : int
      {
      AboveSegment SIP_MONKEYPATCH_COMPAT_NAME( LabelAboveSegment ) = 0, 
      BelowSegment SIP_MONKEYPATCH_COMPAT_NAME( LabelBelowSegment ), 
    };
    enum class ScaleBarDistanceLabelVerticalPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, LabelVerticalPlacement ) : int {…};
    Q_ENUM( ScaleBarDistanceLabelVerticalPlacement )
 
    
    enum class ScaleBarDistanceLabelHorizontalPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, LabelHorizontalPlacement ) : int
      {
      CenteredEdge SIP_MONKEYPATCH_COMPAT_NAME( LabelCenteredEdge ) = 0, 
      CenteredSegment SIP_MONKEYPATCH_COMPAT_NAME( LabelCenteredSegment ), 
    };
    enum class ScaleBarDistanceLabelHorizontalPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsScaleBarSettings, LabelHorizontalPlacement ) : int {…};
    Q_ENUM( ScaleBarDistanceLabelHorizontalPlacement )
 
    
    enum class InputControllerType : int
    {
      Map2D, 
      Map3D 
    };
    enum class InputControllerType : int {…};
    Q_ENUM( InputControllerType );
 
    enum class PostgresRelKind
    {
      NotSet, 
      Unknown, 
      OrdinaryTable, 
      Index, 
      Sequence, 
      View, 
      MaterializedView, 
      CompositeType, 
      ToastTable, 
      ForeignTable, 
      PartitionedTable, 
    };
    enum class PostgresRelKind {…};
    Q_ENUM( PostgresRelKind )
 
    
    enum class DatabaseProviderConnectionCapability2 : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SetFieldComment = 1 << 0, 
      SetFieldAlias = 1 << 1, 
      SetTableComment = 1 << 2, 
    };
    enum class DatabaseProviderConnectionCapability2 : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( DatabaseProviderConnectionCapability2 )
    Q_DECLARE_FLAGS( DatabaseProviderConnectionCapabilities2, DatabaseProviderConnectionCapability2 )
    Q_FLAG( DatabaseProviderConnectionCapabilities2 )
 
    enum class DatabaseProviderTableImportCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SetGeometryColumnName = 1 << 0, 
      SetPrimaryKeyName = 1 << 1, 
    };
    enum class DatabaseProviderTableImportCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( DatabaseProviderTableImportCapability )
    Q_DECLARE_FLAGS( DatabaseProviderTableImportCapabilities, DatabaseProviderTableImportCapability )
    Q_FLAG( DatabaseProviderTableImportCapabilities )
 
    enum class ProviderStyleStorageCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SaveToDatabase = 1 << 1,
      LoadFromDatabase = 1 << 2,
      DeleteFromDatabase = 1 << 3
    };
    enum class ProviderStyleStorageCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ProviderStyleStorageCapability );
    Q_DECLARE_FLAGS( ProviderStyleStorageCapabilities, ProviderStyleStorageCapability )
    Q_FLAG( ProviderStyleStorageCapabilities )
 
    
    enum class UserProfileSelectionPolicy : int
    {
      LastProfile, 
      DefaultProfile, 
      AskUser, 
    };
    enum class UserProfileSelectionPolicy : int {…};
    Q_ENUM( UserProfileSelectionPolicy )
 
    
    enum class AttributeEditorType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAttributeEditorElement, AttributeEditorType ) : int
      {
      Container SIP_MONKEYPATCH_COMPAT_NAME( AeTypeContainer ), 
      Field SIP_MONKEYPATCH_COMPAT_NAME( AeTypeField ), 
      Relation SIP_MONKEYPATCH_COMPAT_NAME( AeTypeRelation ), 
      QmlElement SIP_MONKEYPATCH_COMPAT_NAME( AeTypeQmlElement ), 
      HtmlElement SIP_MONKEYPATCH_COMPAT_NAME( AeTypeHtmlElement ), 
      Action SIP_MONKEYPATCH_COMPAT_NAME( AeTypeAction ), 
      TextElement SIP_MONKEYPATCH_COMPAT_NAME( AeTypeTextElement ), 
      SpacerElement SIP_MONKEYPATCH_COMPAT_NAME( AeTypeSpacerElement ), 
      Invalid SIP_MONKEYPATCH_COMPAT_NAME( AeTypeInvalid ), 
    };
    enum class AttributeEditorType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAttributeEditorElement, AttributeEditorType ) : int {…};
    Q_ENUM( AttributeEditorType )
 
    
    enum class AttributeEditorContainerType : int
    {
      GroupBox, 
      Tab, 
      Row, 
    };
    enum class AttributeEditorContainerType : int {…};
    Q_ENUM( AttributeEditorContainerType )
 
    
    enum class AttributeFormLayout SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, EditorLayout ) : int
      {
      AutoGenerated SIP_MONKEYPATCH_COMPAT_NAME( GeneratedLayout ) = 0, 
      DragAndDrop SIP_MONKEYPATCH_COMPAT_NAME( TabLayout ) = 1, 
      UiFile SIP_MONKEYPATCH_COMPAT_NAME( UiFileLayout ) = 2 
    };
    enum class AttributeFormLayout SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, EditorLayout ) : int {…};
    Q_ENUM( AttributeFormLayout )
 
    
    enum class AttributeFormSuppression SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, FeatureFormSuppress ) : int
      {
      Default SIP_MONKEYPATCH_COMPAT_NAME( SuppressDefault ) = 0, 
      On SIP_MONKEYPATCH_COMPAT_NAME( SuppressOn ) = 1, 
      Off SIP_MONKEYPATCH_COMPAT_NAME( SuppressOff ) = 2 
    };
    enum class AttributeFormSuppression SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, FeatureFormSuppress ) : int {…};
    Q_ENUM( AttributeFormSuppression )
 
    
    enum class AttributeFormPythonInitCodeSource SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, PythonInitCodeSource ) : int
      {
      NoSource SIP_MONKEYPATCH_COMPAT_NAME( CodeSourceNone ) = 0, 
      File SIP_MONKEYPATCH_COMPAT_NAME( CodeSourceFile ) = 1, 
      Dialog SIP_MONKEYPATCH_COMPAT_NAME( CodeSourceDialog ) = 2, 
      Environment SIP_MONKEYPATCH_COMPAT_NAME( CodeSourceEnvironment ) = 3 
    };
    enum class AttributeFormPythonInitCodeSource SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsEditFormConfig, PythonInitCodeSource ) : int {…};
    Q_ENUM( AttributeFormPythonInitCodeSource )
 
    
    enum class ExpressionType
    {
      Qgis, 
      PointCloud, 
      RasterCalculator, 
    };
    enum class ExpressionType {…};
    Q_ENUM( ExpressionType )
 
    
    enum class FeatureSymbologyExport SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorFileWriter, SymbologyExport ) : int
      {
      NoSymbology = 0, 
      PerFeature SIP_MONKEYPATCH_COMPAT_NAME( FeatureSymbology ), 
      PerSymbolLayer SIP_MONKEYPATCH_COMPAT_NAME( SymbolLayerSymbology ) 
    };
    enum class FeatureSymbologyExport SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorFileWriter, SymbologyExport ) : int {…};
    Q_ENUM( FeatureSymbologyExport )
 
    
    enum class VectorTileProviderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AlwaysUseTileMatrixSetFromProvider = 1 << 1, 
    };
    enum class VectorTileProviderFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorTileProviderFlag )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderFlags, VectorTileProviderFlag )
    Q_FLAG( VectorTileProviderFlags )
 
    enum class VectorTileProviderCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ReadLayerMetadata = 1 << 1, 
    };
    enum class VectorTileProviderCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( VectorTileProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderCapabilities, VectorTileProviderCapability )
    Q_FLAG( VectorTileProviderCapabilities )
 
    enum class TileAvailability
    {
      Available, 
      NotAvailable, 
      AvailableNoChildren, 
      UseLowerZoomLevelTile, 
    };
    enum class TileAvailability {…};
    Q_ENUM( TileAvailability )
 
    
    enum class TiledSceneProviderCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ReadLayerMetadata = 1 << 1, 
    };
    enum class TiledSceneProviderCapability : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( TiledSceneProviderCapability )
 
    
    Q_DECLARE_FLAGS( TiledSceneProviderCapabilities, TiledSceneProviderCapability )
    Q_FLAG( TiledSceneProviderCapabilities )
 
    enum class TiledSceneBoundingVolumeType
    {
      Region, 
      OrientedBox, 
      Sphere, 
    };
    enum class TiledSceneBoundingVolumeType {…};
    Q_ENUM( TiledSceneBoundingVolumeType )
 
    
    enum class TileRefinementProcess
    {
      Replacement, 
      Additive, 
    };
    enum class TileRefinementProcess {…};
    Q_ENUM( TileRefinementProcess )
 
    
    enum class TileChildrenAvailability
    {
      NoChildren, 
      Available, 
      NeedFetching, 
    };
    enum class TileChildrenAvailability {…};
    Q_ENUM( TileChildrenAvailability )
 
    
    enum class TiledSceneRequestFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoHierarchyFetch = 1 << 0,  
    };
    enum class TiledSceneRequestFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( TiledSceneRequestFlag )
 
    
    Q_DECLARE_FLAGS( TiledSceneRequestFlags, TiledSceneRequestFlag )
    Q_FLAG( TiledSceneRequestFlags )
 
    enum class TiledSceneRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RequiresTextures = 1 << 0,  
      ForceRasterRender = 1 << 1, 
      RendersTriangles = 1 << 2, 
      RendersLines = 1 << 3, 
    };
    enum class TiledSceneRendererFlag : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( TiledSceneRendererFlag )
 
    
    Q_DECLARE_FLAGS( TiledSceneRendererFlags, TiledSceneRendererFlag )
    Q_FLAG( TiledSceneRendererFlags )
 
    enum class GdalResampleAlgorithm : int
    {
      RA_NearestNeighbour = 0, 
      RA_Bilinear = 1,       
      RA_Cubic = 2,          
      RA_CubicSpline = 3,    
      RA_Lanczos = 4,        
      RA_Average = 5,        
      RA_Mode = 6,            
      RA_Max = 8, 
      RA_Min = 9, 
      RA_Median = 10, 
      RA_Q1 = 11, 
      RA_Q3 = 12, 
    };
    enum class GdalResampleAlgorithm : int {…};
    Q_ENUM( GdalResampleAlgorithm )
 
    
    enum class VsiHandlerType : int
    {
      Invalid, 
      Archive, 
      Network, 
      Cloud, 
      Memory, 
      Other, 
    };
    enum class VsiHandlerType : int {…};
    Q_ENUM( VsiHandlerType )
 
    // TODO QGIS 4: make All include all values (we can't do this before 4.0, as we need to keep
    // compatibility with code which expects all these statistics to give numeric results)
 
    
    enum class ZonalStatistic : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Count = 1 << 0,  
      Sum = 1 << 1,  
      Mean = 1 << 2,  
      Median = 1 << 3, 
      StDev = 1 << 4, 
      Min = 1 << 5,  
      Max = 1 << 6,  
      Range = 1 << 7, 
      Minority = 1 << 8, 
      Majority = 1 << 9, 
      Variety = 1 << 10, 
      Variance = 1 << 11, 
      MinimumPoint = 1 << 12, 
      MaximumPoint = 1 << 13, 
      All = Count | Sum | Mean | Median | StDev | Max | Min | Range | Minority | Majority | Variety | Variance, 
      AllNumeric = Count | Sum | Mean | Median | StDev | Max | Min | Range | Minority | Majority | Variety | Variance, 
      Default = Count | Sum | Mean, 
    };
    enum class ZonalStatistic : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( ZonalStatistic )
 
    
    Q_DECLARE_FLAGS( ZonalStatistics, ZonalStatistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( Qgis, ZonalStatistics )
    Q_FLAG( ZonalStatistics )
 
    enum class ZonalStatisticResult : int
    {
      Success = 0, 
      LayerTypeWrong = 1, 
      LayerInvalid, 
      RasterInvalid, 
      RasterBandInvalid, 
      FailedToCreateField = 8, 
      Canceled = 9 
    };
    enum class ZonalStatisticResult : int {…};
    Q_ENUM( ZonalStatisticResult )
 
    
    enum class Aggregate SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAggregateCalculator, Aggregate ) : int
      {
      Count, 
      CountDistinct, 
      CountMissing, 
      Min, 
      Max, 
      Sum, 
      Mean, 
      Median, 
      StDev, 
      StDevSample,
      Range, 
      Minority, 
      Majority, 
      FirstQuartile, 
      ThirdQuartile, 
      InterQuartileRange, 
      StringMinimumLength, 
      StringMaximumLength, 
      StringConcatenate, 
      GeometryCollect, 
      ArrayAggregate, 
      StringConcatenateUnique 
    };
    enum class Aggregate SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsAggregateCalculator, Aggregate ) : int {…};
    Q_ENUM( Aggregate )
 
    
    enum class Statistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Count = 1 << 0,  
      CountMissing = 1 << 15, 
      Sum = 1 << 1,  
      Mean = 1 << 2,  
      Median = 1 << 3, 
      StDev = 1 << 4, 
      StDevSample = 1 << 5, 
      Min = 1 << 6,  
      Max = 1 << 7,  
      Range = 1 << 8, 
      Minority = 1 << 9, 
      Majority = 1 << 10, 
      Variety = 1 << 11, 
      FirstQuartile = 1 << 12, 
      ThirdQuartile = 1 << 13, 
      InterQuartileRange = 1 << 14, 
      First = 1 << 16, 
      Last = 1 << 17, 
      All = Count | CountMissing | Sum | Mean | Median | StDev | Max | Min | Range | Minority | Majority | Variety | FirstQuartile | ThirdQuartile | InterQuartileRange | First | Last 
    };
    enum class Statistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( Statistic )
 
    
    Q_DECLARE_FLAGS( Statistics, Statistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsStatisticalSummary, Statistics )
    Q_FLAG( Statistics )
 
    enum class DateTimeStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDateTimeStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Count = 1,  
      CountDistinct = 2,  
      CountMissing = 4,  
      Min = 8, 
      Max = 16, 
      Range = 32, 
      All = Count | CountDistinct | CountMissing | Min | Max | Range, 
    };
    enum class DateTimeStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDateTimeStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( DateTimeStatistic )
 
    
    Q_DECLARE_FLAGS( DateTimeStatistics, DateTimeStatistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDateTimeStatisticalSummary, Statistics )
    Q_FLAG( DateTimeStatistics )
 
    enum class StringStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStringStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Count = 1,  
      CountDistinct = 2,  
      CountMissing = 4,  
      Min = 8, 
      Max = 16, 
      MinimumLength = 32, 
      MaximumLength = 64, 
      MeanLength = 128, 
      Minority = 256, 
      Majority = 512, 
      All = Count | CountDistinct | CountMissing | Min | Max | MinimumLength | MaximumLength | MeanLength | Minority | Majority, 
    };
    enum class StringStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsStringStatisticalSummary, Statistic ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( StringStatistic )
 
    
    Q_DECLARE_FLAGS( StringStatistics, StringStatistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsStringStatisticalSummary, Statistics )
    Q_FLAG( StringStatistics )
 
    enum class RasterBandStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterBandStats, Stats ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoStatistic = 0, 
      Min = 1, 
      Max = 1 << 1, 
      Range = 1 << 2, 
      Sum = 1 << 3, 
      Mean = 1 << 4, 
      StdDev = 1 << 5, 
      SumOfSquares = 1 << 6, 
      All = Min | Max | Range | Sum | Mean | StdDev | SumOfSquares 
    };
    enum class RasterBandStatistic SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterBandStats, Stats ) : int SIP_ENUM_BASETYPE( IntFlag ) {…};
    Q_ENUM( RasterBandStatistic )
 
    
    Q_DECLARE_FLAGS( RasterBandStatistics, RasterBandStatistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( Qgis, RasterBandStatistics )
    Q_FLAG( RasterBandStatistics )
 
    enum class SensorThingsEntity : int
    {
      Invalid, 
      Thing, 
      Location, 
      HistoricalLocation, 
      Datastream, 
      Sensor, 
      ObservedProperty, 
      Observation, 
      FeatureOfInterest, 
      MultiDatastream, 
    };
    enum class SensorThingsEntity : int {…};
    Q_ENUM( SensorThingsEntity )
 
    
    enum class ColorModel : int
    {
      Rgb, 
      Cmyk, 
    };
    enum class ColorModel : int {…};
    Q_ENUM( ColorModel )
 
    
    enum class DocumentationApi : int
    {
      PyQgis, 
      PyQgisSearch, 
      CppQgis, 
      Qt, 
    };
    enum class DocumentationApi : int {…};
    Q_ENUM( DocumentationApi )
 
    
    enum class DocumentationBrowser : int
    {
      DeveloperToolsPanel, 
      SystemWebBrowser, 
    };
    enum class DocumentationBrowser : int {…};
    Q_ENUM( DocumentationBrowser )
 
    
    enum class MouseHandlesAction : int
    {
      MoveItem, 
      ResizeUp, 
      ResizeDown, 
      ResizeLeft, 
      ResizeRight, 
      ResizeLeftUp, 
      ResizeRightUp, 
      ResizeLeftDown, 
      ResizeRightDown, 
      SelectItem, 
      NoAction 
    };
    enum class MouseHandlesAction : int {…};
    Q_ENUM( MouseHandlesAction )
 
    
    enum class MeshRangeLimit : int
    {
      NotSet, 
      MinimumMaximum,  
    };
    enum class MeshRangeLimit : int {…};
    Q_ENUM( MeshRangeLimit )
 
    
    enum class MeshRangeExtent : int
    {
      WholeMesh, 
      FixedCanvas, 
      UpdatedCanvas, 
    };
    enum class MeshRangeExtent : int {…};
    Q_ENUM( MeshRangeExtent )
 
    
    enum class PointCloudAccessType : int
    {
      Local, 
      Remote 
    };
    enum class PointCloudAccessType : int {…};
    Q_ENUM( PointCloudAccessType )
 
    
    enum class PointCloudZoomOutRenderBehavior : int
    {
      RenderExtents, 
      RenderOverview, 
      RenderOverviewAndExtents 
    };
    enum class PointCloudZoomOutRenderBehavior : int {…};
    Q_ENUM( PointCloudZoomOutRenderBehavior )
 
    
    enum class SegmentCalculationMethod : int
    {
      Standard = 0,   
      Adaptive,       
      AreaError,      
      ConstantDensity 
    };
    enum class SegmentCalculationMethod : int {…};
    Q_ENUM( SegmentCalculationMethod )
 
    
    static const double DEFAULT_SEARCH_RADIUS_MM;
 
    static const float DEFAULT_MAPTOPIXEL_THRESHOLD;
 
    static const QColor DEFAULT_HIGHLIGHT_COLOR;
 
    static const double DEFAULT_HIGHLIGHT_BUFFER_MM;
 
    static const double DEFAULT_HIGHLIGHT_MIN_WIDTH_MM;
 
    Q_DECL_DEPRECATED static const double SCALE_PRECISION;
 
    static const double DEFAULT_Z_COORDINATE;
 
    static const double DEFAULT_M_COORDINATE;
 
    static const double UI_SCALE_FACTOR;
 
    static const double DEFAULT_SNAP_TOLERANCE;
 
    static const Qgis::MapToolUnit DEFAULT_SNAP_UNITS;
 
    static const int USER_CRS_START_ID;
 
    static const double DEFAULT_POINT_SIZE;
 
    static const double DEFAULT_LINE_WIDTH;
 
    static const double DEFAULT_SEGMENT_EPSILON;
 
    SIP_SKIP static const int PREVIEW_JOB_DELAY_MS;
 
    SIP_SKIP static const int MAXIMUM_LAYER_PREVIEW_TIME_MS;
 
    static QString defaultProjectScales();
 
    static int geosVersionInt();
 
    static int geosVersionMajor();
 
    static int geosVersionMinor();
 
    static int geosVersionPatch();
 
    static QString geosVersion();
 
    static QString geoNone()
    {
      return QStringLiteral( "NONE" );
    }
    static QString geoNone() {…}
 
    static QString geographicCrsAuthId()
    {
      return QStringLiteral( "EPSG:4326" );
    }
    static QString geographicCrsAuthId() {…}
 
    Q_DECL_DEPRECATED static QString geoWkt()
    {
      return QStringLiteral(
               R"""(GEOGCRS["WGS 84",DATUM["World Geodetic System 1984",ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199433]],CS[ellipsoidal,2],AXIS["geodetic latitude (Lat)",north,ORDER[1],ANGLEUNIT["degree",0.0174532925199433]],AXIS["geodetic longitude (Lon)",east,ORDER[2],ANGLEUNIT["degree",0.0174532925199433]],USAGE[SCOPE["unknown"],AREA["World"],BBOX[-90,-180,90,180]],ID["EPSG",4326]] )"""
             );
    }
    Q_DECL_DEPRECATED static QString geoWkt() {…}
 
    Q_DECL_DEPRECATED static QString geoProj4()
    {
      return QStringLiteral( "+proj=longlat +datum=WGS84 +no_defs" );
    }
    Q_DECL_DEPRECATED static QString geoProj4() {…}
 
};
class CORE_EXPORT Qgis {…};
 
QHASH_FOR_CLASS_ENUM( Qgis::CaptureTechnique )
QHASH_FOR_CLASS_ENUM( Qgis::RasterAttributeTableFieldUsage )
 
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemGuiFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AuthConfigurationStorageCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelCommandFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelFormatCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BrowserItemCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::CoordinateTransformationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DatabaseProviderConnectionCapabilities2 )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DatabaseProviderTableImportCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FileOperationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GeometryValidityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GpsInformationComponents )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::HistoryProviderBackends )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelingFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelLinePlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelPolygonPlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LayerTreeFilterFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LegendJsonRenderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionTargets )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerProperties )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LoadStyleFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapSettingsFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MarkerLinePlacements )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::PlotToolFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProfileGeneratorFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectReadFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterRendererCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterTemporalCapabilityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RelationshipCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RenderContextFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ScriptLanguageCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SelectionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SettingsTreeNodeOptions )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SnappingTypes )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SqlLayerDefinitionCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::UriCleaningFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerQueryFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FeatureRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolLayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolLayerUserFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolPreviewFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolRenderHints )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TextComponents )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TextRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TiledSceneProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TiledSceneRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FieldConfigurationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LayerFilters )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TiledSceneRequestFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorDataProviderAttributeEditCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorFileWriterCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorLayerTypeFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorTileProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorTileProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GeosCreationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FeatureRequestFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingFeatureSourceDefinitionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ZonalStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::Statistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DateTimeStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::StringStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterBandStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterInterfaceCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingAlgorithmFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingAlgorithmDocumentationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingFeatureSourceFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingParameterTypeFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingParameterFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataItemProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorRenderingSimplificationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataProviderReadFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapCanvasFlags )
 
// hack to workaround warnings when casting void pointers
// retrieved from QLibrary::resolve to function pointers.
// It's assumed that this works on all systems supporting
// QLibrary
#define cast_to_fptr(f) f
 
 
// based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
template<class Object> class QgsSignalBlocker SIP_SKIP SIP_SKIP // clazy:exclude=rule-of-three
{
  public:
 
    explicit QgsSignalBlocker( Object *object )
      : mObject( object )
      , mPreviousState( object->blockSignals( true ) )
    {}
    explicit QgsSignalBlocker( Object *object ) {…}
 
    ~QgsSignalBlocker()
    {
      mObject->blockSignals( mPreviousState );
    }
    ~QgsSignalBlocker() {…}
 
    Object *operator->() { return mObject; }
 
  private:
 
    Object *mObject = nullptr;
    bool mPreviousState;
 
};
template<class Object> class QgsSignalBlocker SIP_SKIP SIP_SKIP // clazy:exclude=rule-of-three {…};
 
// based on Boojum's code from http://stackoverflow.com/questions/3556687/prevent-firing-signals-in-qt
template<class Object> inline QgsSignalBlocker<Object> whileBlocking( Object *object ) SIP_SKIP SIP_SKIP
{
  return QgsSignalBlocker<Object>( object );
}
template<class Object> inline QgsSignalBlocker<Object> whileBlocking( Object *object ) SIP_SKIP SIP_SKIP {…}
 
CORE_EXPORT uint qHash( const QVariant &variant );
 
inline QString qgsDoubleToString( double a, int precision = 17 )
{
  QString str;
  if ( precision )
  {
    if ( precision < 0 )
    {
      const double roundFactor = std::pow( 10, -precision );
      str = QString::number( static_cast< long long >( std::round( a / roundFactor ) * roundFactor ) );
    }
    else
    {
      str = QString::number( a, 'f', precision );
      if ( str.contains( QLatin1Char( '.' ) ) )
      {
        // remove ending 0s
        int idx = str.length() - 1;
        while ( str.at( idx ) == '0' && idx > 1 )
        {
          idx--;
        }
        if ( idx < str.length() - 1 )
          str.truncate( str.at( idx ) == '.' ? idx : idx + 1 );
      }
    }
  }
  else
  {
    str = QString::number( a, 'f', precision );
  }
  // avoid printing -0
  // see https://bugreports.qt.io/browse/QTBUG-71439
  if ( str == QLatin1String( "-0" ) )
  {
    return QLatin1String( "0" );
  }
  return str;
}
inline QString qgsDoubleToString( double a, int precision = 17 ) {…}
 
inline bool qgsNanCompatibleEquals( double a, double b )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  return a == b;
}
inline bool qgsNanCompatibleEquals( double a, double b ) {…}
 
#ifndef SIP_RUN
 
template<typename T>
inline bool qgsNumberNear( T a, T b, T epsilon = std::numeric_limits<T>::epsilon() * 4 )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  const T diff = a - b;
  return diff >= -epsilon && diff <= epsilon;
}
inline bool qgsNumberNear( T a, T b, T epsilon = std::numeric_limits<T>::epsilon() * 4 ) {…}
#endif
 
inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  return qgsNumberNear<double>( a, b, epsilon );
}
inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() ) {…}
 
inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON )
{
  return qgsNumberNear<float>( a, b, epsilon );
}
inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON ) {…}
 
inline bool qgsDoubleNearSig( double a, double b, int significantDigits = 10 )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  // The most simple would be to print numbers as %.xe and compare as strings
  // but that is probably too costly
  // Then the fastest would be to set some bits directly, but little/big endian
  // has to be considered (maybe TODO)
  // Is there a better way?
  int aexp, bexp;
  const double ar = std::frexp( a, &aexp );
  const double br = std::frexp( b, &bexp );
 
  return aexp == bexp &&
         std::round( ar * std::pow( 10.0, significantDigits ) ) == std::round( br * std::pow( 10.0, significantDigits ) );
}
inline bool qgsDoubleNearSig( double a, double b, int significantDigits = 10 ) {…}
 
inline double qgsRound( double number, int places )
{
  const double m = ( number < 0.0 ) ? -1.0 : 1.0;
  const double scaleFactor = std::pow( 10.0, places );
  return ( std::round( number * m * scaleFactor ) / scaleFactor ) * m;
}
inline double qgsRound( double number, int places ) {…}
 
#ifndef SIP_RUN
 
template<class Key, class Value>
QString qgsMapJoinKeys( const QMap<Key, Value> &map, const QString &separator )
{
  QString result;
  for ( auto it = map.constBegin(); it != map.constEnd(); it++ )
    result += QString( "%1%2" ).arg( it.key() ).arg( separator );
 
  result.chop( separator.size() );
  return result;
}
QString qgsMapJoinKeys( const QMap<Key, Value> &map, const QString &separator ) {…}
 
template<class Key, class Value>
QString qgsMapJoinValues( const QMap<Key, Value> &map, const QString &separator )
{
  QString result;
  for ( auto it = map.constBegin(); it != map.constEnd(); it++ )
    result += QString( "%1%2" ).arg( it.value() ).arg( separator );
 
  result.chop( separator.size() );
  return result;
}
QString qgsMapJoinValues( const QMap<Key, Value> &map, const QString &separator ) {…}
 
template<class T>
QString qgsSetJoin( const QSet<T> &set, const QString &separator )
{
  QString result;
  for ( auto it = set.constBegin(); it != set.constEnd(); it++ )
    result += QString( "%1%2" ).arg( *it ).arg( separator );
 
  result.chop( separator.size() );
  return result;
}
QString qgsSetJoin( const QSet<T> &set, const QString &separator ) {…}
 
 
namespace qgis
{
 
  template<typename To, typename From> inline To down_cast( From *f )
  {
    static_assert(
      ( std::is_base_of<From,
        typename std::remove_pointer<To>::type>::value ),
      "target type not derived from source type" );
    Q_ASSERT( f == nullptr || dynamic_cast<To>( f ) != nullptr );
    return static_cast<To>( f );
  }
 
  template<class T>
  QSet<T> listToSet( const QList<T> &list )
  {
    return QSet<T>( list.begin(), list.end() );
  }
 
  template<class T>
  QList<T> setToList( const QSet<T> &set )
  {
    return QList<T>( set.begin(), set.end() );
  }
}
 
#endif
 
template<class T> const QList<T> qgsEnumList() SIP_SKIP
{
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  QList<T> enumList;
  for ( int idx = 0; idx < metaEnum.keyCount(); ++idx )
  {
    enumList.append( static_cast<T>( metaEnum.value( idx ) ) );
  }
  return enumList;
}
template<class T> const QList<T> qgsEnumList() SIP_SKIP {…}
 
template<class T> const QMap<T, QString> qgsEnumMap() SIP_SKIP
{
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  QMap<T, QString> enumMap;
  for ( int idx = 0; idx < metaEnum.keyCount(); ++idx )
  {
    enumMap.insert( static_cast<T>( metaEnum.value( idx ) ), QString( metaEnum.key( idx ) ) );
  }
  return enumMap;
}
template<class T> const QMap<T, QString> qgsEnumMap() SIP_SKIP {…}
 
template<class T> QString qgsEnumValueToKey( const T &value, bool *returnOk = nullptr ) SIP_SKIP
{
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  const char *key = metaEnum.valueToKey( static_cast<int>( value ) );
  if ( returnOk )
  {
    *returnOk = key ? true : false;
  }
  return QString::fromUtf8( key );
}
template<class T> QString qgsEnumValueToKey( const T &value, bool *returnOk = nullptr ) SIP_SKIP {…}
 
template<class T> T qgsEnumKeyToValue( const QString &key, const T &defaultValue, bool tryValueAsKey = true,  bool *returnOk = nullptr ) SIP_SKIP
{
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  bool ok = false;
  T v = static_cast<T>( metaEnum.keyToValue( key.toUtf8().data(), &ok ) );
  if ( returnOk )
  {
    *returnOk = ok;
  }
  if ( ok )
  {
    return v;
  }
  else
  {
    // if conversion has failed, try with conversion from int value
    if ( tryValueAsKey )
    {
      bool canConvert = false;
      const int intValue = key.toInt( &canConvert );
      if ( canConvert && metaEnum.valueToKey( intValue ) )
      {
        if ( returnOk )
        {
          *returnOk = true;
        }
        return static_cast<T>( intValue );
      }
    }
  }
  return defaultValue;
}
template<class T> T qgsEnumKeyToValue( const QString &key, const T &defaultValue, bool tryValueAsKey = true,  bool *returnOk = nullptr ) SIP_SKIP {…}
 
template<class T> QString qgsFlagValueToKeys( const T &value, bool *returnOk = nullptr ) SIP_SKIP
{
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  int intValue = static_cast<int>( value );
  const QByteArray ba = metaEnum.valueToKeys( intValue );
  // check that the int value does correspond to a flag
  // see https://stackoverflow.com/a/68495949/1548052
  const int intValueCheck = metaEnum.keysToValue( ba );
  bool ok = intValue == intValueCheck;
  if ( returnOk )
    *returnOk = ok;
  return ok ? QString::fromUtf8( ba ) : QString();
}
template<class T> QString qgsFlagValueToKeys( const T &value, bool *returnOk = nullptr ) SIP_SKIP {…}
 
template<class T> T qgsFlagKeysToValue( const QString &keys, const T &defaultValue, bool tryValueAsKey = true,  bool *returnOk = nullptr ) SIP_SKIP
{
  if ( keys.isEmpty() )
  {
    if ( returnOk )
    {
      *returnOk = false;
    }
    return defaultValue;
  }
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  bool ok = false;
  T v = static_cast<T>( metaEnum.keysToValue( keys.toUtf8().constData(), &ok ) );
  if ( returnOk )
  {
    *returnOk = ok;
  }
  if ( ok )
  {
    return v;
  }
  else
  {
    // if conversion has failed, try with conversion from int value
    if ( tryValueAsKey )
    {
      bool canConvert = false;
      const int intValue = keys.toInt( &canConvert );
      if ( canConvert )
      {
        const QByteArray keys = metaEnum.valueToKeys( intValue );
        const int intValueCheck = metaEnum.keysToValue( keys );
        if ( intValue == intValueCheck )
        {
          if ( returnOk )
          {
            *returnOk = true;
          }
          return T( intValue );
        }
      }
    }
  }
  return defaultValue;
}
template<class T> T qgsFlagKeysToValue( const QString &keys, const T &defaultValue, bool tryValueAsKey = true,  bool *returnOk = nullptr ) SIP_SKIP {…}
 
 
CORE_EXPORT double qgsPermissiveToDouble( QString string, bool &ok );
 
CORE_EXPORT int qgsPermissiveToInt( QString string, bool &ok );
 
CORE_EXPORT qlonglong qgsPermissiveToLongLong( QString string, bool &ok );
 
CORE_EXPORT bool qgsVariantLessThan( const QVariant &lhs, const QVariant &rhs );
 
CORE_EXPORT bool qgsVariantEqual( const QVariant &lhs, const QVariant &rhs );
 
CORE_EXPORT bool qgsVariantGreaterThan( const QVariant &lhs, const QVariant &rhs );
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 
inline bool operator> ( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantGreaterThan( v1, v2 );
}
inline bool operator> ( const QVariant &v1, const QVariant &v2 ) {…}
 
inline bool operator< ( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantLessThan( v1, v2 );
}
inline bool operator< ( const QVariant &v1, const QVariant &v2 ) {…}
#endif
 
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 
template<> CORE_EXPORT bool qMapLessThanKey<QVariantList>( const QVariantList &key1, const QVariantList &key2 ) SIP_SKIP;
#endif
 
Q_DECL_DEPRECATED CORE_EXPORT QString qgsVsiPrefix( const QString &path ) SIP_DEPRECATED;
 
void CORE_EXPORT *qgsMalloc( size_t size ) SIP_SKIP;
 
void CORE_EXPORT qgsFree( void *ptr ) SIP_SKIP;
 
#ifndef SIP_RUN
 
class ScopedIntIncrementor
{
  public:
 
    ScopedIntIncrementor( int *variable )
      : mVariable( variable )
    {
      ( *mVariable )++;
    }
 
    ScopedIntIncrementor( const ScopedIntIncrementor &other ) = delete;
    ScopedIntIncrementor &operator=( const ScopedIntIncrementor &other ) = delete;
 
    void release()
    {
      if ( mVariable )
        ( *mVariable )--;
 
      mVariable = nullptr;
    }
 
    ~ScopedIntIncrementor()
    {
      release();
    }
 
  private:
    int *mVariable = nullptr;
};
 
#endif
 
Q_DECL_DEPRECATED const long GEOSRID = 4326;
 
Q_DECL_DEPRECATED const long GEOCRS_ID = 3452;
 
Q_DECL_DEPRECATED const long GEO_EPSG_CRS_ID = 4326;
 
typedef QMap<QString, QString> QgsStringMap SIP_SKIP;
 
typedef unsigned long long qgssize;
 
#ifndef SIP_RUN
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
 
#define Q_NOWARN_DEPRECATED_PUSH \
  _Pragma("GCC diagnostic push") \
  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"");
#define Q_NOWARN_DEPRECATED_POP \
  _Pragma("GCC diagnostic pop");
#define Q_NOWARN_UNREACHABLE_PUSH
#define Q_NOWARN_UNREACHABLE_POP
 
#elif defined(_MSC_VER)
 
#define Q_NOWARN_DEPRECATED_PUSH \
  __pragma(warning(push)) \
  __pragma(warning(disable:4996))
#define Q_NOWARN_DEPRECATED_POP \
  __pragma(warning(pop))
#define Q_NOWARN_UNREACHABLE_PUSH \
  __pragma(warning(push)) \
  __pragma(warning(disable:4702))
#define Q_NOWARN_UNREACHABLE_POP \
  __pragma(warning(pop))
 
#else
 
#define Q_NOWARN_DEPRECATED_PUSH
#define Q_NOWARN_DEPRECATED_POP
#define Q_NOWARN_UNREACHABLE_PUSH
#define Q_NOWARN_UNREACHABLE_POP
 
#endif
#endif
 
#ifndef QGISEXTERN
#ifdef Q_OS_WIN
#  define QGISEXTERN extern "C" __declspec( dllexport )
#else
#  if defined(__GNUC__) || defined(__clang__)
#    define QGISEXTERN extern "C" __attribute__ ((visibility ("default")))
#  else
#    define QGISEXTERN extern "C"
#  endif
#endif
#endif
#endif
 
// see https://infektor.net/posts/2017-01-19-using-cpp17-attributes-today.html#using-the-nodiscard-attribute
#if __cplusplus >= 201703L
#define NODISCARD [[nodiscard]]
#elif defined(__clang__)
#define NODISCARD [[nodiscard]]
#elif defined(_MSC_VER)
#define NODISCARD // no support
#elif defined(__has_cpp_attribute)
#if __has_cpp_attribute(nodiscard)
#define NODISCARD [[nodiscard]]
#elif __has_cpp_attribute(gnu::warn_unused_result)
#define NODISCARD [[gnu::warn_unused_result]]
#else
#define NODISCARD Q_REQUIRED_RESULT
#endif
#else
#define NODISCARD Q_REQUIRED_RESULT
#endif
 
#if __cplusplus >= 201703L
#define MAYBE_UNUSED [[maybe_unused]]
#elif defined(__clang__)
#define MAYBE_UNUSED [[maybe_unused]]
#elif defined(_MSC_VER)
#define MAYBE_UNUSED // no support
#elif defined(__has_cpp_attribute)
#if __has_cpp_attribute(gnu::unused)
#define MAYBE_UNUSED [[gnu::unused]]
#else
#define MAYBE_UNUSED
#endif
#else
#define MAYBE_UNUSED
#endif
 
#ifndef FINAL
#define FINAL final
#endif
 
#ifndef SIP_RUN
#ifdef _MSC_VER
#define BUILTIN_UNREACHABLE \
  __assume(false);
#elif defined(__GNUC__) && !defined(__clang__)
// Workaround a GCC bug where a -Wreturn-type warning is emitted in constructs
// like:
// switch( mVariableThatCanOnlyBeXorY )
// {
//    case X:
//        return "foo";
//    case Y:
//        return "foo";
// }
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87951
#define BUILTIN_UNREACHABLE \
  __builtin_unreachable();
#else
#define BUILTIN_UNREACHABLE
#endif
#endif // SIP_RUN