qgis.h

Go to the documentation of this file.

/***************************************************************************
                          qgis.h - QGIS namespace
                             -------------------
    begin                : Sat Jun 30 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGIS_H
#define QGIS_H
 
 
#include <QMetaEnum>
#include <cfloat>
#include <memory>
#include <cmath>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#ifdef SIP_RUN
% ModuleHeaderCode
#include <qgis.h>
% End
 
% ModuleCode
int QgisEvent = QEvent::User + 1;
% End
#endif
 
#ifndef SIP_RUN
// qHash implementation for scoped enum type
// https://gitlab.com/frostasm/programming-knowledge-base/-/snippets/20120
#define QHASH_FOR_CLASS_ENUM(T) \
  inline uint qHash(const T &t, uint seed) { \
    return ::qHash(static_cast<typename std::underlying_type<T>::type>(t), seed); \
  }
#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 MessageLevel
    {
      Info = 0, 
      Warning = 1, 
      Critical = 2, 
      Success = 3, 
      NoLevel = 4, 
    };
    Q_ENUM( MessageLevel )
 
    
    enum class LayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsMapLayer, LayerType ) : int
      {
      Vector SIP_MONKEYPATCH_COMPAT_NAME( VectorLayer ), 
      Raster SIP_MONKEYPATCH_COMPAT_NAME( RasterLayer ), 
      Plugin SIP_MONKEYPATCH_COMPAT_NAME( PluginLayer ), 
      Mesh SIP_MONKEYPATCH_COMPAT_NAME( MeshLayer ),    
      VectorTile SIP_MONKEYPATCH_COMPAT_NAME( VectorTileLayer ), 
      Annotation SIP_MONKEYPATCH_COMPAT_NAME( AnnotationLayer ), 
      PointCloud SIP_MONKEYPATCH_COMPAT_NAME( PointCloudLayer ), 
      Group SIP_MONKEYPATCH_COMPAT_NAME( GroupLayer ), 
      TiledScene, 
    };
    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, 
      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, 
      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, 
      PointZM = 3001, 
      LineStringZM = 3002, 
      PolygonZM = 3003, 
      MultiPointZM = 3004, 
      MultiLineStringZM = 3005, 
      MultiPolygonZM = 3006, 
      GeometryCollectionZM = 3007, 
      CircularStringZM = 3008, 
      CompoundCurveZM = 3009, 
      CurvePolygonZM = 3010, 
      MultiCurveZM = 3011, 
      MultiSurfaceZM = 3012, 
      TriangleZM = 3017, 
      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, 
    };
    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 PythonMacroMode SIP_MONKEYPATCH_SCOPEENUM_UNNEST( Qgis, PythonMacroMode ) : int
      {
      Never = 0, 
      Ask = 1, 
      SessionOnly = 2, 
      Always = 3, 
      NotForThisSession, 
    };
    Q_ENUM( PythonMacroMode )
 
    
    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 4 -- remove NoCapabilities and rely on VectorProviderCapabilities() instead
 
    enum class VectorProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, Capability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0, 
      AddFeatures = 1, 
      DeleteFeatures = 1 <<  1, 
      ChangeAttributeValues = 1 <<  2, 
      AddAttributes = 1 <<  3, 
      DeleteAttributes = 1 <<  4, 
      CreateSpatialIndex = 1 <<  6, 
      SelectAtId = 1 <<  7, 
      ChangeGeometries = 1 <<  8, 
      SelectEncoding = 1 << 13, 
      CreateAttributeIndex = 1 << 12, 
      SimplifyGeometries = 1 << 14, 
      SimplifyGeometriesWithTopologicalValidation = 1 << 15, 
      TransactionSupport = 1 << 16, 
      CircularGeometries = 1 << 17, 
      ChangeFeatures = 1 << 18, 
      RenameAttributes = 1 << 19, 
      FastTruncate = 1 << 20, 
      ReadLayerMetadata = 1 << 21, 
      WriteLayerMetadata = 1 << 22, 
      CancelSupport = 1 << 23, 
      CreateRenderer = 1 << 24, 
      CreateLabeling = 1 << 25, 
      ReloadData = 1 << 26, 
      FeatureSymbology = 1 << 27, 
      EditingCapabilities = AddFeatures | DeleteFeatures | ChangeAttributeValues | ChangeGeometries | AddAttributes | DeleteAttributes | RenameAttributes, 
    };
    Q_ENUM( VectorProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorProviderCapabilities, VectorProviderCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsVectorDataProvider, Capabilities )
    Q_FLAG( VectorProviderCapabilities )
 
    enum class FeatureCountState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, FeatureCountState ) : int
      {
      Uncounted = -2, 
      UnknownCount = -1, 
    };
    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, //<! Save the former value of the settings
      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, 
    };
    Q_ENUM( SymbolRenderHint )
    Q_DECLARE_FLAGS( SymbolRenderHints, SymbolRenderHint ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, RenderHints )
    Q_FLAG( SymbolRenderHints )
 
    enum class SymbolRotationMode : int
    {
      RespectMapRotation, 
      IgnoreMapRotation, 
    };
    Q_ENUM( SymbolRotationMode )
 
    
    enum class SymbolFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      RendererShouldUseSymbolLevels = 1 << 0, 
    };
    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, 
    };
    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 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 
    };
    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 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 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 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 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 SublayerQueryFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      FastScan = 1 << 0, 
      ResolveGeometryType = 1 << 1, 
      CountFeatures = 1 << 2, 
      IncludeSystemTables = 1 << 3, 
    };
    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 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 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 ), 
    };
    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 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, 
    };
    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, 
    };
    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 Axis : int
    {
      X, 
      Y, 
      Z 
    };
    Q_ENUM( Axis )
 
    
    enum class AnnotationItemFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ScaleDependentBoundingBox = 1 << 0, 
    };
    Q_DECLARE_FLAGS( AnnotationItemFlags, AnnotationItemFlag )
    Q_ENUM( AnnotationItemFlag )
    Q_FLAG( AnnotationItemFlags )
 
    
    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, 
    };
    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, 
    };
    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 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, 
    };
    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, 
    };
    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,
    };
    Q_ENUM( MapLayerRendererFlag )
 
    
    Q_DECLARE_FLAGS( MapLayerRendererFlags, MapLayerRendererFlag )
    Q_FLAG( MapLayerRendererFlags )
 
    // refs for below dox: https://github.com/qgis/QGIS/pull/1286#issuecomment-39806854
    // https://github.com/qgis/QGIS/pull/8573#issuecomment-445585826
 
    enum class TextRenderFormat SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRenderContext, TextRenderFormat ) : int
      {
      AlwaysOutlines SIP_MONKEYPATCH_COMPAT_NAME( TextFormatAlwaysOutlines ), 
      AlwaysText SIP_MONKEYPATCH_COMPAT_NAME( TextFormatAlwaysText ), 
    };
    Q_ENUM( TextRenderFormat )
 
    
    enum class LabelingFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLabelingEngineSettings, Flag ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      UseAllLabels          = 1 << 1, 
      UsePartialCandidates  = 1 << 2, 
      // TODO QGIS 4.0: remove
      RenderOutlineLabels   = 1 << 3, 
      DrawLabelRectOnly     = 1 << 4, 
      DrawCandidates        = 1 << 5, 
      DrawUnplacedLabels    = 1 << 6, 
      CollectUnplacedLabels = 1 << 7, 
      DrawLabelMetrics      = 1 << 8, 
    };
    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
      {
      Text, 
      Buffer, 
      Background, 
      Shadow, 
    };
    Q_ENUM( TextComponent )
 
    
    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 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 VertexType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVertexId, VertexType ) : int
      {
      Segment SIP_MONKEYPATCH_COMPAT_NAME( SegmentVertex ) = 1, 
      Curve SIP_MONKEYPATCH_COMPAT_NAME( CurveVertex ) = 2, 
    };
    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 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 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 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 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 
    };
    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, 
      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, 
    };
    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 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, 
    };
    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 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 Point3DShape : int
    {
      Cylinder, 
      Sphere, 
      Cone, 
      Cube, 
      Torus, 
      Plane, 
      ExtrudedText, 
      Model, 
      Billboard, 
    };
    Q_ENUM( Point3DShape )
 
    
    enum class LightSourceType : int
    {
      Point, 
      Directional, 
    };
    Q_ENUM( LightSourceType )
 
    
    enum class NavigationMode : int
    {
      TerrainBased, 
      Walk 
    };
    Q_ENUM( NavigationMode )
 
    
    enum class VerticalAxisInversion : int
    {
      Never, 
      WhenDragging, 
      Always, 
    };
    Q_ENUM( VerticalAxisInversion )
 
    
    enum class ProfileSurfaceSymbology : int
    {
      Line, 
      FillBelow, 
      FillAbove, 
    };
    Q_ENUM( ProfileSurfaceSymbology );
 
    enum class VectorProfileType : int
    {
      IndividualFeatures, 
      ContinuousSurface, 
    };
    Q_ENUM( VectorProfileType );
 
    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, 
    };
    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, 
    };
    Q_ENUM( ArcGisRestServiceType )
 
    
    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 LayerTreeFilterFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      SkipVisibilityCheck = 1 << 0, 
    };
    Q_ENUM( LayerTreeFilterFlag )
 
    
    Q_DECLARE_FLAGS( LayerTreeFilterFlags, LayerTreeFilterFlag )
    Q_FLAG( LayerTreeFilterFlags )
 
 
    enum class LegendJsonRenderFlag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      ShowRuleDetails = 1 << 0, 
    };
    Q_ENUM( LegendJsonRenderFlag )
    Q_DECLARE_FLAGS( LegendJsonRenderFlags, LegendJsonRenderFlag )
    Q_FLAG( LegendJsonRenderFlags )
 
    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, 
    };
    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 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  
    };
    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 4 -- remove NoCapabilities and rely on RasterInterfaceCapabilities() instead
    // remove deprecated members
    // Remove "Identify" member, and replace with combinations of IdentifyValue/IdentifyText/etc
 
    
    enum class RasterInterfaceCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterInterface, Capability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoCapabilities = 0, 
      Size = 1 << 1, 
      Create = 1 << 2, 
      Remove = 1 << 3, 
      BuildPyramids = 1 << 4, 
      Identify = 1 << 5, 
      IdentifyValue = 1 << 6, 
      IdentifyText = 1 << 7, 
      IdentifyHtml = 1 << 8, 
      IdentifyFeature = 1 << 9, 
      Prefetch = 1 << 10, 
    };
    Q_ENUM( RasterInterfaceCapability )
 
    
    Q_DECLARE_FLAGS( RasterInterfaceCapabilities, RasterInterfaceCapability )
    Q_FLAG( RasterInterfaceCapabilities )
 
    // TODO QGIS 4 -- remove NoProviderCapabilities and rely on RasterProviderCapabilities() instead
 
    enum class RasterProviderCapability SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsRasterDataProvider, ProviderCapability ) : int SIP_ENUM_BASETYPE( IntFlag )
    {
      NoProviderCapabilities = 0, 
      ReadLayerMetadata = 1 << 1, 
      WriteLayerMetadata = 1 << 2, 
      ProviderHintBenefitsFromResampling = 1 << 3, 
      ProviderHintCanPerformProviderResampling = 1 << 4, 
      ReloadData = 1 << 5, 
      DpiDependentData = 1 << 6, 
      NativeRasterAttributeTable = 1 << 7, 
      BuildPyramids = 1 << 8, 
    };
    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, 
      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 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 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 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 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, 
    };
    Q_ENUM( DatabaseProviderConnectionCapability2 )
    Q_DECLARE_FLAGS( DatabaseProviderConnectionCapabilities2, DatabaseProviderConnectionCapability2 )
    Q_FLAG( DatabaseProviderConnectionCapabilities2 )
 
    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 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 )
 
    
    enum class ZonalStatistic : int SIP_ENUM_BASETYPE( IntFlag )
    {
      Count = 1,  
      Sum = 2,  
      Mean = 4,  
      Median = 8, 
      StDev = 16, 
      Min = 32,  
      Max = 64,  
      Range = 128, 
      Minority = 256, 
      Majority = 512, 
      Variety = 1024, 
      Variance = 2048, 
      All = 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 SensorThingsEntity : int
    {
      Invalid, 
      Thing, 
      Location, 
      HistoricalLocation, 
      Datastream, 
      Sensor, 
      ObservedProperty, 
      Observation, 
      FeatureOfInterest, 
      MultiDatastream, 
    };
    Q_ENUM( SensorThingsEntity )
 
    
    enum class ColorModel : int
    {
      Rgb, 
      Cmyk, 
    };
    Q_ENUM( ColorModel )
 
    
    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;
 
    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 QString defaultProjectScales();
 
    static int geosVersionInt();
 
    static int geosVersionMajor();
 
    static int geosVersionMinor();
 
    static int geosVersionPatch();
 
    static QString geosVersion();
};
 
QHASH_FOR_CLASS_ENUM( Qgis::CaptureTechnique )
QHASH_FOR_CLASS_ENUM( Qgis::RasterAttributeTableFieldUsage )
 
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemGuiFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelCommandFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelFormatCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BrowserItemCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::CoordinateTransformationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DatabaseProviderConnectionCapabilities2 )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FileOperationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GeometryValidityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GpsInformationComponents )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::HistoryProviderBackends )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelingFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelLinePlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelPolygonPlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LayerTreeFilterFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LegendJsonRenderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionTargets )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerProperties )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LoadStyleFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapSettingsFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MarkerLinePlacements )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::PlotToolFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProfileGeneratorFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectReadFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterRendererCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterTemporalCapabilityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RelationshipCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RenderContextFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ScriptLanguageCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SelectionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SettingsTreeNodeOptions )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SnappingTypes )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SqlLayerDefinitionCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerQueryFlags )
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::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::FeatureRequestFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingFeatureSourceDefinitionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ZonalStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::Statistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DateTimeStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::StringStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterBandStatistics )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterInterfaceCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingAlgorithmFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingAlgorithmDocumentationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingFeatureSourceFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingParameterTypeFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProcessingParameterFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataItemProviderCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorRenderingSimplificationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataProviderReadFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorProviderCapabilities )
 
// 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 uint qHash( const QVariant &variant );
 
inline QString qgsDoubleToString( double a, int precision = 17 )
{
  QString str;
  if ( precision )
  {
    if ( precision < 0 )
    {
      const double roundFactor = std::pow( 10, -precision );
      str = QString::number( static_cast< long long >( std::round( a / roundFactor ) * roundFactor ) );
    }
    else
    {
      str = QString::number( a, 'f', precision );
      if ( str.contains( QLatin1Char( '.' ) ) )
      {
        // remove ending 0s
        int idx = str.length() - 1;
        while ( str.at( idx ) == '0' && idx > 1 )
        {
          idx--;
        }
        if ( idx < str.length() - 1 )
          str.truncate( str.at( idx ) == '.' ? idx : idx + 1 );
      }
    }
  }
  else
  {
    str = QString::number( a, 'f', precision );
  }
  // avoid printing -0
  // see https://bugreports.qt.io/browse/QTBUG-71439
  if ( str == QLatin1String( "-0" ) )
  {
    return QLatin1String( "0" );
  }
  return str;
}
 
inline bool qgsNanCompatibleEquals( double a, double b )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  return a == b;
}
 
#ifndef SIP_RUN
 
template<typename T>
inline bool qgsNumberNear( T a, T b, T epsilon = std::numeric_limits<T>::epsilon() * 4 )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  const T diff = a - b;
  return diff >= -epsilon && diff <= epsilon;
}
#endif
 
inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  return qgsNumberNear<double>( a, b, epsilon );
}
 
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() );
  }
}
 
#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 );
  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;
  }
  const QMetaEnum metaEnum = QMetaEnum::fromType<T>();
  Q_ASSERT( metaEnum.isValid() );
  bool ok = false;
  T v = static_cast<T>( metaEnum.keysToValue( keys.toUtf8().constData(), &ok ) );
  if ( returnOk )
  {
    *returnOk = ok;
  }
  if ( ok )
  {
    return v;
  }
  else
  {
    // if conversion has failed, try with conversion from int value
    if ( tryValueAsKey )
    {
      bool canConvert = false;
      const int intValue = keys.toInt( &canConvert );
      if ( canConvert )
      {
        const QByteArray keys = metaEnum.valueToKeys( intValue );
        const int intValueCheck = metaEnum.keysToValue( keys );
        if ( intValue == intValueCheck )
        {
          if ( returnOk )
          {
            *returnOk = true;
          }
          return T( intValue );
        }
      }
    }
  }
  return defaultValue;
}
 
 
CORE_EXPORT double qgsPermissiveToDouble( QString string, bool &ok );
 
CORE_EXPORT int qgsPermissiveToInt( QString string, bool &ok );
 
CORE_EXPORT qlonglong qgsPermissiveToLongLong( QString string, bool &ok );
 
CORE_EXPORT bool qgsVariantLessThan( const QVariant &lhs, const QVariant &rhs );
 
CORE_EXPORT bool qgsVariantEqual( const QVariant &lhs, const QVariant &rhs );
 
CORE_EXPORT bool qgsVariantGreaterThan( const QVariant &lhs, const QVariant &rhs );
 
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
 
inline bool operator> ( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantGreaterThan( v1, v2 );
}
 
inline bool operator< ( const QVariant &v1, const QVariant &v2 )
{
  return qgsVariantLessThan( v1, v2 );
}
#endif
 
 
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 
template<> CORE_EXPORT bool qMapLessThanKey<QVariantList>( const QVariantList &key1, const QVariantList &key2 ) SIP_SKIP;
#endif
 
CORE_EXPORT QString qgsVsiPrefix( const QString &path );
 
void CORE_EXPORT *qgsMalloc( size_t size ) SIP_SKIP;
 
void CORE_EXPORT qgsFree( void *ptr ) SIP_SKIP;
 
#ifndef SIP_RUN
 
#ifdef _MSC_VER
#define CONSTLATIN1STRING inline const QLatin1String
#else
#define CONSTLATIN1STRING constexpr QLatin1String
#endif
 
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;
};
 
CONSTLATIN1STRING geoWkt()
{
  return QLatin1String(
           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]] )"""
         );
}
 
CONSTLATIN1STRING geoProj4()
{
  return QLatin1String( "+proj=longlat +datum=WGS84 +no_defs" );
}
 
CONSTLATIN1STRING geoEpsgCrsAuthId()
{
  return QLatin1String( "EPSG:4326" );
}
 
CONSTLATIN1STRING geoNone()
{
  return QLatin1String( "NONE" );
}
 
 
const int PREVIEW_JOB_DELAY_MS = 250;
 
const int MAXIMUM_LAYER_PREVIEW_TIME_MS = 250;
 
 
#endif
 
const long GEOSRID = 4326;
 
const long GEOCRS_ID = 3452;
 
const long GEO_EPSG_CRS_ID = 4326;
 
const int USER_CRS_START_ID = 100000;
 
//
// Constants for point symbols
//
 
const double DEFAULT_POINT_SIZE = 2.0;
const double DEFAULT_LINE_WIDTH = 0.26;
 
const double DEFAULT_SEGMENT_EPSILON = 1e-8;
 
typedef QMap<QString, QString> QgsStringMap SIP_SKIP;
 
typedef unsigned long long qgssize;
 
#ifndef SIP_RUN
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
 
#define Q_NOWARN_DEPRECATED_PUSH \
  _Pragma("GCC diagnostic push") \
  _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"");
#define Q_NOWARN_DEPRECATED_POP \
  _Pragma("GCC diagnostic pop");
#define Q_NOWARN_UNREACHABLE_PUSH
#define Q_NOWARN_UNREACHABLE_POP
 
#elif defined(_MSC_VER)
 
#define Q_NOWARN_DEPRECATED_PUSH \
  __pragma(warning(push)) \
  __pragma(warning(disable:4996))
#define Q_NOWARN_DEPRECATED_POP \
  __pragma(warning(pop))
#define Q_NOWARN_UNREACHABLE_PUSH \
  __pragma(warning(push)) \
  __pragma(warning(disable:4702))
#define Q_NOWARN_UNREACHABLE_POP \
  __pragma(warning(pop))
 
#else
 
#define Q_NOWARN_DEPRECATED_PUSH
#define Q_NOWARN_DEPRECATED_POP
#define Q_NOWARN_UNREACHABLE_PUSH
#define Q_NOWARN_UNREACHABLE_POP
 
#endif
#endif
 
#ifndef QGISEXTERN
#ifdef Q_OS_WIN
#  define QGISEXTERN extern "C" __declspec( dllexport )
#else
#  if defined(__GNUC__) || defined(__clang__)
#    define QGISEXTERN extern "C" __attribute__ ((visibility ("default")))
#  else
#    define QGISEXTERN extern "C"
#  endif
#endif
#endif
#endif
 
// see https://infektor.net/posts/2017-01-19-using-cpp17-attributes-today.html#using-the-nodiscard-attribute
#if __cplusplus >= 201703L
#define NODISCARD [[nodiscard]]
#elif defined(__clang__)
#define NODISCARD [[nodiscard]]
#elif defined(_MSC_VER)
#define NODISCARD // no support
#elif defined(__has_cpp_attribute)
#if __has_cpp_attribute(nodiscard)
#define NODISCARD [[nodiscard]]
#elif __has_cpp_attribute(gnu::warn_unused_result)
#define NODISCARD [[gnu::warn_unused_result]]
#else
#define NODISCARD Q_REQUIRED_RESULT
#endif
#else
#define NODISCARD Q_REQUIRED_RESULT
#endif
 
#if __cplusplus >= 201703L
#define MAYBE_UNUSED [[maybe_unused]]
#elif defined(__clang__)
#define MAYBE_UNUSED [[maybe_unused]]
#elif defined(_MSC_VER)
#define MAYBE_UNUSED // no support
#elif defined(__has_cpp_attribute)
#if __has_cpp_attribute(gnu::unused)
#define MAYBE_UNUSED [[gnu::unused]]
#else
#define MAYBE_UNUSED
#endif
#else
#define MAYBE_UNUSED
#endif
 
#ifndef FINAL
#define FINAL final
#endif
 
#ifndef SIP_RUN
#ifdef _MSC_VER
#define BUILTIN_UNREACHABLE \
  __assume(false);
#elif defined(__GNUC__) && !defined(__clang__)
// Workaround a GCC bug where a -Wreturn-type warning is emitted in constructs
// like:
// switch( mVariableThatCanOnlyBeXorY )
// {
//    case X:
//        return "foo";
//    case Y:
//        return "foo";
// }
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=87951
#define BUILTIN_UNREACHABLE \
  __builtin_unreachable();
#else
#define BUILTIN_UNREACHABLE
#endif
#endif // SIP_RUN
 
#ifdef SIP_RUN
 
QString CORE_EXPORT geoWkt();
 
QString CORE_EXPORT geoProj4();
 
QString CORE_EXPORT geoEpsgCrsAuthId();
 
QString CORE_EXPORT geoNone();
 
#endif