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 <cfloat>
#include <cmath>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QMetaEnum>
#include <QString>
#include <QTimeZone>
 
using namespace Qt::StringLiterals;
 
#ifdef SIP_RUN
// clang-format off
% ModuleHeaderCode
#include <qgis.h>
% End
 
% ModuleCode
int QgisEvent = QEvent::User + 1;
% End
// clang-format on
#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 size_t qHash( const T &t, size_t seed )                                      \
  {                                                                                   \
    return ::qHash( static_cast<typename std::underlying_type<T>::type>( t ), seed ); \
  }
#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, 
 
    };
    Q_ENUM( AuthConfigurationStorageCapability )
 
    
    Q_DECLARE_FLAGS( AuthConfigurationStorageCapabilities, AuthConfigurationStorageCapability )
    Q_FLAG( AuthConfigurationStorageCapabilities )

    enum MessageLevel
    {
      Info = 0,     
      Warning = 1,  
      Critical = 2, 
      Success = 3,  
      NoLevel = 4,  
    };
    Q_ENUM( MessageLevel )
 
    
    enum class StringFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMessageOutput, MessageType ) : int
    {
      PlainText SIP_MONKEYPATCH_COMPAT_NAME( MessageText ), 
      Html SIP_MONKEYPATCH_COMPAT_NAME( MessageHtml ),      
    };
    Q_ENUM( StringFormat )
 
    
    enum class NetworkRequestFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DisableMessageLogging = 1 << 0, 
    };
    Q_ENUM( NetworkRequestFlag )
 
    
    Q_DECLARE_FLAGS( NetworkRequestFlags, NetworkRequestFlag )
    Q_FLAG( NetworkRequestFlags )

    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,                                                
    };
    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 
    };
    Q_DECLARE_FLAGS( LayerFilters, LayerFilter )
    Q_FLAG( LayerFilters )
 
    
    enum class LoadStyleFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IgnoreMissingStyleErrors
      = 1 << 0, 
    };
    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,                    
      NurbsCurve = 21,             
      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,                 
      NurbsCurveZ = 1021,          
      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,                 
      NurbsCurveM = 2021,          
      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,           
      NurbsCurveZM = 3021,         
      Point25D = 0x80000001,       
      LineString25D,               
      Polygon25D,                  
      MultiPoint25D,               
      MultiLineString25D,          
      MultiPolygon25D              
    };
    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 ),       
    };
    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 
    };
    Q_ENUM( DataType )
 
    
    enum class CaptureTechnique : int
    {
      StraightSegments, 
      CircularString,   
      Streaming,        
      Shape,            
      PolyBezier,       
      NurbsCurve,       
    };
    Q_ENUM( CaptureTechnique )
 
 
    
    enum class VectorLayerTypeFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SqlQuery = 1 << 0 
    };
    Q_ENUM( VectorLayerTypeFlag )
    Q_DECLARE_FLAGS( VectorLayerTypeFlags, VectorLayerTypeFlag )
    Q_FLAG( VectorLayerTypeFlags )

    enum class EmbeddedScriptMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, PythonMacroMode ) : int
    {
      Never = 0,             
      Ask = 1,               
      SessionOnly = 2,       
      Always = 3,            
      NotForThisSession = 4, 
      NeverAsk = 5,          
    };
    Q_ENUM( EmbeddedScriptMode )
 
    
    enum class EmbeddedScriptType : int
    {
      Macro = 0,              
      ExpressionFunction = 1, 
      Action = 2,             
      FormInitCode = 3,       
    };
    Q_ENUM( EmbeddedScriptType )
 
    
    enum class ProjectTrustStatus : int
    {
      Undetermined = 0, 
      Trusted = 1,      
      Untrusted = 2,    
    };
    Q_ENUM( ProjectTrustStatus )
 
    
    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, 
    };
    Q_ENUM( DataProviderReadFlag )
 
    
    Q_DECLARE_FLAGS( DataProviderReadFlags, DataProviderReadFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataProvider, ReadFlags )
    Q_FLAG( DataProviderReadFlags )
 
    // TODO QGIS 5 -- 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, 
      CacheData = 1 << 28, 
      ReadFieldDomains = 1 << 29, 
      EditingCapabilities = AddFeatures | DeleteFeatures | ChangeAttributeValues | ChangeGeometries | AddAttributes | DeleteAttributes | RenameAttributes, 
    };
    Q_ENUM( VectorProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorProviderCapabilities, VectorProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsVectorDataProvider, Capabilities )
    Q_FLAG( VectorProviderCapabilities )

   enum class CreateLayerActionOnExisting : int
   {
     Abort, 
     CreateOrOverwriteFile, 
     CreateOrOverwriteLayer, 
   };
    Q_ENUM( CreateLayerActionOnExisting )
 
    
    enum class FeatureCountState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, FeatureCountState ) : int
    {
      Uncounted = -2,    
      UnknownCount = -1, 
    };
    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,       
    };
    Q_ENUM( SpatialIndexPresence )
 
    
    enum class FeatureAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsFeatureSource, FeatureAvailability ) : int
    {
      NoFeaturesAvailable = 0, 
      FeaturesAvailable,       
      FeaturesMaybeAvailable   
    };
    Q_ENUM( FeatureAvailability )
 
    
    enum class VectorDataProviderAttributeEditCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      EditAlias = 1 << 0,   
      EditComment = 1 << 1, 
    };
 
    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  
    };
    Q_ENUM( SymbolType )
 
    
    enum class ScaleMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, ScaleMethod ) : int
    {
      ScaleArea,    
      ScaleDiameter 
    };
    Q_ENUM( ScaleMethod )
 
    
    enum class SettingsType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSettingsEntryBase, SettingsType ) : int
    {
      Custom,     
      Variant,    
      String,     
      StringList, 
      VariantMap, 
      Bool,       
      Integer,    
      Double,     
      EnumFlag,   
      Color       
    };
    Q_ENUM( SettingsType )
 
    
    enum class SettingsTreeNodeType
    {
      Root,      
      Standard,  
      NamedList, 
    };
    Q_ENUM( SettingsTreeNodeType )
 
    
    enum class SettingsTreeNodeOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NamedListSelectedItemSetting = 1 << 0, 
    };
 
    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 ), 
    };
    Q_ENUM( PropertyType )
 
    
    enum class SldExportOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoOptions = 0, 
      Svg = 1 << 0,  
      Png = 1 << 1,  
    };
    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,   
    };
    Q_ENUM( SldExportVendorExtension )
 
 
    
    enum class SettingsOption : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SaveFormerValue = 1 << 1,   
      SaveEnumFlagAsInt = 1 << 2, 
    };
    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, 
    };
    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,       
    };
    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, 
    };
    Q_ENUM( SymbolRenderHint )
    Q_DECLARE_FLAGS( SymbolRenderHints, SymbolRenderHint ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, RenderHints )
    Q_FLAG( SymbolRenderHints )

    enum class SymbolConverterCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ReadSymbol = 1 << 0, 
      WriteSymbol = 1 << 1, 
    };
 
    Q_ENUM( SymbolConverterCapability )
 
    
    Q_DECLARE_FLAGS( SymbolConverterCapabilities, SymbolConverterCapability )
    Q_FLAG( SymbolConverterCapabilities )

    enum class SymbolRotationMode : int
    {
      RespectMapRotation, 
      IgnoreMapRotation,  
    };
    Q_ENUM( SymbolRotationMode )
 
 
    
    enum class HorizontalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, HorizontalAnchorPoint ) : int
    {
      Left,                                          
      Center SIP_MONKEYPATCH_COMPAT_NAME( HCenter ), 
      Right,                                         
    };
    Q_ENUM( HorizontalAnchorPoint )
 
    
    enum class VerticalAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMarkerSymbolLayer, VerticalAnchorPoint ) : int
    {
      Top,                                           
      Center SIP_MONKEYPATCH_COMPAT_NAME( VCenter ), 
      Bottom,                                        
      Baseline, 
    };
    Q_ENUM( VerticalAnchorPoint )
 
    
    enum class FeatureRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AffectsLabeling = 1 << 0, 
    };
    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,               
    };
    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, 
    };
    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, 
    };
    Q_ENUM( SymbolLayerFlag )
    Q_DECLARE_FLAGS( SymbolLayerFlags, SymbolLayerFlag )
    Q_FLAG( SymbolLayerFlags )

    enum class SymbolLayerUserFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DisableSelectionRecoloring = 1 << 0, 
    };
    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,      
    };
    Q_ENUM( BrowserItemType )
 
    
    enum class BrowserItemState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsDataItem, State ) : int
    {
      NotPopulated, 
      Populating,   
      Populated,    
    };
    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,                           
    };
    Q_ENUM( BrowserItemCapability )
    Q_DECLARE_FLAGS( BrowserItemCapabilities, BrowserItemCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataItem, Capabilities )
    Q_FLAG( BrowserItemCapabilities )

    enum class BrowserItemFilterFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      HideWhenNotFilteringByLayerType = 1 << 0, 
    };
    Q_ENUM( BrowserItemFilterFlag )
 
    
    Q_DECLARE_FLAGS( BrowserItemFilterFlags, BrowserItemFilterFlag )
    Q_FLAG( BrowserItemFilterFlags )

    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,           
    };
    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, 
    };
    Q_ENUM( BrowserLayerType )
 
    
    enum class BrowserDirectoryMonitoring : int
    {
      Default,       
      NeverMonitor,  
      AlwaysMonitor, 
    };
    Q_ENUM( BrowserDirectoryMonitoring )
 
    
    enum class HttpMethod : int
    {
      Get = 0,  
      Post = 1, 
      Head,     
      Put,      
      Delete,   
    };
    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 ),                                  
    };
    Q_ENUM( VectorExportResult )
 
    
    enum class VectorFileWriterCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FieldAliases = 1 << 0,  
      FieldComments = 1 << 2, 
    };
    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  
    };
    Q_ENUM( SqlLayerDefinitionCapability )
    Q_DECLARE_FLAGS( SqlLayerDefinitionCapabilities, SqlLayerDefinitionCapability )
    Q_FLAG( SqlLayerDefinitionCapabilities )

    enum class SqlKeywordCategory : int
    {
      Keyword,    
      Constant,   
      Function,   
      Geospatial, 
      Operator,   
      Math,       
      Aggregate,  
      String,     
      Identifier  
    };
    Q_ENUM( SqlKeywordCategory )
 
    
    enum class DriveType : int
    {
      Unknown,   
      Invalid,   
      Removable, 
      Fixed,     
      Remote,    
      CdRom,     
      RamDisk,   
      Cloud,     
    };
    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 ), 
    };
    Q_ENUM( ActionStart )
 
    
    enum class UnplacedLabelVisibility : int
    {
      FollowEngineSetting, 
      NeverShow,           
    };
    Q_ENUM( UnplacedLabelVisibility )
 
    
    enum class LabelOverlapHandling : int
    {
      PreventOverlap,         
      AllowOverlapIfRequired, 
      AllowOverlapAtNoCost,   
    };
    Q_ENUM( LabelOverlapHandling )
 
    
    enum class LabelWhitespaceCollisionHandling : int
    {
      TreatWhitespaceAsCollision, 
      IgnoreWhitespaceCollisions, 
    };
    Q_ENUM( LabelWhitespaceCollisionHandling )
 
    
    enum class LabelPrioritization : int
    {
      PreferCloser,           
      PreferPositionOrdering, 
    };
    Q_ENUM( LabelPrioritization )
 
    
    enum class LabelPlacement SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, Placement ) : int
    {
      AroundPoint, 
      OverPoint,   
      Line,        
      Curved,      
      Horizontal,  
      Free,        
      OrderedPositionsAroundPoint, 
      PerimeterCurved, 
      OutsidePolygons, 
    };
    Q_ENUM( LabelPlacement )
 
    
    enum class CurvedLabelMode : int
    {
      Default,                   
      PlaceCharactersAtVertices, 
      StretchCharacterSpacingToFitLine, 
      StretchWordSpacingToFitLine,      
    };
    Q_ENUM( CurvedLabelMode )
 
    
    enum class LabelPredefinedPointPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, PredefinedPointPosition ) : int
    {
      TopLeft,             
      TopSlightlyLeft,     
      TopMiddle,           
      TopSlightlyRight,    
      TopRight,            
      MiddleLeft,          
      MiddleRight,         
      BottomLeft,          
      BottomSlightlyLeft,  
      BottomMiddle,        
      BottomSlightlyRight, 
      BottomRight,         
      OverPoint,           
    };
    Q_ENUM( LabelPredefinedPointPosition )
 
    
    enum class MultiPartLabelingBehavior : int
    {
      LabelLargestPartOnly,          
      LabelEveryPartWithEntireLabel, 
      SplitLabelTextLinesOverParts,  
    };
    Q_ENUM( MultiPartLabelingBehavior )
 
    
    enum class LabelOffsetType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPalLayerSettings, OffsetType ) : int
    {
      FromPoint,        
      FromSymbolBounds, 
    };
    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 ), 
    };
    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, 
    };
    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, 
    };
    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 )                     
    };
    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 ),                 
    };
    Q_ENUM( LabelMultiLineAlignment )
 
    
    enum class TextAnchorPoint SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelLineSettings, AnchorTextPoint ) : int
    {
      StartOfText,     
      CenterOfText,    
      EndOfText,       
      FollowPlacement, 
    };
    Q_ENUM( TextAnchorPoint )
 
    
    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,                                                   
    };
    Q_ENUM( FileFilterType )
 
    
    enum class UriCleaningFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RemoveCredentials = 1 << 0, 
      RedactCredentials = 1 << 1, 
    };
    Q_ENUM( UriCleaningFlag )
 
    
    Q_DECLARE_FLAGS( UriCleaningFlags, UriCleaningFlag )
    Q_FLAG( UriCleaningFlags )

    enum class SourceHierarchyLevel : int
    {
      Connection, 
      Group,      
      Object,     
    };
    Q_ENUM( SourceHierarchyLevel )
 
    
    enum class SublayerQueryFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FastScan = 1 << 0, 
      ResolveGeometryType = 1 << 1,             
      CountFeatures = 1 << 2,                   
      IncludeSystemTables = 1 << 3,             
      OpenLayersToResolveDescriptions = 1 << 4, 
    };

    Q_DECLARE_FLAGS( SublayerQueryFlags, SublayerQueryFlag )
    Q_ENUM( SublayerQueryFlag )
    Q_FLAG( SublayerQueryFlags )
 
    
    enum class SublayerFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SystemTable = 1 << 0, 
    };

    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,                                              
    };
    Q_ENUM( ShaderInterpolationMethod )
 
    
    enum class ShaderClassificationMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsColorRampShader, ClassificationMode ) : int
    {
      Continuous = 1,    
      EqualInterval = 2, 
      Quantile = 3,      
    };
    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, 
    };
    Q_ENUM( RasterPipeInterfaceRole )
 
    
    enum class RasterResamplingStage SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterPipe, ResamplingStage ) : int
    {
      ResampleFilter, 
      Provider,       
    };
    Q_ENUM( RasterResamplingStage )
 
    
    enum class RasterResamplingMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ResamplingMethod ) : int
    {
      Nearest,     
      Bilinear,    
      Cubic,       
      CubicSpline, 
      Lanczos,     
      Average,     
      Mode,        
      Gauss        
    };
    Q_ENUM( RasterResamplingMethod )
 
    
    enum class RasterRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      InternalLayerOpacityHandling = 1 << 0, 
      UseNoDataForOutOfRangePixels
      = 1 << 1, 
    };

    Q_DECLARE_FLAGS( RasterRendererFlags, RasterRendererFlag )
 
    Q_ENUM( RasterRendererFlag )
    Q_FLAG( RasterRendererFlags )
 
    
    enum class RasterRendererCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      UsesMultipleBands = 1 << 0, 
    };
    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                                         
    };
    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,                                            
    };
    Q_ENUM( RasterRangeExtent )
 
    
    enum class RasterRangeAccuracy SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterMinMaxOrigin, StatAccuracy ) : int
    {
      Exact,     
      Estimated, 
    };
    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        
    };
    Q_ENUM( RasterAttributeTableFieldUsage )
 
    
    enum class RasterAttributeTableType : int
    {
      Thematic = 0,
      Athematic = 1
    };
    Q_ENUM( RasterAttributeTableType )
 
    
    enum class RasterExportType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterFileWriter, Mode ) : int
    {
      Raw = 0,                                               
      RenderedImage SIP_MONKEYPATCH_COMPAT_NAME( Image ) = 1 
    };
    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,                     
    };
    Q_ENUM( RasterFileWriterResult )
 
    
    enum class MeshEditingErrorType : int
    {
      NoError,               
      InvalidFace,           
      TooManyVerticesInFace, 
      FlatFace,              
      UniqueSharedVertex,    
      InvalidVertex,         
      ManifoldFace,          
    };
    Q_ENUM( MeshEditingErrorType )
 
    
    enum class FilePathType : int
    {
      Absolute, 
      Relative, 
    };
    Q_ENUM( FilePathType )
 
    
    enum class SublayerPromptMode : int
    {
      AlwaysAsk,               
      AskExcludingRasterBands, 
      NeverAskSkip,            
      NeverAskLoadAll,         
    };
    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 ) 
    };
    Q_ENUM( FieldOrigin )
 
    
    enum class FieldConfigurationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoFlag = 0,             
      NotSearchable = 1 << 1, 
      HideFromWms = 1 << 2,   
      HideFromWfs = 1 << 3,   
    };
    Q_ENUM( FieldConfigurationFlag )
 
    
    Q_DECLARE_FLAGS( FieldConfigurationFlags, FieldConfigurationFlag )
    Q_FLAG( FieldConfigurationFlags )

    enum class FieldMetadataProperty : int
    {
      GeometryCrs = 0x1000,      
      GeometryWkbType = 0x1001,  
      CustomProperty = 0x100000, 
    };
    Q_ENUM( FieldMetadataProperty )
 
    
    enum class SelectionRenderingMode : int
    {
      Default,      
      CustomColor,  
      CustomSymbol, 
    };
    Q_ENUM( SelectionRenderingMode )
 
    
    enum class SelectBehavior SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorLayer, SelectBehavior ) : int
    {
      SetSelection,        
      AddToSelection,      
      IntersectSelection,  
      RemoveFromSelection, 
    };
    Q_ENUM( SelectBehavior )
 
    
    enum class SelectGeometryRelationship : int
    {
      Intersect, 
      Within,    
    };
    Q_ENUM( SelectGeometryRelationship )
 
    
    enum class SelectionFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SingleFeatureSelection = 1 << 0, 
      ToggleSelection = 1 << 1, 
    };

    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,       
    };
    Q_ENUM( VectorEditResult )
 
    
    enum class VertexMarkerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbolLayerUtils, VertexMarkerType ) : int
    {
      SemiTransparentCircle, 
      Cross,                 
      NoMarker,              
    };
    Q_ENUM( VertexMarkerType )
 
    
    enum class ContentStatus : int
    {
      NotStarted, 
      Running,    
      Finished,   
      Failed,     
      Canceled,   
    };
    Q_ENUM( ContentStatus )
 
    
    enum class GpsConnectionType : int
    {
      Automatic, 
      Internal,  
      Serial,    
      Gpsd,      
    };
    Q_ENUM( GpsConnectionType )
 
    
    enum class DeviceConnectionStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, GpsConnectionStatus ) : int
    {
      Disconnected, 
      Connecting,   
      Connected,    
    };
    Q_ENUM( DeviceConnectionStatus )
 
    
    enum class GpsFixStatus SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGpsInformation, FixStatus ) : int
    {
      NoData, 
      NoFix,  
      Fix2D,  
      Fix3D   
    };
    Q_ENUM( GpsFixStatus );
 

    enum class GnssConstellation
    {
      Unknown, 
      Gps,     
      Glonass, 
      Galileo, 
      BeiDou,  
      Qzss,    
      Navic,   
      Sbas,    
    };
    Q_ENUM( GnssConstellation );

    enum class GpsQualityIndicator
    {
      Unknown = -1, 
      Invalid,      
      GPS,          
      DGPS,         
      PPS,          
      RTK,          
      FloatRTK,     
      Estimated,    
      Manual,       
      Simulation,   
    };
    Q_ENUM( GpsQualityIndicator )
 
    
    enum class GpsNavigationStatus : int
    {
      NotValid, 
      Safe,     
      Caution,  
      Unsafe,   
    };
    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,           
    };

    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,    
    };

    Q_DECLARE_FLAGS( BabelFormatCapabilities, BabelFormatCapability )
    Q_ENUM( BabelFormatCapability )
    Q_FLAG( BabelFormatCapabilities )
 
    
    enum class BabelCommandFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      QuoteFilePaths = 1 << 0, 
    };

    Q_DECLARE_FLAGS( BabelCommandFlags, BabelCommandFlag )
    Q_ENUM( BabelCommandFlag )
    Q_FLAG( BabelCommandFlags )
 
    
    enum class GpsFeatureType : int
    {
      Waypoint, 
      Route,    
      Track,    
    };
    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, 
    };
    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, 
    };

    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 ), 
      Sfcgal, 
    };
    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 ),   
    };
    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 ),   
    };
    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 ),     
    };
    Q_ENUM( JoinStyle )
 
    
    enum class JoinStyle3D : int
    {
      Round = 1,           
      Flat,                
      CylindersAndSpheres, 
    };
    Q_ENUM( JoinStyle3D )
 
    
    enum class GeometryBackend : int
    {
      QGIS = 1, 
      GEOS,     
    };
    Q_ENUM( GeometryBackend )
 
    
    enum class GeosCreationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RejectOnInvalidSubGeometry = 1 << 0, 
      SkipEmptyInteriorRings = 1 << 1,     
    };
    Q_ENUM( GeosCreationFlag )
 
    
    Q_DECLARE_FLAGS( GeosCreationFlags, GeosCreationFlag )
    Q_FLAG( GeosCreationFlags )

    enum class CoverageValidityResult : int
    {
      Invalid = 0, 
      Valid = 1,   
      Error = 2,   
    };
    Q_ENUM( CoverageValidityResult )
 
    
    enum class MakeValidMethod : int
    {
      Linework = 0,  
      Structure = 1, 
    };
    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, 
    };
    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 ) 
    };
    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, 
    };
    Q_ENUM( InvalidGeometryCheck )
 
    
    enum class SpatialFilterType : int
    {
      NoFilter,       
      BoundingBox,    
      DistanceWithin, 
    };
    Q_ENUM( SpatialFilterType )
 
    
    enum class FileOperationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IncludeMetadataFile = 1 << 0, 
      IncludeStyleFile = 1 << 1,    
    };

    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, 
      Is3DBasemapLayer = 1 << 2, 
    };

    Q_DECLARE_FLAGS( MapLayerProperties, MapLayerProperty )
    Q_ENUM( MapLayerProperty )
    Q_FLAG( MapLayerProperties )
 
    
    enum class AutoRefreshMode : int
    {
      Disabled = 0,   
      ReloadData = 1, 
      RedrawOnly = 2, 
    };
    Q_ENUM( AutoRefreshMode )
 
    
    enum class DataProviderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      IsBasemapSource = 1 << 1,   
      FastExtent2D = 1 << 2,      
      FastExtent3D = 1 << 3,      
      Is3DBasemapSource = 1 << 4, 
    };

    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, 
    };
    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,      
    };
    Q_ENUM( CrsAxisDirection )
 
    
    enum class CoordinateOrder : int
    {
      Default, 
      XY,      
      YX,      
    };
    Q_ENUM( CoordinateOrder )
 
    
    enum class CrsIdentifierType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCoordinateReferenceSystem, IdentifierType ) : int
    {
      ShortString,  
      MediumString, 
      FullString,   
    };
    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, 
    };
    Q_ENUM( CrsWktVariant )
 
    
    enum class UnknownLayerCrsBehavior : int
    {
      NoAction = 0,         
      PromptUserForCrs = 1, 
      UseProjectCrs = 2,    
      UseDefaultCrs = 3,    
    };
    Q_ENUM( UnknownLayerCrsBehavior )
 
    
    enum class Axis : int
    {
      X, 
      Y, 
      Z  
    };
    Q_ENUM( Axis )
 
    
    enum class AnnotationItemFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ScaleDependentBoundingBox = 1 << 0, 
      SupportsReferenceScale = 1 << 1,    
      SupportsCallouts = 1 << 2,          
    };

    Q_DECLARE_FLAGS( AnnotationItemFlags, AnnotationItemFlag )
    Q_ENUM( AnnotationItemFlag )
    Q_FLAG( AnnotationItemFlags )
 
    
    enum class AnnotationPlacementMode : int
    {
      SpatialBounds = 0,  
      FixedSize,          
      RelativeToMapFrame, 
    };
    Q_ENUM( AnnotationPlacementMode )
 
    
    enum class AnnotationItemGuiFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FlagNoCreationTools = 1 << 0, 
    };

    Q_DECLARE_FLAGS( AnnotationItemGuiFlags, AnnotationItemGuiFlag )
    Q_ENUM( AnnotationItemGuiFlag )
    Q_FLAG( AnnotationItemGuiFlags )
 
    
    enum class AnnotationItemNodeType : int
    {
      VertexHandle,  
      CalloutHandle, 
    };
    Q_ENUM( AnnotationItemNodeType )
 
    
    enum class AnnotationItemEditOperationResult : int
    {
      Success,     
      Invalid,     
      ItemCleared, 
    };
    Q_ENUM( AnnotationItemEditOperationResult )
 
    
    enum class TemporalNavigationMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, NavigationMode ) : int
    {
      Disabled SIP_MONKEYPATCH_COMPAT_NAME( NavigationOff ), 
      Animated,                                              
      FixedRange,                                            
      Movie,                                                 
    };
    Q_ENUM( TemporalNavigationMode )
 
    
    enum class AnimationState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTemporalNavigationObject, AnimationState ) : int
    {
      Forward, 
      Reverse, 
      Idle,    
    };
    Q_ENUM( AnimationState )
 
    
    enum class PlaybackOperation : int
    {
      SkipToStart,   
      PreviousFrame, 
      PlayReverse,   
      Pause,         
      PlayForward,   
      NextFrame,     
      SkipToEnd,     
    };
    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
      ), 
    };
    Q_ENUM( VectorTemporalMode )
 
    
    enum class VectorTemporalLimitMode : int
    {
      IncludeBeginExcludeEnd = 0, 
      IncludeBeginIncludeEnd,     
    };
    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 ), 
    };
    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,            
    };
    Q_ENUM( RasterTemporalMode )
 
    
    enum class TemporalIntervalMatchMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProviderTemporalCapabilities, IntervalHandlingMethod ) : int
    {
      MatchUsingWholeRange,           
      MatchExactUsingStartOfRange,    
      MatchExactUsingEndOfRange,      
      FindClosestMatchToStartOfRange, 
      FindClosestMatchToEndOfRange    
    };
    Q_ENUM( TemporalIntervalMatchMethod )
 
    
    enum class RasterTemporalCapabilityFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RequestedTimesMustExactlyMatchAllAvailableTemporalRanges
      = 1 << 0, 
    };
    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 )  
    };
    Q_ENUM( TransformDirection )
 
    
    enum class CoordinateTransformationFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      BallparkTransformsAreAppropriate
      = 1 << 0, 
      IgnoreImpossibleTransformations
      = 1 << 1, 
    };
    Q_ENUM( CoordinateTransformationFlag )
 
    
    Q_DECLARE_FLAGS( CoordinateTransformationFlags, CoordinateTransformationFlag )
    Q_FLAG( CoordinateTransformationFlags )

    enum class RasterizedRenderingPolicy : int
    {
      Default,      
      PreferVector, 
      ForceVector, 
    };
    Q_ENUM( RasterizedRenderingPolicy )
 
    
    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, 
      DrawLabelSelection = 0x80000 
    };

    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, 
      RenderLayerTree = 0x400000,        
      DrawLabelSelection = 0x800000     
    };

    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, 
    };
    Q_ENUM( MapLayerRendererFlag )
 
    
    Q_DECLARE_FLAGS( MapLayerRendererFlags, MapLayerRendererFlag )
    Q_FLAG( MapLayerRendererFlags )

    enum class PaintEffectFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RequiresRasterization = 1 << 0, 
    };
    Q_ENUM( PaintEffectFlag )
 
    
    Q_DECLARE_FLAGS( PaintEffectFlags, PaintEffectFlag )
    Q_FLAG( PaintEffectFlags )
 
    // 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, 
    };
    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 5.0: remove
      RenderOutlineLabels = 1 << 3,   
      DrawLabelRectOnly = 1 << 4,     
      DrawCandidates = 1 << 5,        
      DrawUnplacedLabels = 1 << 6,    
      CollectUnplacedLabels = 1 << 7, 
      DrawLabelMetrics = 1 << 8,      
      IgnoreObstacles = 1 << 9,       
      SingleCandidateOnly = 1 << 10,  
      IgnoreOverlaps = 1 << 11,       
      DisableSearchTree = 1 << 12,    
    };
    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 ), 
    };
    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 ), 
    };
    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, 
    };
    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,     
    };
    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 ), 
    };
    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 ),          
    };
    Q_ENUM( TextVerticalAlignment )
 
    
    enum class TextCharacterVerticalAlignment : int
    {
      Normal,      
      SuperScript, 
      SubScript,   
    };
    Q_ENUM( TextCharacterVerticalAlignment )
 
    
    enum class CurvedTextFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsTextRendererUtils, CurvedTextFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      TruncateStringWhenLineIsTooShort = 1 << 0, 
      UseBaselinePlacement = 1 << 1,             
      UprightCharactersOnly = 1 << 2,            
      ExtendLineToFitText = 1 << 3,              
    };
    Q_ENUM( CurvedTextFlag )
 
    
    Q_DECLARE_FLAGS( CurvedTextFlags, CurvedTextFlag )SIP_MONKEYPATCH_FLAGS_UNNEST( QgsTextRendererUtils, CurvedTextFlags )

    enum class VectorSimplificationAlgorithm SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorSimplifyMethod, SimplifyAlgorithm ) : int
      {
      Distance = 0, 
      SnapToGrid = 1, 
      Visvalingam = 2, 
      SnappedToGridGlobal = 3, 
    };
    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,         
    };
    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, 
    };
    Q_ENUM( RenderSubcomponentProperty )
 
    
    enum class SelectiveMaskSourceType : int
    {
      SymbolLayer, 
      Label,       
    };
    Q_ENUM( SelectiveMaskSourceType )
 
    
    enum class VertexType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVertexId, VertexType ) : int
    {
      Segment SIP_MONKEYPATCH_COMPAT_NAME( SegmentVertex ) = 1,           
      Curve SIP_MONKEYPATCH_COMPAT_NAME( CurveVertex ) = 2,               
      ControlPoint SIP_MONKEYPATCH_COMPAT_NAME( ControlPointVertex ) = 3, 
    };
    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,       
    };
    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, 
    };
    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,              
    };
    Q_ENUM( LinearReferencingPlacement )
 
    
    enum class LinearReferencingLabelSource : int
    {
      CartesianDistance2D, 
      Z,                   
      M,                   
    };
    Q_ENUM( LinearReferencingLabelSource )
 
    
    enum class GradientColorSource SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientColorType ) : int
    {
      SimpleTwoColor, 
      ColorRamp,      
    };
    Q_ENUM( GradientColorSource )
 
    
    enum class GradientType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientType ) : int
    {
      Linear,  
      Radial,  
      Conical, 
    };
    Q_ENUM( GradientType )
 
    
    enum class SymbolCoordinateReference SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientCoordinateMode ) : int
    {
      Feature,  
      Viewport, 
    };
    Q_ENUM( SymbolCoordinateReference )
 
    
    enum class GradientSpread SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGradientFillSymbolLayer, GradientSpread ) : int
    {
      Pad,     
      Reflect, 
      Repeat,  
    };
    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 ), 
    };
    Q_ENUM( PointCountMethod )
 
    
    enum class MarkerClipMode : int
    {
      NoClipping,       
      Shape,            
      CentroidWithin,   
      CompletelyWithin, 
    };
    Q_ENUM( MarkerClipMode )
 
    
    enum class LineClipMode : int
    {
      ClipPainterOnly,    
      ClipToIntersection, 
      NoClipping,         
    };
    Q_ENUM( LineClipMode )
 
    
    enum class DashPatternLineEndingRule : int
    {
      NoRule,   
      FullDash, 
      HalfDash, 
      FullGap,  
      HalfGap,  
    };
    Q_ENUM( DashPatternLineEndingRule )
 
    
    enum class DashPatternSizeAdjustment : int
    {
      ScaleBothDashAndGap, 
      ScaleDashOnly,       
      ScaleGapOnly,        
    };
    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 ),   
    };
    Q_ENUM( GraduatedMethod )
 
    
    enum class PlotAxisSuffixPlacement
    {
      NoLabels,           
      EveryLabel,         
      FirstLabel,         
      LastLabel,          
      FirstAndLastLabels, 
    };
    Q_ENUM( PlotAxisSuffixPlacement )
 
 
    
    enum class PlotAxisType
    {
      Interval,    
      Categorical, 
    };
    Q_ENUM( PlotAxisType )
 
    
    enum class PieChartLabelType : int
    {
      NoLabels,   
      Categories, 
      Values,     
    };
    Q_ENUM( PieChartLabelType )
 
    
    enum class DpiMode
    {
      All = 7,       
      Off = 0,       
      QGIS = 1,      
      UMN = 2,       
      GeoServer = 4, 
    };
    Q_ENUM( DpiMode )
 
    
    enum class TilePixelRatio
    {
      Undefined = 0,   
      StandardDpi = 1, 
      HighDpi = 2,     
    };
    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,   
    };
    Q_ENUM( Capitalization )
 
    
    enum class TextRendererFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      WrapLines = 1 << 0, 
    };
    Q_ENUM( TextRendererFlag )
    Q_DECLARE_FLAGS( TextRendererFlags, TextRendererFlag )
    Q_FLAG( TextRendererFlags )

    enum class ScaleToTileZoomLevelMethod : int
    {
      MapBox, 
      Esri,   
    };
    Q_ENUM( ScaleToTileZoomLevelMethod );

    enum class AngularDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsCurve, Orientation ) : int
    {
      Clockwise,        
      CounterClockwise, 
      NoOrientation,    
    };
    Q_ENUM( AngularDirection )
 
    
    enum class RendererUsage : int
    {
      View,    
      Export,  
      Unknown, 
    };
    Q_ENUM( RendererUsage )
 
    
    enum class MapCanvasFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowMainAnnotationLayer = 1 << 0, 
    };
    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, 
    };
    Q_ENUM( ViewSyncModeFlag )
    Q_DECLARE_FLAGS( ViewSyncModeFlags, ViewSyncModeFlag )

    enum class MapRecenteringMode
    {
      Always,                   
      WhenOutsideVisibleExtent, 
      Never,                    
    };
    Q_ENUM( MapRecenteringMode )
 
    
    enum class HistoryProviderBackend : int SIP_ENUM_BASETYPE( IntFlag )
    {
      LocalProfile = 1 << 0, 
                             //      Project = 1 << 1, //!< QGIS Project  (not yet implemented)
    };
    Q_ENUM( HistoryProviderBackend )
    Q_DECLARE_FLAGS( HistoryProviderBackends, HistoryProviderBackend )
    Q_FLAG( HistoryProviderBackends )

    enum class QueryStorageBackend : int
    {
      LocalProfile,   
      CurrentProject, 
    };
    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, 
      TiledScene = 11                                                
    };
    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, 
    };
    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, 
    };
    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, 
      RespectsEllipsoid = 1 << 2, 
    };
    Q_ENUM( ProcessingAlgorithmDocumentationFlag )
 
    
    Q_DECLARE_FLAGS( ProcessingAlgorithmDocumentationFlags, ProcessingAlgorithmDocumentationFlag )
    Q_FLAG( ProcessingAlgorithmDocumentationFlags )

    enum class ProcessingPropertyAvailability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingAlgorithm, PropertyAvailability ) : int
    {
      NotAvailable, 
      Available,    
    };
    Q_ENUM( ProcessingPropertyAvailability )
 
    
    enum class ProcessingLogLevel SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingContext, LogLevel ) : int
    {
      DefaultLevel = 0, 
      Verbose,          
      ModelDebug,       
    };
    Q_ENUM( ProcessingLogLevel )
 
    
    enum class ProcessingMode
    {
      Standard, 
      Batch,    
      Modeler,  
    };
    Q_ENUM( ProcessingMode )
 
    
    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, 
    };
    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, 
    };
    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 
    };
    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, 
    };
    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, 
    };
    Q_ENUM( ProcessingFileParameterBehavior )
 
    
    enum class ProcessingNumberParameterType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterNumber, Type ) : int
    {
      Integer, 
      Double,  
    };
    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,  
    };
    Q_ENUM( ProcessingFieldParameterDataType )
 
    
    enum class ProcessingDateTimeParameterDataType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterDateTime, Type ) : int
    {
      DateTime, 
      Date,     
      Time,     
    };
    Q_ENUM( ProcessingDateTimeParameterDataType )
 
    
    enum class ProcessingModelChildParameterSource : int
    {
      ModelParameter, 
      ChildOutput,    
      StaticValue,    
      Expression,     
      ExpressionText, 
      ModelOutput,    
    };
    Q_ENUM( ProcessingModelChildParameterSource )
 
    
    enum class ProcessingModelChildAlgorithmExecutionStatus : int
    {
      NotExecuted, 
      Success,     
      Failed,      
    };
    Q_ENUM( ProcessingModelChildAlgorithmExecutionStatus )
 
    
    enum class ProcessingTinInputLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProcessingParameterTinInputLayers, Type ) : int
    {
      Vertices,       
      StructureLines, 
      BreakLines      
    };
    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 ), 
    };
    Q_ENUM( CrsDefinitionFormat )
 
    
    enum class FieldDomainSplitPolicy : int
    {
      DefaultValue,  
      Duplicate,     
      GeometryRatio, 
      UnsetField,    
    };
    Q_ENUM( FieldDomainSplitPolicy )
 
    
    enum class FieldDomainMergePolicy : int
    {
      DefaultValue,     
      Sum,              
      GeometryWeighted, 
      UnsetField,       
      LargestGeometry,  
      MinimumValue,     
      MaximumValue,     
      SetToNull,        
    };
    Q_ENUM( FieldDomainMergePolicy )
 
    
    enum class FieldDuplicatePolicy : int
    {
      DefaultValue, 
      Duplicate,    
      UnsetField,   
    };
    Q_ENUM( FieldDuplicatePolicy )
 
    
    enum class FieldDomainType : int
    {
      Coded, 
      Range, 
      Glob,  
    };
    Q_ENUM( FieldDomainType )
 
    
    enum class TransactionMode : int
    {
      Disabled = 0,        
      AutomaticGroups = 1, 
      BufferedGroups = 2, 
    };
    Q_ENUM( TransactionMode )
 
    
    enum class AltitudeClamping : int
    {
      Absolute, 
      Relative, 
      Terrain,  
    };
    Q_ENUM( AltitudeClamping )
 
    
    enum class AltitudeBinding : int
    {
      Vertex,   
      Centroid, 
    };
    Q_ENUM( AltitudeBinding )
 
    
    enum class RangeLimits : int
    {
      IncludeBoth = 0,          
      IncludeLowerExcludeUpper, 
      ExcludeLowerIncludeUpper, 
      ExcludeBoth,              
    };
    Q_ENUM( RangeLimits )
 
    
    enum class RasterElevationMode : int
    {
      FixedElevationRange = 0,        
      RepresentsElevationSurface = 1, 
      FixedRangePerBand = 2,          
      DynamicRangePerBand = 3,        
    };
    Q_ENUM( RasterElevationMode )
 
    
    enum class MeshElevationMode : int
    {
      FixedElevationRange = 0, 
      FromVertices = 1,        
      FixedRangePerGroup = 2,  
    };
    Q_ENUM( MeshElevationMode )
 
    
    enum class BetweenLineConstraint SIP_MONKEYPATCH_SCOPEENUM : int
    {
      NoConstraint,  
      Perpendicular, 
      Parallel       
    };
    Q_ENUM( BetweenLineConstraint )
 
    
    enum class LineExtensionSide : int
    {
      BeforeVertex, 
      AfterVertex,  
      NoVertex,     
    };
    Q_ENUM( LineExtensionSide )
 
 
    
    enum class CadConstraintType : int
    {
      Generic,     
      Angle,       
      Distance,    
      XCoordinate, 
      YCoordinate, 
      ZValue,      
      MValue,      
    };
    Q_ENUM( CadConstraintType )
 
    
    enum class CadMeasurementDisplayType : int
    {
      Hidden,      
      Cartesian,   
      Ellipsoidal, 
    };
    Q_ENUM( CadMeasurementDisplayType )
 
    
    enum class ProjectFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      EvaluateDefaultValuesOnProviderSide = 1 << 0, 
      TrustStoredLayerStatistics
      = 1 << 1, 
      RememberLayerEditStatusBetweenSessions = 1 << 2, 
      RememberAttributeTableWindowsBetweenSessions = 1 << 3, 
    };
    Q_ENUM( ProjectFlag )
    Q_DECLARE_FLAGS( ProjectFlags, ProjectFlag )
    Q_FLAG( ProjectFlags )

    enum class PlotToolFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowContextMenu = 1 << 0, 
    };
    Q_ENUM( PlotToolFlag )
    Q_DECLARE_FLAGS( PlotToolFlags, PlotToolFlag )
    Q_FLAG( PlotToolFlags )

    enum class Map3DDebugFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowTerrainBoundingBoxes = 1 << 0, 
      ShowTerrainTileInfo = 1 << 1,      
      ShowCameraViewCenter = 1 << 2,     
      ShowCameraRotationCenter = 1 << 3, 
      ShowLightSourceOrigins = 1 << 4,   
      ShowFPS = 1 << 5,                  
      ShowDebugPanel = 1 << 6,           
    };
    Q_ENUM( Map3DDebugFlag )
    Q_DECLARE_FLAGS( Map3DDebugFlags, Map3DDebugFlag )
    Q_FLAG( Map3DDebugFlags )

    enum class Map3DProjectionType : int
    {
      Orthographic = 0, 
      Perspective = 1,  
    };
    Q_ENUM( Map3DProjectionType )
 
    
    enum class Point3DShape : int
    {
      Cylinder,     
      Sphere,       
      Cone,         
      Cube,         
      Torus,        
      Plane,        
      ExtrudedText, 
      Model,        
      Billboard,    
    };
    Q_ENUM( Point3DShape )
 
    
    enum class MaterialRenderingTechnique : int
    {
      Triangles,                 
      Lines,                     
      InstancedPoints,           
      Points,                    
      TrianglesWithFixedTexture, 
      TrianglesFromModel,        
      TrianglesDataDefined,      
      Billboards,                
    };
    Q_ENUM( MaterialRenderingTechnique )
 
    
    enum class InstancedMaterialFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      DataDefinedScale = 1 << 0,    
      DataDefinedRotation = 1 << 1, 
    };
    Q_ENUM( InstancedMaterialFlag )
    Q_DECLARE_FLAGS( InstancedMaterialFlags, InstancedMaterialFlag )
    Q_FLAG( InstancedMaterialFlags )

    enum class BillboardScaleMode : int
    {
      ViewIndependent, 
      Perspective      
    };
    Q_ENUM( BillboardScaleMode )
 
    
    enum class TextureFilterQuality : int
    {
      Trilinear,      
      Anisotropic2x,  
      Anisotropic4x,  
      Anisotropic8x,  
      Anisotropic16x, 
    };
    Q_ENUM( TextureFilterQuality )
 
    
    enum class ShadowQuality : int
    {
      Low,      
      Medium,   
      High,     
      VeryHigh, 
      Extreme,  
    };
    Q_ENUM( ShadowQuality )
 
    
    enum class LightSourceType : int
    {
      Point,       
      Directional, 
      Sun,         
    };
    Q_ENUM( LightSourceType )
 
    
    enum class Map3DBackgroundType : int
    {
      NoBackground,            
      FixedGradientBackground, 
      DistinctTextureSkybox,   
    };
    Q_ENUM( Map3DBackgroundType )
 
    
    enum class SkyboxCubeMapping : int
    {
      NativeZUp,             
      OpenGLYUp,             
      GodotYUp,              
      UnrealEngineZUp,       
      LeftHandedYUpMirrored, 
    };
    Q_ENUM( SkyboxCubeMapping )
 
    
    enum class NavigationMode : int
    {
      TerrainBased,     
      Walk,             
      GlobeTerrainBased 
    };
    Q_ENUM( NavigationMode )
 
    
    enum class SceneMode : int
    {
      Local, 
      Globe  
    };
    Q_ENUM( SceneMode )
 
    
    enum class VerticalAxisInversion : int SIP_ENUM_BASETYPE( IntFlag )
    {
      WhenRotatingDragging = 1 << 0, 
      WhenRotatingCaptured = 1 << 1, 
      WhenPivoting = 1 << 2,         
 
      // Legacy aliases for old flying-only enum:
 
      Never = WhenRotatingDragging | WhenRotatingCaptured | WhenPivoting, 
      WhenDragging = WhenRotatingCaptured | WhenPivoting,                 
      Always = WhenPivoting,                                              
    };
    Q_ENUM( VerticalAxisInversion )
    Q_DECLARE_FLAGS( VerticalAxisInversionFlags, VerticalAxisInversion )
    Q_FLAG( VerticalAxisInversionFlags )

    enum class ToneMappingMethod : int
    {
      Clamp, 
      Aces, 
    };
    Q_ENUM( ToneMappingMethod )
 
    
    enum class Export3DSceneFormat : int
    {
      Obj,     
      StlAscii 
    };
    Q_ENUM( Export3DSceneFormat )
 
    
    enum class ProfileSurfaceSymbology : int
    {
      Line,      
      FillBelow, 
      FillAbove, 
    };
    Q_ENUM( ProfileSurfaceSymbology );

    enum class VectorProfileType : int
    {
      IndividualFeatures, 
      ContinuousSurface,  
    };
    Q_ENUM( VectorProfileType );

    enum class PointCloudProfileType : int
    {
      IndividualPoints,    
      TriangulatedSurface, 
    };
    Q_ENUM( PointCloudProfileType );

    enum class ProfileGeneratorFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RespectsMaximumErrorMapUnit = 1 << 0, 
      RespectsDistanceRange = 1 << 1,       
      RespectsElevationRange = 1 << 2,      
    };
    Q_ENUM( ProfileGeneratorFlag )
    Q_DECLARE_FLAGS( ProfileGeneratorFlags, ProfileGeneratorFlag )
    Q_FLAG( ProfileGeneratorFlags )

    enum class ProfileExportType : int
    {
      Features3D,               
      Profile2D,                
      DistanceVsElevationTable, 
    };
    Q_ENUM( ProfileExportType );

    enum class PointCloudSymbol SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, PointSymbol ) : int
    {
      Square, 
      Circle, 
    };
    Q_ENUM( PointCloudSymbol )
 
    
    enum class PointCloudDrawOrder SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsPointCloudRenderer, DrawOrder ) : int
    {
      Default,     
      BottomToTop, 
      TopToBottom, 
    };
    Q_ENUM( PointCloudDrawOrder )
 
    
    enum class AvoidIntersectionsMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, AvoidIntersectionsMode ) : int
    {
      AllowIntersections,             
      AvoidIntersectionsCurrentLayer, 
      AvoidIntersectionsLayers,       
    };
    Q_ENUM( AvoidIntersectionsMode )
 
    
    enum class ProjectFileFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsProject, FileFormat ) : int
    {
      Qgz, 
      Qgs, 
    };
    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,                                             
    };
    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, 
    };
    Q_ENUM( ProjectCapability )
 
    
    Q_DECLARE_FLAGS( ProjectCapabilities, ProjectCapability )
    Q_FLAG( ProjectCapabilities )

    enum class MapBoxGlStyleSourceType : int
    {
      Vector,    
      Raster,    
      RasterDem, 
      GeoJson,   
      Image,     
      Video,     
      Unknown,   
    };
    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,                                                     
      SceneServer,                                                 
    };
    Q_ENUM( ArcGisRestServiceType )
 
    
    enum class ArcGisRestServiceCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Map = 1 << 0,       
      Query = 1 << 1,     
      Update = 1 << 2,    
      Delete = 1 << 3,    
      Create = 1 << 4,    
      Image = 1 << 5,     
      TilesOnly = 1 << 6, 
    };
    Q_ENUM( ArcGisRestServiceCapability )
 
    
    Q_DECLARE_FLAGS( ArcGisRestServiceCapabilities, ArcGisRestServiceCapability )
    Q_FLAG( ArcGisRestServiceCapabilities )

    enum class RelationshipType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationType ) : int
    {
      Normal,    
      Generated, 
    };
    Q_ENUM( RelationshipType )
 
    
    enum class RelationshipStrength SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRelation, RelationStrength ) : int
    {
      Association, 
      Composition, 
    };
    Q_ENUM( RelationshipStrength )
 
    
    enum class RelationshipCardinality : int
    {
      OneToOne,   
      OneToMany,  
      ManyToOne,  
      ManyToMany, 
    };
    Q_ENUM( RelationshipCardinality )
 
    
    enum class RelationshipCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      MultipleFieldKeys = 1 << 0, 
      ForwardPathLabel = 1 << 1,  
      BackwardPathLabel = 1 << 2, 
    };
    Q_ENUM( RelationshipCapability )
 
    
    Q_DECLARE_FLAGS( RelationshipCapabilities, RelationshipCapability )
    Q_FLAG( RelationshipCapabilities )

    enum class CoordinateDisplayType : int
    {
      MapCrs,        
      MapGeographic, 
      CustomCrs,     
    };
    Q_ENUM( CoordinateDisplayType )
 
    
    enum class SettingsOrigin : int
    {
      Any,    
      Global, 
      Local,  
    };
    Q_ENUM( SettingsOrigin )
 
    
    enum class ScriptLanguage : int
    {
      Css,            
      QgisExpression, 
      Html,           
      JavaScript,     
      Json,           
      Python,         
      R,              
      Sql,            
      Batch,          
      Bash,           
      Unknown,        
    };
    Q_ENUM( ScriptLanguage )
 
    
    enum class ScriptLanguageCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Reformat = 1 << 0,      
      CheckSyntax = 1 << 1,   
      ToggleComment = 1 << 2, 
    };
    Q_ENUM( ScriptLanguageCapability )
 
    
    Q_DECLARE_FLAGS( ScriptLanguageCapabilities, ScriptLanguageCapability )
    Q_FLAG( ScriptLanguageCapabilities )

    enum class LayerTreeInsertionMethod : int
    {
      AboveInsertionPoint,     
      TopOfTree,               
      OptimalInInsertionGroup, 
    };
    Q_ENUM( LayerTreeInsertionMethod )
 
    
    enum class LegendLayerDoubleClickAction : int
    {
      LayerProperties = 0, 
      AttributeTable = 1,  
      LayerStyling = 2,    
    };
    Q_ENUM( LegendLayerDoubleClickAction )
 
    
    enum class LayerTreeFilterFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SkipVisibilityCheck = 1 << 0, 
    };
    Q_ENUM( LayerTreeFilterFlag )
 
    
    Q_DECLARE_FLAGS( LayerTreeFilterFlags, LayerTreeFilterFlag )
    Q_FLAG( LayerTreeFilterFlags )

    enum class MapLayerLegendFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ExcludeByDefault = 1 << 0, 
    };
    Q_ENUM( MapLayerLegendFlag )
 
    
    Q_DECLARE_FLAGS( MapLayerLegendFlags, MapLayerLegendFlag )
    Q_FLAG( MapLayerLegendFlags )

    enum class LegendComponent SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLegendStyle, Style ) : int
    {
      Undefined,   
      Hidden,      
      Title,       
      Group,       
      Subgroup,    
      Symbol,      
      SymbolLabel, 
    };
    // !!! WARNING: If adding new values to this enum, make sure you update QgsLegendSettings constructor accordingly!!
    Q_ENUM( LegendComponent )
 
    
    enum class LegendSyncMode : int
    {
      AllProjectLayers, 
      VisibleLayers,    
      Manual,           
    };
    Q_ENUM( LegendSyncMode )
 
    
    enum class LegendJsonRenderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowRuleDetails = 1 << 0, 
    };
    Q_ENUM( LegendJsonRenderFlag )
    Q_DECLARE_FLAGS( LegendJsonRenderFlags, LegendJsonRenderFlag )
    Q_FLAG( LegendJsonRenderFlags )

    enum class GeoJsonProfile : int
    {
      Legacy, 
      Rfc7946,    
      JsonFg,     
      JsonFgPlus, 
    };
    Q_ENUM( GeoJsonProfile )
 
    
    enum class ActionType : int
    {
      Invalid,        
      MapLayerAction, 
      AttributeAction 
    };
    Q_ENUM( ActionType )
 
    
    enum class MapLayerActionTarget : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Layer = 1 << 0,            
      SingleFeature = 1 << 1,    
      MultipleFeatures = 1 << 2, 
      AllActions = Layer | SingleFeature | MultipleFeatures
    };
    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, 
    };
    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, 
    };
    Q_ENUM( AttributeActionType )
 
    
    enum class MetadataDateType
    {
      Created,    
      Published,  
      Revised,    
      Superseded, 
    };
    Q_ENUM( MetadataDateType )
 
    
    enum class AcademicReferenceType : int
    {
      Unknown,        
      Book,           
      JournalArticle, 
      Presentation,   
      WebPage,        
      Preprint        
    };
    Q_ENUM( AcademicReferenceType )
 
    
 
    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,  
    };
    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 ), 
    };
    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 ), 
    };
    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        
    };
    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 
    };
    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, 
    };
    Q_ENUM( RasterIdentifyFormat )
 
    // TODO QGIS 5 -- 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,       
    };
    Q_ENUM( RasterInterfaceCapability )
 
    
    Q_DECLARE_FLAGS( RasterInterfaceCapabilities, RasterInterfaceCapability )
    Q_FLAG( RasterInterfaceCapabilities )
 
    // TODO QGIS 5 -- 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,                            
    };
    Q_ENUM( RasterProviderCapability )
 
    
    Q_DECLARE_FLAGS( RasterProviderCapabilities, RasterProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsRasterDataProvider, ProviderCapabilities )
    Q_FLAG( RasterProviderCapabilities )

    enum class ElevationMapCombineMethod : int
    {
      HighestElevation, 
      NewerElevation, 
    };
    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 ),                         
    };
    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 ),           
    };
    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 ) 
    };
    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 ),     
    };
    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 ),         
    };
    Q_ENUM( DistanceUnit )
 
    
    enum class DistanceUnitType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsUnitTypes, DistanceUnitType ) : int
    {
      Standard,                                           
      Geographic,                                         
      Unknown SIP_MONKEYPATCH_COMPAT_NAME( UnknownType ), 
    };
    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 ),                     
    };
    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 ),             
    };
    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 ),           
    };
    Q_ENUM( AngleUnit )
 
    
    enum class WindSpeedUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMeshRendererVectorWindBarbSettings, WindSpeedUnit ) : int
    {
      MetersPerSecond = 0, 
      KilometersPerHour,   
      Knots,               
      MilesPerHour,        
      FeetPerSecond,       
      OtherUnit            
    };
    Q_ENUM( WindSpeedUnit )
 
    
    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 )          
    };
    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 ), 
    };
    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 )            
    };
    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 ) 
    };
    Q_ENUM( LayoutUnitType )
 
    
    enum class LayoutRenderFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutRenderContext, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Debug SIP_MONKEYPATCH_COMPAT_NAME( FlagDebug ) = 1 << 1,                           
      OutlineOnly SIP_MONKEYPATCH_COMPAT_NAME( FlagOutlineOnly ) = 1 << 2,               
      Antialiasing SIP_MONKEYPATCH_COMPAT_NAME( FlagAntialiasing ) = 1 << 3,             
      UseAdvancedEffects SIP_MONKEYPATCH_COMPAT_NAME( FlagUseAdvancedEffects ) = 1 << 4, 
      ForceVectorOutput SIP_MONKEYPATCH_COMPAT_NAME( FlagForceVectorOutput )
      = 1 << 5, 
      HideCoverageLayer SIP_MONKEYPATCH_COMPAT_NAME( FlagHideCoverageLayer ) = 1 << 6, 
      DrawSelection SIP_MONKEYPATCH_COMPAT_NAME( FlagDrawSelection ) = 1 << 7,         
      DisableTiledRasterLayerRenders SIP_MONKEYPATCH_COMPAT_NAME( FlagDisableTiledRasterLayerRenders )
      = 1 << 8, 
      RenderLabelsByMapLayer SIP_MONKEYPATCH_COMPAT_NAME( FlagRenderLabelsByMapLayer )
      = 1 << 9, 
      LosslessImageRendering SIP_MONKEYPATCH_COMPAT_NAME( FlagLosslessImageRendering )
      = 1 << 10, 
      SynchronousLegendGraphics SIP_MONKEYPATCH_COMPAT_NAME( FlagSynchronousLegendGraphics ) = 1 << 11, 
      AlwaysUseGlobalMasks SIP_MONKEYPATCH_COMPAT_NAME( FlagAlwaysUseGlobalMasks )
      = 1 << 12, 
      LimitCoverageLayerRenderToCurrentFeature = 1 << 13, 
    };
    Q_ENUM( LayoutRenderFlag )
 
    
    Q_DECLARE_FLAGS( LayoutRenderFlags, LayoutRenderFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsLayoutRenderContext, Flags )
    Q_FLAG( LayoutRenderFlags )

    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 ), 
    };
    Q_ENUM( PictureFormat )
 
    
    enum class ScaleCalculationMethod : int
    {
      HorizontalTop = 0, 
      HorizontalMiddle,  
      HorizontalBottom,  
      HorizontalAverage, 
      AtEquator, 
    };
    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 ),   
    };
    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 
    };
    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 ),     
    };
    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 ), 
    };
    Q_ENUM( ScaleBarDistanceLabelHorizontalPlacement )
 
 
    
    enum class MapGridUnit SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, GridUnit ) : int
    {
      MapUnits SIP_MONKEYPATCH_COMPAT_NAME( MapUnit ), 
      Millimeters SIP_MONKEYPATCH_COMPAT_NAME( MM ),   
      Centimeters SIP_MONKEYPATCH_COMPAT_NAME( CM ),   
      DynamicPageSizeBased,                            
    };
    Q_ENUM( MapGridUnit )
 
    
    enum class MapGridStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, GridStyle ) : int
    {
      Lines SIP_MONKEYPATCH_COMPAT_NAME( Solid ) = 0,                             
      LineCrosses SIP_MONKEYPATCH_COMPAT_NAME( Cross ),                           
      Markers,                                                                    
      FrameAndAnnotationsOnly SIP_MONKEYPATCH_COMPAT_NAME( FrameAnnotationsOnly ) 
    };
    Q_ENUM( MapGridStyle )
 
    
    enum class MapGridComponentVisibility SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, DisplayMode ) : int
    {
      ShowAll = 0,   
      LatitudeOnly,  
      LongitudeOnly, 
      HideAll        
    };
    Q_ENUM( MapGridComponentVisibility )
 
    
    enum class MapGridAnnotationPosition SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, AnnotationPosition ) : int
    {
      InsideMapFrame = 0, 
      OutsideMapFrame,    
    };
    Q_ENUM( MapGridAnnotationPosition )
 
    
    enum class MapGridAnnotationDirection SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, AnnotationDirection ) : int
    {
      Horizontal = 0,     
      Vertical,           
      VerticalDescending, 
      BoundaryDirection,  
      AboveTick,          
      OnTick,             
      UnderTick,          
    };
    Q_ENUM( MapGridAnnotationDirection )
 
    
    enum class MapGridAnnotationFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, AnnotationFormat ) : int
    {
      Decimal = 0,                
      DegreeMinute,               
      DegreeMinuteSecond,         
      DecimalWithSuffix,          
      DegreeMinuteNoSuffix,       
      DegreeMinutePadded,         
      DegreeMinuteSecondNoSuffix, 
      DegreeMinuteSecondPadded,   
      CustomFormat                
    };
    Q_ENUM( MapGridAnnotationFormat )
 
    
    enum class MapGridBorderSide SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, BorderSide ) : int
    {
      Left,   
      Right,  
      Bottom, 
      Top,    
    };
    Q_ENUM( MapGridBorderSide )
 
    
    enum class MapGridFrameStyle SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, FrameStyle ) : int
    {
      NoFrame = 0,           
      Zebra,                 
      InteriorTicks,         
      ExteriorTicks,         
      InteriorExteriorTicks, 
      LineBorder,            
      LineBorderNautical,    
      ZebraNautical,         
    };
    Q_ENUM( MapGridFrameStyle )
 
    
    enum class MapGridTickLengthMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, TickLengthMode ) : int
    {
      OrthogonalTicks = 0, 
      NormalizedTicks,     
    };
    Q_ENUM( MapGridTickLengthMode )
 
 
    
    enum class MapGridFrameSideFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, FrameSideFlag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Left SIP_MONKEYPATCH_COMPAT_NAME( FrameLeft ) = 0x01,    
      Right SIP_MONKEYPATCH_COMPAT_NAME( FrameRight ) = 0x02,  
      Top SIP_MONKEYPATCH_COMPAT_NAME( FrameTop ) = 0x04,      
      Bottom SIP_MONKEYPATCH_COMPAT_NAME( FrameBottom ) = 0x08 
    };
    Q_ENUM( MapGridFrameSideFlag )
 
    
    Q_DECLARE_FLAGS( MapGridFrameSideFlags, MapGridFrameSideFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsLayoutItemMapGrid, FrameSideFlags )
    Q_FLAG( MapGridFrameSideFlags )

    enum class MapGridAnnotationType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayoutItemMapGrid, AnnotationCoordinate ) : int
      {
      Longitude = 0, 
      Latitude 
    };
    Q_ENUM( MapGridAnnotationType )
 
    
    enum class InputControllerType : int
    {
      Map2D, 
      Map3D  
    };
    Q_ENUM( InputControllerType );

    enum class PostgresRelKind
    {
      NotSet,           
      Unknown,          
      OrdinaryTable,    
      Index,            
      Sequence,         
      View,             
      MaterializedView, 
      CompositeType,    
      ToastTable,       
      ForeignTable,     
      PartitionedTable, 
    };
    Q_ENUM( PostgresRelKind )
 
    
    enum class DatabaseProviderConnectionCapability2 : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SetFieldComment = 1 << 0,   
      SetFieldAlias = 1 << 1,     
      SetTableComment = 1 << 2,   
      EditFieldDomain = 1 << 3,   
      DeleteFieldDomain = 1 << 4, 
    };
    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,     
    };
    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
    };
    Q_ENUM( ProviderStyleStorageCapability );
    Q_DECLARE_FLAGS( ProviderStyleStorageCapabilities, ProviderStyleStorageCapability )
    Q_FLAG( ProviderStyleStorageCapabilities )
 
    
    enum class UserProfileSelectionPolicy : int
    {
      LastProfile,    
      DefaultProfile, 
      AskUser,        
    };
    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 ),             
    };
    Q_ENUM( AttributeEditorType )
 
    
    enum class AttributeEditorContainerType : int
    {
      GroupBox, 
      Tab,      
      Row,      
    };
    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            
    };
    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          
    };
    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 
    };
    Q_ENUM( AttributeFormPythonInitCodeSource )
 
    
    enum class AttributeFormReuseLastValuePolicy : int
    {
      NotAllowed = 0,        
      AllowedDefaultOn = 1,  
      AllowedDefaultOff = 2, 
    };
    Q_ENUM( AttributeFormReuseLastValuePolicy )
 
    
    enum class ExpressionType
    {
      Qgis,             
      PointCloud,       
      RasterCalculator, 
    };
    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 ) 
    };
    Q_ENUM( FeatureSymbologyExport )
 
    
    enum class VectorTileProviderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AlwaysUseTileMatrixSetFromProvider = 1 << 1, 
    };
    Q_ENUM( VectorTileProviderFlag )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderFlags, VectorTileProviderFlag )
    Q_FLAG( VectorTileProviderFlags )

    enum class VectorTileProviderCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ReadLayerMetadata = 1 << 1, 
    };
    Q_ENUM( VectorTileProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderCapabilities, VectorTileProviderCapability )
    Q_FLAG( VectorTileProviderCapabilities )

    enum class TileAvailability
    {
      Available,             
      NotAvailable,          
      AvailableNoChildren,   
      UseLowerZoomLevelTile, 
    };
    Q_ENUM( TileAvailability )
 
    
    enum class TiledSceneProviderCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ReadLayerMetadata = 1 << 1, 
    };
    Q_ENUM( TiledSceneProviderCapability )
 
    
    Q_DECLARE_FLAGS( TiledSceneProviderCapabilities, TiledSceneProviderCapability )
    Q_FLAG( TiledSceneProviderCapabilities )

    enum class TiledSceneBoundingVolumeType
    {
      Region,      
      OrientedBox, 
      Sphere,      
    };
    Q_ENUM( TiledSceneBoundingVolumeType )
 
    
    enum class TileRefinementProcess
    {
      Replacement, 
      Additive,    
    };
    Q_ENUM( TileRefinementProcess )
 
    
    enum class TileChildrenAvailability
    {
      NoChildren,   
      Available,    
      NeedFetching, 
    };
    Q_ENUM( TileChildrenAvailability )
 
    
    enum class TiledSceneRequestFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoHierarchyFetch = 1 << 0, 
    };
    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,      
    };
    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,              
    };
    Q_ENUM( GdalResampleAlgorithm )
 
    
    enum class VsiHandlerType : int
    {
      Invalid, 
      Archive, 
      Network, 
      Cloud,   
      Memory,  
      Other,   
    };
    Q_ENUM( VsiHandlerType )
 
    // TODO QGIS 5: 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, 
      // clang-format off
      All = Count | Sum | Mean | Median | StDev | Max | Min | Range | Minority | Majority | Variety | Variance, 
      // clang-format on
      AllNumeric = Count | Sum | Mean | Median | StDev | Max | Min | Range | Minority | Majority | Variety | Variance, 
      Default = Count | Sum | Mean,                                                                                    
    };
    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 
    };
    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 
    };
    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 
    };
    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, 
    };
    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, 
    };
    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 
    };
    Q_ENUM( RasterBandStatistic )
 
    
    Q_DECLARE_FLAGS( RasterBandStatistics, RasterBandStatistic ) SIP_MONKEYPATCH_FLAGS_UNNEST( Qgis, RasterBandStatistics )
    Q_FLAG( RasterBandStatistics )

    enum class InterpolationSourceType : int
    {
      Points,  
      StructureLines, 
      BreakLines, 
    };
    Q_ENUM( InterpolationSourceType )
 
    
    enum class InterpolationValueSource : int
    {
      Attribute, 
      Z,         
      M,         
    };
    Q_ENUM( InterpolationValueSource )
 
    
    enum class SensorThingsVersion : int
    {
      Version1_1, 
      Version2_0, 
    };
    Q_ENUM( SensorThingsVersion );

    enum class SensorThingsExtension : int SIP_ENUM_BASETYPE( IntFlag )
    {
      MultiDatastream = 1 << 0,                          
      SensingExtensionObservationsMeasurements = 1 << 1, 
      SensingExtensionSampling = 1 << 2,                 
      SensingExtensionRelations = 1 << 3,                
    };
    Q_ENUM( SensorThingsExtension );

    Q_DECLARE_FLAGS( SensorThingsExtensions, SensorThingsExtension )
    Q_FLAG( SensorThingsExtensions )
 
    
    enum class SensorThingsEntity : int
    {
      Invalid, 
      Thing, 
      Location,           
      HistoricalLocation, 
      Datastream,         
      Sensor,             
      ObservedProperty,   
      Observation,        
      FeatureOfInterest, 
      MultiDatastream, 
      // version 2.0
      Feature, 
      FeatureType, 
      Deployment, 
      ObservingProcedure, 
      Sampling, 
      SamplingProcedure, 
      Sampler, 
      PreparationStep, 
      PreparationProcedure, 
      ThingRelation, 
      RelationRole,  
      FeatureRelation, 
      DatastreamRelation, 
      ObservationRelation, 
    };
    Q_ENUM( SensorThingsEntity )
 
    
    enum class ColorModel : int
    {
      Rgb,  
      Cmyk, 
    };
    Q_ENUM( ColorModel )
 
    
    enum class DocumentationApi : int
    {
      PyQgis,       
      PyQgisSearch, 
      CppQgis,      
      Qt,           
    };
    Q_ENUM( DocumentationApi )
 
    
    enum class DocumentationBrowser : int
    {
      DeveloperToolsPanel, 
      SystemWebBrowser,    
    };
    Q_ENUM( DocumentationBrowser )
 
    
    enum class MouseHandlesAction : int
    {
      MoveItem,          
      ResizeUp,          
      ResizeDown,        
      ResizeLeft,        
      ResizeRight,       
      ResizeLeftUp,      
      ResizeRightUp,     
      ResizeLeftDown,    
      ResizeRightDown,   
      RotateTopLeft,     
      RotateTopRight,    
      RotateBottomLeft,  
      RotateBottomRight, 
      SelectItem,        
      NoAction           
    };
    Q_ENUM( MouseHandlesAction )
 
    
    enum class MeshRangeLimit : int
    {
      NotSet,         
      MinimumMaximum, 
    };
    Q_ENUM( MeshRangeLimit )
 
    
    enum class MeshRangeExtent : int
    {
      WholeMesh,     
      FixedCanvas,   
      UpdatedCanvas, 
    };
    Q_ENUM( MeshRangeExtent )
 
    
    enum class PointCloudAccessType : int
    {
      Local, 
      Remote 
    };
    Q_ENUM( PointCloudAccessType )
 
    
    enum class PointCloudZoomOutRenderBehavior : int
    {
      RenderExtents,           
      RenderOverview,          
      RenderOverviewAndExtents 
    };
    Q_ENUM( PointCloudZoomOutRenderBehavior )
 
    
    enum class SegmentCalculationMethod : int
    {
      Standard = 0,   
      Adaptive,       
      AreaError,      
      ConstantDensity 
    };
    Q_ENUM( SegmentCalculationMethod )
 
    
    enum class StacObjectType : int
    {
      Unknown,    
      Catalog,    
      Collection, 
      Item,       
    };
    Q_ENUM( StacObjectType )
 
    
    enum class RasterProcessingParameterCapability : int SIP_ENUM_BASETYPE( IntFlag )
    {
      WmsScale = 1 << 0, 
      WmsDpi = 1 << 1,   
    };
    Q_ENUM( RasterProcessingParameterCapability )
 
    
    Q_DECLARE_FLAGS( RasterProcessingParameterCapabilities, RasterProcessingParameterCapability )
    Q_FLAG( RasterProcessingParameterCapabilities )

    enum class DevToolsNodeRole
    {
      Status = Qt::UserRole + 1, 
      Id,                        
      ElapsedTime,               
      MaximumTime,               
      Sort,                      
    };
    Q_ENUM( DevToolsNodeRole )
 
    
    enum class ExtrusionFace : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoFace = 0,
      Walls = 1 << 0,
      Roof = 1 << 1,
      Floor = 1 << 2
    };
    Q_ENUM( ExtrusionFace )
 
    
    Q_DECLARE_FLAGS( ExtrusionFaces, ExtrusionFace )
    Q_FLAG( ExtrusionFaces )

    enum class TriangulationAlgorithm : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ConstrainedDelaunay = 0,
      Earcut = 1 << 0
    };
    Q_ENUM( TriangulationAlgorithm )
 
    
    enum class WmsGroupRequestMode : int
    {
      Normal, 
      Opaque, 
    };
    Q_ENUM( WmsGroupRequestMode )
 
    
    enum class DockableWidgetInitialState : int
    {
      RestorePreviousState, 
      ForceDocked,          
      ForceDialog,          
    };
    Q_ENUM( DockableWidgetInitialState )
 
    
    enum class CoverageCleanOverlapMergeStrategy : int
    {
      LongestBorder = 0, 
      MaximumArea = 1,   
      MinimumArea = 2,   
      MinimumIndex = 3,  
    };
    Q_ENUM( CoverageCleanOverlapMergeStrategy )
 
    
    enum class PdfRenderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RenderTextAsText = 1 << 0, 
    };
    Q_ENUM( PdfRenderFlag )
 
    
    Q_DECLARE_FLAGS( PdfRenderFlags, PdfRenderFlag )
    Q_FLAG( PdfRenderFlags )
 

    enum class WmsDimensionDefaultDisplay : int
    {
      AllValues = 0,      
      MinValue = 1,       
      MaxValue = 2,       
      ReferenceValue = 3, 
    };
    Q_ENUM( WmsDimensionDefaultDisplay )
 
    
    enum class RubberBandIconType : int
    {
      NoIcon,        
      CrossPlus,     
      CrossX,        
      Box,           
      Circle,        
      BoxFilled,     
      Diamond,       
      DiamondFilled, 
      SVG            
    };
    Q_ENUM( RubberBandIconType )
 
    
    enum class RubberBandComponent : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Symbol = 1 << 0,       
      PreviewItems = 1 << 1, 
    };
    Q_ENUM( RubberBandComponent )
 
    
    Q_DECLARE_FLAGS( RubberBandComponents, RubberBandComponent )
    Q_FLAG( RubberBandComponents )

    enum class UserInterfaceIconType : int
    {
      MainWindowToolbar, 
      DockedToolbar,     
    };
    Q_ENUM( UserInterfaceIconType )
 
    
    enum class VectorFieldArrowScalingMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMeshRendererVectorArrowSettings, ArrowScalingMethod ) : int
    {
      MinMax = 0, 
      Scaled,     
      Fixed       
    };
    Q_ENUM( VectorFieldArrowScalingMethod )
 
    
    enum class VectorFieldSymbology SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMeshRendererVectorSettings, Symbology ) : int
    {
      Arrows = 0,  
      Streamlines, 
      Traces,      
      WindBarbs    
    };
    Q_ENUM( VectorFieldSymbology )
 
    
    enum class VectorFieldSeedingMethod SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMeshRendererVectorStreamlineSettings, SeedingStartPointsMethod ) : int
    {
      Gridded SIP_MONKEYPATCH_COMPAT_NAME( MeshGridded ) = 0, 
      Random                                                  
    };
    Q_ENUM( VectorFieldSeedingMethod )
 
    
    enum class LinearMatrixMethod : int
    {
      Lu = 0,               
      Svd = 1,              
      LuWithSvdFallback = 2 
    };
    Q_ENUM( LinearMatrixMethod )
 
    
    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 bool hasSfcgal();

    static int sfcgalVersionInt();

    static bool hasGeographicLib();

    static int geographicLibVersion();

    Q_DECL_DEPRECATED static bool hasQtWebkit();

    static QString geoNone() { return u"NONE"_s; }

    static QString geographicCrsAuthId() { return u"EPSG:4326"_s; }

    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 geoProj4() { return u"+proj=longlat +datum=WGS84 +no_defs"_s; }
};
 
