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 "qgstolerance.h"
#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 ), 
    };
    Q_ENUM( LayerType )
 
    
    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
    {
      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 FeatureCountState SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsVectorDataProvider, FeatureCountState ) : int
      {
      Uncounted = -2, 
      UnknownCount = -1, 
    };
    Q_ENUM( FeatureCountState )
 
    
    enum class VectorDataProviderAttributeEditCapability
    {
      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
    {
      NamedListSelectedItemSetting = 1 << 0, 
    };
 
    Q_ENUM( SettingsTreeNodeOption )
    Q_DECLARE_FLAGS( SettingsTreeNodeOptions, SettingsTreeNodeOption )
    Q_FLAG( SettingsTreeNodeOptions )
 
    
    enum class SldExportOption : int
    {
      NoOptions = 0,                      
      Svg = 1 << 0,                       
      Png = 1 << 1,                       
    };
    Q_ENUM( SldExportOption )
    Q_DECLARE_FLAGS( SldExportOptions, SldExportOption )
    Q_FLAG( SldExportOptions )
 
    
    enum class SldExportVendorExtension : int
    {
      NoVendorExtension = 0,             
      GeoServerVendorExtension = 1 << 1, 
      DeegreeVendorExtension = 1 << 2,   
    };
    Q_ENUM( SldExportVendorExtension )
 
 
    
    enum class SettingsOption : int
    {
      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
      {
      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
      {
      DynamicRotation = 2, 
    };
    Q_ENUM( SymbolRenderHint )
    Q_DECLARE_FLAGS( SymbolRenderHints, SymbolRenderHint ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, RenderHints )
    Q_FLAG( SymbolRenderHints )
 
    enum class SymbolFlag : int
    {
      RendererShouldUseSymbolLevels = 1 << 0, 
    };
    Q_ENUM( SymbolFlag )
    Q_DECLARE_FLAGS( SymbolFlags, SymbolFlag )
    Q_FLAG( SymbolFlags )
 
    
    enum class SymbolPreviewFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsSymbol, PreviewFlag ) : int
      {
      FlagIncludeCrosshairsForMarkerSymbols = 1 << 0, 
    };
    Q_ENUM( SymbolPreviewFlag )
    Q_DECLARE_FLAGS( SymbolPreviewFlags, SymbolPreviewFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsSymbol, SymbolPreviewFlags )
    Q_FLAG( SymbolPreviewFlags )
 
    enum class SymbolLayerFlag : int
    {
      DisableFeatureClipping = 1 << 0, 
    };
    Q_ENUM( SymbolLayerFlag )
    Q_DECLARE_FLAGS( SymbolLayerFlags, SymbolLayerFlag )
    Q_FLAG( SymbolLayerFlags )
 
    
    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
      {
      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, 
    };
    Q_ENUM( BrowserItemCapability )
    Q_DECLARE_FLAGS( BrowserItemCapabilities, BrowserItemCapability ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsDataItem, Capabilities )
    Q_FLAG( BrowserItemCapabilities )
 
    enum class BrowserLayerType SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsLayerItem, LayerType ) : int
      {
      NoType, 
      Vector, 
      Raster, 
      Point, 
      Line, 
      Polygon, 
      TableLayer, 
      Database, 
      Table, 
      Plugin, 
      Mesh, 
      VectorTile, 
      PointCloud 
    };
    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
    {
      FieldAliases = 1 << 0, 
      FieldComments = 1 << 2, 
    };
    Q_ENUM( VectorFileWriterCapability )
 
    
    Q_DECLARE_FLAGS( VectorFileWriterCapabilities, VectorFileWriterCapability )
    Q_FLAG( VectorFileWriterCapabilities )
 
    
    enum class SqlLayerDefinitionCapability : int
    {
      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, 
    };
    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 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, 
    };
    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
      {
      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
      {
      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, 
    };
    Q_ENUM( FileFilterType )
 
    
    enum class SublayerQueryFlag : int
    {
      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
    {
      SystemTable = 1 << 0, 
    };
    Q_DECLARE_FLAGS( SublayerFlags, SublayerFlag )
    Q_ENUM( SublayerFlag )
    Q_FLAG( SublayerFlags )
 
    
    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
    {
      InternalLayerOpacityHandling = 1 << 0, 
    };
 
    Q_DECLARE_FLAGS( RasterRendererFlags, RasterRendererFlag )
 
    Q_ENUM( RasterRendererFlag )
    Q_FLAG( RasterRendererFlags )
 
    
    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 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 FieldMetadataProperty : int
    {
      GeometryCrs = 0x1000, 
      GeometryWkbType = 0x1001, 
      CustomProperty = 0x100000, 
    };
    Q_ENUM( FieldMetadataProperty )
 
    
    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
    {
      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 GpsInformationComponent : int
    {
      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
    {
      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
    {
      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, 
    };
    Q_ENUM( GeometryOperationResult )
 
    
    enum class GeometryValidityFlag SIP_MONKEYPATCH_SCOPEENUM_UNNEST( QgsGeometry, ValidityFlag ) : int
      {
      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 MakeValidMethod : int
    {
      Linework = 0, 
      Structure = 1, 
    };
    Q_ENUM( MakeValidMethod )
 
    
    enum class SpatialFilterType : int
    {
      NoFilter, 
      BoundingBox, 
      DistanceWithin, 
    };
    Q_ENUM( SpatialFilterType )
 
    
    enum class FileOperationFlag : int
    {
      IncludeMetadataFile = 1 << 0, 
      IncludeStyleFile = 1 << 1, 
    };
    Q_DECLARE_FLAGS( FileOperationFlags, FileOperationFlag )
    Q_ENUM( FileOperationFlag )
    Q_FLAG( FileOperationFlags )
 
    
    enum class MapLayerProperty : int
    {
      UsersCannotToggleEditing = 1 << 0, 
      IsBasemapLayer = 1 << 1, 
    };
    Q_DECLARE_FLAGS( MapLayerProperties, MapLayerProperty )
    Q_ENUM( MapLayerProperty )
    Q_FLAG( MapLayerProperties )
 
    
    enum class DataProviderFlag : int
    {
      IsBasemapSource = 1 << 1, 
    };
    Q_DECLARE_FLAGS( DataProviderFlags, DataProviderFlag )
    Q_ENUM( DataProviderFlag )
    Q_FLAG( DataProviderFlags )
 
    
    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 AnnotationItemFlag : int
    {
      ScaleDependentBoundingBox = 1 << 0, 
    };
    Q_DECLARE_FLAGS( AnnotationItemFlags, AnnotationItemFlag )
    Q_ENUM( AnnotationItemFlag )
    Q_FLAG( AnnotationItemFlags )
 
    
    enum class AnnotationItemGuiFlag : int
    {
      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 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, 
    };
    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
    {
      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
    {
      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
      {
      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,  
    };
    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
      {
      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, 
    };
    Q_DECLARE_FLAGS( RenderContextFlags, RenderContextFlag ) SIP_MONKEYPATCH_FLAGS_UNNEST( QgsRenderContext, Flags )
    Q_ENUM( RenderContextFlag )
    Q_FLAG( RenderContextFlags )
 
    // 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
      {
      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 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
      {
      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 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
    {
      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, 
    };
    Q_ENUM( AngularDirection )
 
    
    enum class RendererUsage : int
    {
      View, 
      Export, 
      Unknown, 
    };
    Q_ENUM( RendererUsage )
 
    
    enum class ViewSyncModeFlag : int
    {
      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
    {
      LocalProfile = 1 << 0, 
//      Project = 1 << 1, //!< QGIS Project  (not yet implemented)
    };
    Q_ENUM( HistoryProviderBackend )
    Q_DECLARE_FLAGS( HistoryProviderBackends, HistoryProviderBackend )
    Q_FLAG( HistoryProviderBackends )
 
    
    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 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 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
    {
      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
    {
      ShowContextMenu = 1 << 0, 
    };
    Q_ENUM( PlotToolFlag )
    Q_DECLARE_FLAGS( PlotToolFlags, PlotToolFlag )
    Q_FLAG( PlotToolFlags )
 
    
    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
    {
      RespectsMaximumErrorMapUnit = 1 << 0, 
      RespectsDistanceRange = 1 << 1, 
      RespectsElevationRange = 1 << 2, 
    };
    Q_ENUM( ProfileGeneratorFlag )
    Q_DECLARE_FLAGS( ProfileGeneratorFlags, ProfileGeneratorFlag )
    Q_FLAG( ProfileGeneratorFlags )
 
    
    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
      {
      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
    {
      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
    {
      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
    {
      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
    {
      SkipVisibilityCheck = 1 << 0, 
    };
    Q_ENUM( LayerTreeFilterFlag )
 
    
    Q_DECLARE_FLAGS( LayerTreeFilterFlags, LayerTreeFilterFlag )
    Q_FLAG( LayerTreeFilterFlags )
 
    
    enum class ActionType : int
    {
      Invalid, 
      MapLayerAction, 
      AttributeAction 
    };
    Q_ENUM( ActionType )
 
    
    enum class MapLayerActionTarget : int
    {
      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
    {
      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
      {
      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 )
 
    
    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 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 PostgresRelKind
    {
      NotSet, 
      Unknown, 
      OrdinaryTable, 
      Index, 
      Sequence, 
      View, 
      MaterializedView, 
      CompositeType, 
      ToastTable, 
      ForeignTable, 
      PartitionedTable, 
    };
    Q_ENUM( PostgresRelKind )
 
    
    enum class DatabaseProviderConnectionCapability2 : int
    {
      SetFieldComment = 1 << 0, 
      SetFieldAlias = 1 << 1, 
    };
    Q_ENUM( DatabaseProviderConnectionCapability2 )
    Q_DECLARE_FLAGS( DatabaseProviderConnectionCapabilities2, DatabaseProviderConnectionCapability2 )
    Q_FLAG( DatabaseProviderConnectionCapabilities2 )
 
    
    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, 
    };
    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
    {
      AlwaysUseTileMatrixSetFromProvider = 1 << 1, 
    };
    Q_ENUM( VectorTileProviderFlag )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderFlags, VectorTileProviderFlag )
    Q_FLAG( VectorTileProviderFlags )
 
    
    enum class VectorTileProviderCapability : int
    {
      ReadLayerMetadata = 1 << 1, 
    };
    Q_ENUM( VectorTileProviderCapability )
 
    
    Q_DECLARE_FLAGS( VectorTileProviderCapabilities, VectorTileProviderCapability )
    Q_FLAG( VectorTileProviderCapabilities )
 
    
    enum class TileAvailability
    {
      Available, 
      NotAvailable, 
      AvailableNoChildren, 
      UseLowerZoomLevelTile, 
    };
    Q_ENUM( TileAvailability )
 
    
    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 QgsTolerance::UnitType 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::SymbolRenderHints )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolPreviewFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SymbolLayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BrowserItemCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerQueryFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SublayerFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SqlLayerDefinitionCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelFormatCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::BabelCommandFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GeometryValidityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::FileOperationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::AnnotationItemGuiFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapSettingsFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RenderContextFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorLayerTypeFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MarkerLinePlacements )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::TextRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::HistoryProviderBackends )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerProperties )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DataProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorDataProviderAttributeEditCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SnappingTypes )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::PlotToolFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProfileGeneratorFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectReadFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ProjectCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::CoordinateTransformationFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterTemporalCapabilityFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SelectionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RasterRendererFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelingFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::GpsInformationComponents )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionTargets )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::MapLayerActionFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::RelationshipCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::SettingsTreeNodeOptions )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::ScriptLanguageCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LayerTreeFilterFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelLinePlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::LabelPolygonPlacementFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::DatabaseProviderConnectionCapabilities2 )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorFileWriterCapabilities )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorTileProviderFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Qgis::VectorTileProviderCapabilities )
 
// 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;
}
 
inline bool qgsDoubleNear( double a, double b, double epsilon = 4 * std::numeric_limits<double>::epsilon() )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  const double diff = a - b;
  return diff > -epsilon && diff <= epsilon;
}
 
inline bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON )
{
  const bool aIsNan = std::isnan( a );
  const bool bIsNan = std::isnan( b );
  if ( aIsNan || bIsNan )
    return aIsNan && bIsNan;
 
  const float diff = a - b;
  return diff > -epsilon && diff <= 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
{
  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
 
#if __cplusplus >= 201500
#define FALLTHROUGH [[fallthrough]];
#elif defined(__clang__)
#define FALLTHROUGH [[clang::fallthrough]];
#elif defined(__GNUC__) && __GNUC__ >= 7
#define FALLTHROUGH [[gnu::fallthrough]];
#else
#define FALLTHROUGH
#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