QHASH_FOR_CLASS_ENUM( Qgis::CaptureTechnique )
QHASH_FOR_CLASS_ENUM( Qgis::RasterAttributeTableFieldUsage )
 
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::NetworkRequestFlags )
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::BrowserItemFilterFlags )
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::VerticalAxisInversionFlags )
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::PaintEffectFlags )
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::RasterProcessingParameterCapabilities )
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 )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LayoutRenderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerLegendFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::CurvedTextFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ExtrusionFaces )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapGridFrameSideFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolConverterCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ArcGisRestServiceCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::InstancedMaterialFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::Map3DDebugFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SensorThingsExtensions )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::PdfRenderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RubberBandComponents )
Q_DECLARE_METATYPE( Qgis::LayoutRenderFlags )
Q_DECLARE_METATYPE( QTimeZone )
 
// 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 ) )
    {}
 
    ~QgsSignalBlocker() { mObject->blockSignals( mPreviousState ); }

    Object *operator->() { return mObject; }
 
  private:
    Object *mObject = nullptr;
    bool mPreviousState;
};

// 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 );
}

CORE_EXPORT size_t 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( '.'_L1 ) )
      {
        // 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 == "-0"_L1 )
  {
    return "0"_L1;
  }
  return str;
}

inline bool qgsNanCompatibleEquals( double a, double b )
{
  if ( a == b )
    return true;
 
  if ( std::isnan( a ) && std::isnan( b ) ) [[unlikely]]
    return true;
 
  return false;
}
 
#ifndef SIP_RUN

template<typename T> inline bool qgsNumberNear( T a, T b, T epsilon = std::numeric_limits<T>::epsilon() * 4 )
{
  static_assert( std::is_floating_point<T>::value, "qgsNumberNear requires floating-point types" );
 
  if ( a == b )
    return true;
 
  // if either 'a' or 'b' is NaN, 'diff' becomes NaN.
  // comparisons (>= or <=) against NaN evaluate to false, which will fallback
  // to the nan related logic at the end of this function
  const T diff = a - b;
  if ( diff >= -epsilon && diff <= epsilon )
    return true;
 
  // defer expensive nan checks to last -- calling std::isnan is NOT cheap!
  if ( std::isnan( a ) && std::isnan( b ) ) [[unlikely]]
    return true;
 
  return false;
}
#endif

inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  return qgsNumberNear<double>( a, b, epsilon );
}

inline bool qgsDoubleLessThanOrNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  // fast check first
  if ( a <= b )
    return true;
 
  // => a > b
  // => a - b > 0
  // we only need to check the upper epsilon bound for the fuzzy equality
  if ( a - b <= epsilon )
    return true;
 
  // defer expensive nan checks to last -- calling std::isnan is NOT cheap!
  if ( std::isnan( a ) && std::isnan( b ) ) [[unlikely]]
    return true;
 
  return false;
}

inline bool qgsDoubleGreaterThanOrNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  // fast check first
  if ( a >= b )
    return true;
 
  // => a < b
  // => b - a > 0
  // we only need to check the upper epsilon bound for the fuzzy equality
  if ( b - a <= epsilon )
    return true;
 
  // defer expensive nan checks to last -- calling std::isnan is NOT cheap!
  if ( std::isnan( a ) && std::isnan( b ) ) [[unlikely]]
    return true;
 
  return false;
}

inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON )
{
  return qgsNumberNear<float>( a, b, 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 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;
}
 
#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;
}

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;
}

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;
}


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() );
  }

  template<typename To, typename From> inline std::unique_ptr<To> unique_ptr_static_cast( std::unique_ptr<From> f )
  {
    static_assert( ( std::is_base_of<From, To>::value ), "target type not derived from source type" );
    Q_ASSERT( !f || dynamic_cast<To *>( f.get() ) != nullptr );
    return std::unique_ptr<To>( static_cast<To *>( f.release() ) );
  }

  template<typename To, typename From> inline std::unique_ptr<To> unique_ptr_dynamic_cast( std::unique_ptr<From> &&f )
  {
    static_assert( ( std::is_base_of<From, To>::value ), "target type not derived from source type" );
    if ( To *casted = dynamic_cast<To *>( f.get() ) )
    {
      return std::unique_ptr< To >( dynamic_cast<To *>( f.release() ) );
    }
    else
    {
      //could not cast
      return nullptr;
    }
  }
 
 
} //namespace qgis

#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 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> 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> 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> 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 );
  if ( intValue == 0 )
  {
    if ( returnOk )
      *returnOk = true;
    return u"0"_s;
  }
 
  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> 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;
  }
  else if ( keys == "0"_L1 )
  {
    if ( returnOk )
    {
      *returnOk = true;
    }
    return T();
  }
  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 keyArray = metaEnum.valueToKeys( intValue );
        const int intValueCheck = metaEnum.keysToValue( keyArray );
        if ( !keyArray.isEmpty() && intValue == intValueCheck )
        {
          if ( returnOk )
          {
            *returnOk = true;
          }
          return T( intValue );
        }
      }
    }
  }
  return defaultValue;
}
 

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 int qgsVariantCompare( const QVariant &lhs, const QVariant &rhs, bool strictTypeCheck = false );

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 );

inline bool operator>( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantCompare( v1, v2, true ) > 0;
}

inline bool operator<( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantCompare( v1, v2, true ) < 0;
}

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
 
#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