qgsprocessingparameters.h

Go to the documentation of this file.

/***************************************************************************
                      qgsprocessingparameters.h
                      -------------------------
 begin                : April 2017
 copyright            : (C) 2017 by Nyall Dawson
 email                : nyall dot dawson at gmail dot 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 QGSPROCESSINGPARAMETERS_H
#define QGSPROCESSINGPARAMETERS_H
 
#include <limits>
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsfilefiltergenerator.h"
#include "qgsprocessing.h"
#include "qgsprocessingutils.h"
#include "qgsproperty.h"
#include "qgsremappingproxyfeaturesink.h"
 
#include <QColor>
#include <QMap>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsProcessingContext;
class QgsProcessingAlgorithm;
class QgsRasterLayer;
class QgsMeshLayer;
class QgsVectorLayer;
class QgsFeatureSink;
class QgsProcessingFeatureSource;
class QgsProcessingOutputDefinition;
class QgsProcessingFeedback;
class QgsProcessingProvider;
class QgsPrintLayout;
class QgsLayoutItem;
class QgsPointCloudLayer;
class QgsAnnotationLayer;

 
class CORE_EXPORT QgsProcessingFeatureSourceDefinition
{
  public:
    QgsProcessingFeatureSourceDefinition(
      const QString &source = QString(),
      bool selectedFeaturesOnly = false,
      long long featureLimit = -1,
      Qgis::ProcessingFeatureSourceDefinitionFlags flags = Qgis::ProcessingFeatureSourceDefinitionFlags(),
      Qgis::InvalidGeometryCheck geometryCheck = Qgis::InvalidGeometryCheck::AbortOnInvalid,
      const QString &filterExpression = QString()
    )
      : source( QgsProperty::fromValue( source ) )
      , selectedFeaturesOnly( selectedFeaturesOnly )
      , featureLimit( featureLimit )
      , filterExpression( filterExpression )
      , flags( flags )
      , geometryCheck( geometryCheck )
    {}

    QgsProcessingFeatureSourceDefinition(
      const QgsProperty &source,
      bool selectedFeaturesOnly = false,
      long long featureLimit = -1,
      Qgis::ProcessingFeatureSourceDefinitionFlags flags = Qgis::ProcessingFeatureSourceDefinitionFlags(),
      Qgis::InvalidGeometryCheck geometryCheck = Qgis::InvalidGeometryCheck::AbortOnInvalid,
      const QString &filterExpression = QString()
    )
      : source( source )
      , selectedFeaturesOnly( selectedFeaturesOnly )
      , featureLimit( featureLimit )
      , filterExpression( filterExpression )
      , flags( flags )
      , geometryCheck( geometryCheck )
    {}

    QgsProperty source;

    bool selectedFeaturesOnly;

    long long featureLimit = -1;

    QString filterExpression;

    Qgis::ProcessingFeatureSourceDefinitionFlags flags;

    Qgis::InvalidGeometryCheck geometryCheck = Qgis::InvalidGeometryCheck::AbortOnInvalid;

    QVariant toVariant() const;

    bool loadVariant( const QVariantMap &map );
 
    // TODO c++20 - replace with = default
    bool operator==( const QgsProcessingFeatureSourceDefinition &other ) const
    {
      return source == other.source
             && selectedFeaturesOnly == other.selectedFeaturesOnly
             && featureLimit == other.featureLimit
             && filterExpression == other.filterExpression
             && flags == other.flags
             && geometryCheck == other.geometryCheck;
    }
 
    bool operator!=( const QgsProcessingFeatureSourceDefinition &other ) const { return !( *this == other ); }

    operator QVariant() const { return QVariant::fromValue( *this ); }
};
 
Q_DECLARE_METATYPE( QgsProcessingFeatureSourceDefinition )
 

 
class CORE_EXPORT QgsProcessingRasterLayerDefinition
{
  public:
    QgsProcessingRasterLayerDefinition( const QString &source = QString(), const double referenceScale = 0, const int dpi = 96 )
      : source( QgsProperty::fromValue( source ) )
      , referenceScale( referenceScale )
      , dpi( dpi )
    {}

    QgsProcessingRasterLayerDefinition( const QgsProperty &source, const double referenceScale = 0, const int dpi = 96 )
      : source( source )
      , referenceScale( referenceScale )
      , dpi( dpi )
    {}

    QgsProperty source;

    double referenceScale = 0;

    int dpi = 96;

    QVariant toVariant() const;

    bool loadVariant( const QVariantMap &map );
 
    // TODO c++20 - replace with = default
    bool operator==( const QgsProcessingRasterLayerDefinition &other ) const { return source == other.source && referenceScale == other.referenceScale && dpi == other.dpi; }
 
    bool operator!=( const QgsProcessingRasterLayerDefinition &other ) const { return !( *this == other ); }

    operator QVariant() const { return QVariant::fromValue( *this ); }
};
 
Q_DECLARE_METATYPE( QgsProcessingRasterLayerDefinition )
 

 
class CORE_EXPORT QgsProcessingOutputLayerDefinition
{
  public:
    QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = nullptr )
      : sink( QgsProperty::fromValue( sink ) )
      , destinationProject( destinationProject )
    {}

    QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = nullptr )
      : sink( sink )
      , destinationProject( destinationProject )
    {}

    QgsProperty sink;

    QgsProject *destinationProject = nullptr;

    QString destinationName;

    QVariantMap createOptions;

    bool useRemapping() const { return mUseRemapping; }

    QgsRemappingSinkDefinition remappingDefinition() const { return mRemappingDefinition; }

    void setRemappingDefinition( const QgsRemappingSinkDefinition &definition );

    QString format() const { return mFormat; }

    void setFormat( const QString &format ) { mFormat = format; }

    QVariant toVariant() const;

    bool loadVariant( const QVariantMap &map );

    operator QVariant() const { return QVariant::fromValue( *this ); }
 
    // TODO c++20 - replace with = default
    bool operator==( const QgsProcessingOutputLayerDefinition &other ) const;
    bool operator!=( const QgsProcessingOutputLayerDefinition &other ) const;
 
  private:
    bool mUseRemapping = false;
    QgsRemappingSinkDefinition mRemappingDefinition = QgsRemappingSinkDefinition();
    QString mFormat;
};
 
Q_DECLARE_METATYPE( QgsProcessingOutputLayerDefinition )
 
 
//
// Parameter definitions
//
 

 
class CORE_EXPORT QgsProcessingParameterDefinition
{
#ifdef SIP_RUN
    // clang-format off
    % TypeHeaderCode
#include "qgsprocessingparameteraggregate.h"
#include "qgsprocessingparameterdxflayers.h"
#include "qgsprocessingparameterfieldmap.h"
#include "qgsprocessingparametertininputlayers.h"
#include "qgsprocessingparametervectortilewriterlayers.h"
#include "qgsprocessingparametermeshdataset.h"
#include "qgsprocessingparameterinterpolationpixelsize.h"
    % End
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == QgsProcessingParameterBoolean::typeName() )
      sipType = sipType_QgsProcessingParameterBoolean;
    else if ( sipCpp->type() == QgsProcessingParameterCrs::typeName() )
      sipType = sipType_QgsProcessingParameterCrs;
    else if ( sipCpp->type() == QgsProcessingParameterMapLayer::typeName() )
      sipType = sipType_QgsProcessingParameterMapLayer;
    else if ( sipCpp->type() == QgsProcessingParameterExtent::typeName() )
      sipType = sipType_QgsProcessingParameterExtent;
    else if ( sipCpp->type() == QgsProcessingParameterPoint::typeName() )
      sipType = sipType_QgsProcessingParameterPoint;
    else if ( sipCpp->type() == QgsProcessingParameterGeometry::typeName() )
      sipType = sipType_QgsProcessingParameterGeometry;
    else if ( sipCpp->type() == QgsProcessingParameterFile::typeName() )
      sipType = sipType_QgsProcessingParameterFile;
    else if ( sipCpp->type() == QgsProcessingParameterMatrix::typeName() )
      sipType = sipType_QgsProcessingParameterMatrix;
    else if ( sipCpp->type() == QgsProcessingParameterMultipleLayers::typeName() )
      sipType = sipType_QgsProcessingParameterMultipleLayers;
    else if ( sipCpp->type() == QgsProcessingParameterNumber::typeName() )
      sipType = sipType_QgsProcessingParameterNumber;
    else if ( sipCpp->type() == QgsProcessingParameterDistance::typeName() )
      sipType = sipType_QgsProcessingParameterDistance;
    else if ( sipCpp->type() == QgsProcessingParameterArea::typeName() )
      sipType = sipType_QgsProcessingParameterArea;
    else if ( sipCpp->type() == QgsProcessingParameterVolume::typeName() )
      sipType = sipType_QgsProcessingParameterVolume;
    else if ( sipCpp->type() == QgsProcessingParameterDuration::typeName() )
      sipType = sipType_QgsProcessingParameterDuration;
    else if ( sipCpp->type() == QgsProcessingParameterScale::typeName() )
      sipType = sipType_QgsProcessingParameterScale;
    else if ( sipCpp->type() == QgsProcessingParameterRange::typeName() )
      sipType = sipType_QgsProcessingParameterRange;
    else if ( sipCpp->type() == QgsProcessingParameterRasterLayer::typeName() )
      sipType = sipType_QgsProcessingParameterRasterLayer;
    else if ( sipCpp->type() == QgsProcessingParameterMeshLayer::typeName() )
      sipType = sipType_QgsProcessingParameterMeshLayer;
    else if ( sipCpp->type() == QgsProcessingParameterEnum::typeName() )
      sipType = sipType_QgsProcessingParameterEnum;
    else if ( sipCpp->type() == QgsProcessingParameterString::typeName() )
      sipType = sipType_QgsProcessingParameterString;
    else if ( sipCpp->type() == QgsProcessingParameterExpression::typeName() )
      sipType = sipType_QgsProcessingParameterExpression;
    else if ( sipCpp->type() == QgsProcessingParameterAuthConfig::typeName() )
      sipType = sipType_QgsProcessingParameterAuthConfig;
    else if ( sipCpp->type() == QgsProcessingParameterVectorLayer::typeName() )
      sipType = sipType_QgsProcessingParameterVectorLayer;
    else if ( sipCpp->type() == QgsProcessingParameterField::typeName() )
      sipType = sipType_QgsProcessingParameterField;
    else if ( sipCpp->type() == QgsProcessingParameterFeatureSource::typeName() )
      sipType = sipType_QgsProcessingParameterFeatureSource;
    else if ( sipCpp->type() == QgsProcessingParameterFeatureSink::typeName() )
      sipType = sipType_QgsProcessingParameterFeatureSink;
    else if ( sipCpp->type() == QgsProcessingParameterVectorDestination::typeName() )
      sipType = sipType_QgsProcessingParameterVectorDestination;
    else if ( sipCpp->type() == QgsProcessingParameterRasterDestination::typeName() )
      sipType = sipType_QgsProcessingParameterRasterDestination;
    else if ( sipCpp->type() == QgsProcessingParameterPointCloudDestination::typeName() )
      sipType = sipType_QgsProcessingParameterPointCloudDestination;
    else if ( sipCpp->type() == QgsProcessingParameterFileDestination::typeName() )
      sipType = sipType_QgsProcessingParameterFileDestination;
    else if ( sipCpp->type() == QgsProcessingParameterFolderDestination::typeName() )
      sipType = sipType_QgsProcessingParameterFolderDestination;
    else if ( sipCpp->type() == QgsProcessingParameterBand::typeName() )
      sipType = sipType_QgsProcessingParameterBand;
    else if ( sipCpp->type() == QgsProcessingParameterLayout::typeName() )
      sipType = sipType_QgsProcessingParameterLayout;
    else if ( sipCpp->type() == QgsProcessingParameterLayoutItem::typeName() )
      sipType = sipType_QgsProcessingParameterLayoutItem;
    else if ( sipCpp->type() == QgsProcessingParameterColor::typeName() )
      sipType = sipType_QgsProcessingParameterColor;
    else if ( sipCpp->type() == QgsProcessingParameterCoordinateOperation::typeName() )
      sipType = sipType_QgsProcessingParameterCoordinateOperation;
    else if ( sipCpp->type() == QgsProcessingParameterMapTheme::typeName() )
      sipType = sipType_QgsProcessingParameterMapTheme;
    else if ( sipCpp->type() == QgsProcessingParameterDateTime::typeName() )
      sipType = sipType_QgsProcessingParameterDateTime;
    else if ( sipCpp->type() == QgsProcessingParameterProviderConnection::typeName() )
      sipType = sipType_QgsProcessingParameterProviderConnection;
    else if ( sipCpp->type() == QgsProcessingParameterDatabaseSchema::typeName() )
      sipType = sipType_QgsProcessingParameterDatabaseSchema;
    else if ( sipCpp->type() == QgsProcessingParameterDatabaseTable::typeName() )
      sipType = sipType_QgsProcessingParameterDatabaseTable;
    else if ( sipCpp->type() == QgsProcessingParameterFieldMapping::typeName() )
      sipType = sipType_QgsProcessingParameterFieldMapping;
    else if ( sipCpp->type() == QgsProcessingParameterTinInputLayers::typeName() )
      sipType = sipType_QgsProcessingParameterTinInputLayers;
    else if ( sipCpp->type() == QgsProcessingParameterVectorTileWriterLayers::typeName() )
      sipType = sipType_QgsProcessingParameterVectorTileWriterLayers;
    else if ( sipCpp->type() == QgsProcessingParameterDxfLayers::typeName() )
      sipType = sipType_QgsProcessingParameterDxfLayers;
    else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetGroups::typeName() )
      sipType = sipType_QgsProcessingParameterMeshDatasetGroups;
    else if ( sipCpp->type() == QgsProcessingParameterMeshDatasetTime::typeName() )
      sipType = sipType_QgsProcessingParameterMeshDatasetTime;
    else if ( sipCpp->type() == QgsProcessingParameterPointCloudLayer::typeName() )
      sipType = sipType_QgsProcessingParameterPointCloudLayer;
    else if ( sipCpp->type() == QgsProcessingParameterAnnotationLayer::typeName() )
      sipType = sipType_QgsProcessingParameterAnnotationLayer;
    else if ( sipCpp->type() == QgsProcessingParameterPointCloudAttribute::typeName() )
      sipType = sipType_QgsProcessingParameterPointCloudAttribute;
    else if ( sipCpp->type() == QgsProcessingParameterVectorTileDestination::typeName() )
      sipType = sipType_QgsProcessingParameterVectorTileDestination;
    else if ( sipCpp->type() == QgsProcessingParameterInterpolationPixelSize::typeName() )
      sipType = sipType_QgsProcessingParameterInterpolationPixelSize;
    else
      sipType = nullptr;
    SIP_END
// clang-format on
#endif
 
  public:

    QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QString &help = QString() );
 
    virtual ~QgsProcessingParameterDefinition() = default;

    virtual QColor modelColor() const;

    virtual QString userFriendlyString( const QVariant &value ) const;

    virtual QgsProcessingParameterDefinition *clone() const = 0 SIP_FACTORY;

    virtual QString type() const = 0;

    virtual bool isDestination() const { return false; }

    QString name() const { return mName; }

    void setName( const QString &name ) { mName = name; }

    QString description() const { return mDescription; }

    void setDescription( const QString &description ) { mDescription = description; }

    QString help() const { return mHelp; }

    void setHelp( const QString &help ) { mHelp = help; }

    QVariant defaultValue() const { return mDefault; }

    void setDefaultValue( const QVariant &value ) { mDefault = value; }

    QVariant guiDefaultValueOverride() const;

    void setGuiDefaultValueOverride( const QVariant &value ) { mGuiDefault = value; }

    QVariant defaultValueForGui() const;

    Qgis::ProcessingParameterFlags flags() const { return mFlags; }

    void setFlags( Qgis::ProcessingParameterFlags flags ) { mFlags = flags; }

    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const;

    virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;

    virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;

    virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const;

    virtual QStringList valueAsStringList( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const;

    virtual QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const;

    virtual QString asScriptCode() const;

    virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const;

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );

    SIP_SKIP QVariantMap metadata() const { return mMetadata; }

    QVariantMap &metadata() { return mMetadata; }

    void setMetadata( const QVariantMap &metadata ) { mMetadata = metadata; }

    virtual QStringList dependsOnOtherParameters() const { return QStringList(); }

    QgsProcessingAlgorithm *algorithm() const;

    QgsProcessingProvider *provider() const;

    virtual QString toolTip() const;

    bool isDynamic() const { return mIsDynamic; }

    void setIsDynamic( bool dynamic ) { mIsDynamic = dynamic; }

    QgsPropertyDefinition dynamicPropertyDefinition() const { return mPropertyDefinition; }

    void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition ) { mPropertyDefinition = definition; }

    QString dynamicLayerParameterName() const { return mDynamicLayerParameterName; }

    void setDynamicLayerParameterName( const QString &name ) { mDynamicLayerParameterName = name; }

    QStringList additionalExpressionContextVariables() const { return mAdditionalExpressionVariables; }

    void setAdditionalExpressionContextVariables( const QStringList &variables ) { mAdditionalExpressionVariables = variables; }
 
#ifndef SIP_RUN

    enum class ValueAsStringFlag : int
    {
      AllowMapLayerValues = 1 << 0, 
    };
    Q_DECLARE_FLAGS( ValueAsStringFlags, ValueAsStringFlag )
#endif
 
  protected:
#ifndef SIP_RUN

    QString valueAsStringPrivate( const QVariant &value, QgsProcessingContext &context, bool &ok, ValueAsStringFlags flags ) const;

    QVariant valueAsJsonObjectPrivate( const QVariant &value, QgsProcessingContext &context, ValueAsStringFlags flags ) const;
#endif

    QVariant defaultGuiValueFromSetting() const;

    QString mName;

    QString mDescription;

    QString mHelp;

    QVariant mDefault;

    QVariant mGuiDefault;

    Qgis::ProcessingParameterFlags mFlags;

    QVariantMap mMetadata;

    QgsProcessingAlgorithm *mAlgorithm = nullptr;

    bool mIsDynamic = false;

    QgsPropertyDefinition mPropertyDefinition;

    QString mDynamicLayerParameterName;

    QStringList mAdditionalExpressionVariables;
 
    // To allow access to mAlgorithm. We don't want a public setter for this!
    friend class QgsProcessingAlgorithm;
};
 
#ifndef SIP_RUN
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingParameterDefinition::ValueAsStringFlags )
#endif

typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;

 
class CORE_EXPORT QgsProcessingParameters
{
  public:
    static bool isDynamic( const QVariantMap &parameters, const QString &name );

    static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QgsFeatureSink *parameterAsSink(
      const QgsProcessingParameterDefinition *definition,
      const QVariantMap &parameters,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      const QgsCoordinateReferenceSystem &crs,
      QgsProcessingContext &context,
      QString &destinationIdentifier SIP_OUT,
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
      const QVariantMap &createOptions = QVariantMap(),
      const QStringList &datasourceOptions = QStringList(),
      const QStringList &layerOptions = QStringList()
    ) SIP_FACTORY;

    static QgsFeatureSink *parameterAsSink(
      const QgsProcessingParameterDefinition *definition,
      const QVariant &value,
      const QgsFields &fields,
      Qgis::WkbType geometryType,
      const QgsCoordinateReferenceSystem &crs,
      QgsProcessingContext &context,
      QString &destinationIdentifier SIP_OUT,
      QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(),
      const QVariantMap &createOptions = QVariantMap(),
      const QStringList &datasourceOptions = QStringList(),
      const QStringList &layerOptions = QStringList()
    ) SIP_THROW( QgsProcessingException ) SIP_FACTORY;

    static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) SIP_FACTORY;

    static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) SIP_FACTORY;

    static QString parameterAsCompatibleSourceLayerPath(
      const QgsProcessingParameterDefinition *definition,
      const QVariantMap &parameters,
      QgsProcessingContext &context,
      const QStringList &compatibleFormats,
      const QString &preferredFormat = QString( "shp" ),
      QgsProcessingFeedback *feedback = nullptr
    );

    static QString parameterAsCompatibleSourceLayerPathAndLayerName(
      const QgsProcessingParameterDefinition *definition,
      const QVariantMap &parameters,
      QgsProcessingContext &context,
      const QStringList &compatibleFormats,
      const QString &preferredFormat = QString( "shp" ),
      QgsProcessingFeedback *feedback = nullptr,
      QString *layerName SIP_OUT = nullptr
    );

    static QgsMapLayer *parameterAsLayer(
      const QgsProcessingParameterDefinition *definition,
      const QVariantMap &parameters,
      QgsProcessingContext &context,
      QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType,
      QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QgsMapLayer *parameterAsLayer(
      const QgsProcessingParameterDefinition *definition,
      const QVariant &value,
      QgsProcessingContext &context,
      QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType,
      QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, bool testOnly = false );

    static QString parameterAsOutputFormat( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsRectangle parameterAsExtent(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsRectangle parameterAsExtent(
      const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsGeometry parameterAsExtentGeometry(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
 

    static QgsPointXY parameterAsPoint(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsPointXY parameterAsPoint(
      const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsGeometry parameterAsGeometry(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsGeometry parameterAsGeometry(
      const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem()
    );

    static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QList< QgsMapLayer *> parameterAsLayerList(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QList< QgsMapLayer *> parameterAsLayerList(
      const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    Q_DECL_DEPRECATED static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) SIP_DEPRECATED;

    Q_DECL_DEPRECATED static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) SIP_DEPRECATED;

    static QStringList parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QStringList parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsPrintLayout *layout );

    static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout );

    static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );

    static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );

    static QgsPointCloudLayer *parameterAsPointCloudLayer(
      const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QgsPointCloudLayer *parameterAsPointCloudLayer(
      const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags()
    );

    static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );

    static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );

    static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) SIP_FACTORY;

    static QString descriptionFromName( const QString &name );

    static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) SIP_FACTORY;
 
  private:
    static bool parseScriptCodeParameterOptions( const QString &code, bool &isOptional, QString &name, QString &type, QString &definition );
};
 

class CORE_EXPORT QgsProcessingParameterBoolean : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"boolean"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;

    static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterCrs : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );
 
    QString userFriendlyString( const QVariant &value ) const override;

    static QString typeName() { return u"crs"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;

    static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterExtent : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"extent"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;

    static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    static bool variantIsValidStringForExtent( const QVariant &value );
};
 

class CORE_EXPORT QgsProcessingParameterPoint : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"point"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;

    static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterGeometry : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterGeometry(
      const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QList< int > &geometryTypes = QList< int >(), bool allowMultipart = true
    );

    static QString typeName() { return u"geometry"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    QList<int> geometryTypes() const { return mGeomTypes; }

    void setGeometryTypes( const QList<int> &geometryTypes ) { mGeomTypes = geometryTypes; }

    bool allowMultipart() const { return mAllowMultipart; }

    void setAllowMultipart( bool allowMultipart ) { mAllowMultipart = allowMultipart; }
 
    QString userFriendlyString( const QVariant &value ) const override;

    static QgsProcessingParameterGeometry *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QList<int> mGeomTypes;
    bool mAllowMultipart;
};

class CORE_EXPORT QgsProcessingParameterFile : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterFile(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingFileParameterBehavior behavior = Qgis::ProcessingFileParameterBehavior::File,
      const QString &extension = QString(),
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      const QString &fileFilter = QString()
    );

    static QString typeName() { return u"file"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    Qgis::ProcessingFileParameterBehavior behavior() const { return mBehavior; }

    void setBehavior( Qgis::ProcessingFileParameterBehavior behavior ) { mBehavior = behavior; }

    QString extension() const { return mExtension; }

    void setExtension( const QString &extension );

    QString fileFilter() const;

    void setFileFilter( const QString &filter );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterFile *fromScriptCode(
      const QString &name, const QString &description, bool isOptional, const QString &definition, Qgis::ProcessingFileParameterBehavior behavior = Qgis::ProcessingFileParameterBehavior::File
    ) SIP_FACTORY;
 
  private:
    Qgis::ProcessingFileParameterBehavior mBehavior = Qgis::ProcessingFileParameterBehavior::File;
    QString mExtension;
    QString mFileFilter;
};

class CORE_EXPORT QgsProcessingParameterMatrix : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterMatrix(
      const QString &name,
      const QString &description = QString(),
      int numberRows = 3,
      bool hasFixedNumberRows = false,
      const QStringList &headers = QStringList(),
      const QVariant &defaultValue = QVariant(),
      bool optional = false
    );

    static QString typeName() { return u"matrix"_s; }
 
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QStringList headers() const;

    void setHeaders( const QStringList &headers );

    int numberRows() const;

    void setNumberRows( int rows );

    bool hasFixedNumberRows() const;

    void setHasFixedNumberRows( bool hasFixedNumberRows );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QStringList mHeaders;
    int mNumberRows = 3;
    bool mFixedNumberRows = false;
};

class CORE_EXPORT QgsProcessingParameterMultipleLayers : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterMultipleLayers(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingSourceType layerType = Qgis::ProcessingSourceType::VectorAnyGeometry,
      const QVariant &defaultValue = QVariant(),
      bool optional = false
    );

    static QString typeName() { return u"multilayer"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    Qgis::ProcessingSourceType layerType() const;

    void setLayerType( Qgis::ProcessingSourceType type );

    int minimumNumberInputs() const;

    void setMinimumNumberInputs( int minimum );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    Qgis::ProcessingSourceType mLayerType = Qgis::ProcessingSourceType::VectorAnyGeometry;
    int mMinimumNumberInputs = 0;
};

class CORE_EXPORT QgsProcessingParameterNumber : public QgsProcessingParameterDefinition
{
  public:
    explicit QgsProcessingParameterNumber(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingNumberParameterType type = Qgis::ProcessingNumberParameterType::Integer,
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      double minValue = std::numeric_limits<double>::lowest() + 1,
      double maxValue = std::numeric_limits<double>::max()
    );

    static QString typeName() { return u"number"_s; }
 
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString toolTip() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    double minimum() const;

    void setMinimum( double minimum );

    double maximum() const;

    void setMaximum( double maximum );

    Qgis::ProcessingNumberParameterType dataType() const;

    void setDataType( Qgis::ProcessingNumberParameterType type );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    double mMin = std::numeric_limits<double>::lowest() + 1;
    double mMax = std::numeric_limits<double>::max();
    Qgis::ProcessingNumberParameterType mDataType = Qgis::ProcessingNumberParameterType::Integer;
};

class CORE_EXPORT QgsProcessingParameterDistance : public QgsProcessingParameterNumber
{
  public:
    explicit QgsProcessingParameterDistance(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentParameterName = QString(),
      bool optional = false,
      double minValue = std::numeric_limits<double>::lowest() + 1,
      double maxValue = std::numeric_limits<double>::max()
    );

    static QString typeName() { return u"distance"_s; } // cppcheck-suppress duplInheritedMember
 
    QString userFriendlyString( const QVariant &value ) const override;
 
    QgsProcessingParameterDistance *clone() const override SIP_FACTORY;
 
    QString type() const override;
    QStringList dependsOnOtherParameters() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QString parentParameterName() const;

    void setParentParameterName( const QString &parentParameterName );

    Qgis::DistanceUnit defaultUnit() const { return mDefaultUnit; }

    void setDefaultUnit( Qgis::DistanceUnit unit ) { mDefaultUnit = unit; }
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
 
  private:
    QString mParentParameterName;
    Qgis::DistanceUnit mDefaultUnit = Qgis::DistanceUnit::Unknown;
};
 

class CORE_EXPORT QgsProcessingParameterArea : public QgsProcessingParameterNumber
{
  public:
    explicit QgsProcessingParameterArea(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentParameterName = QString(),
      bool optional = false,
      double minValue = 0,
      double maxValue = std::numeric_limits<double>::max()
    );

    static QString typeName() { return u"area"_s; } // cppcheck-suppress duplInheritedMember
 
    QgsProcessingParameterArea *clone() const override SIP_FACTORY;
 
    QString type() const override;
    QStringList dependsOnOtherParameters() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QString parentParameterName() const;

    void setParentParameterName( const QString &parentParameterName );

    Qgis::AreaUnit defaultUnit() const { return mDefaultUnit; }

    void setDefaultUnit( Qgis::AreaUnit unit ) { mDefaultUnit = unit; }
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString userFriendlyString( const QVariant &value ) const override;
 
  private:
    QString mParentParameterName;
    Qgis::AreaUnit mDefaultUnit = Qgis::AreaUnit::Unknown;
};
 

class CORE_EXPORT QgsProcessingParameterVolume : public QgsProcessingParameterNumber
{
  public:
    explicit QgsProcessingParameterVolume(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentParameterName = QString(),
      bool optional = false,
      double minValue = 0,
      double maxValue = std::numeric_limits<double>::max()
    );

    static QString typeName() { return u"volume"_s; } // cppcheck-suppress duplInheritedMember
 
    QgsProcessingParameterVolume *clone() const override SIP_FACTORY;
 
    QString type() const override;
    QStringList dependsOnOtherParameters() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QString parentParameterName() const;

    void setParentParameterName( const QString &parentParameterName );

    Qgis::VolumeUnit defaultUnit() const { return mDefaultUnit; }

    void setDefaultUnit( Qgis::VolumeUnit unit ) { mDefaultUnit = unit; }
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString userFriendlyString( const QVariant &value ) const override;
 
  private:
    QString mParentParameterName;
    Qgis::VolumeUnit mDefaultUnit = Qgis::VolumeUnit::Unknown;
};
 

class CORE_EXPORT QgsProcessingParameterDuration : public QgsProcessingParameterNumber
{
  public:
    explicit QgsProcessingParameterDuration(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      double minValue = std::numeric_limits<double>::lowest() + 1,
      double maxValue = std::numeric_limits<double>::max()
    );

    static QString typeName() { return u"duration"_s; } // cppcheck-suppress duplInheritedMember
 
    QgsProcessingParameterDuration *clone() const override SIP_FACTORY;
 
    QString type() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    Qgis::TemporalUnit defaultUnit() const { return mDefaultUnit; }

    void setDefaultUnit( Qgis::TemporalUnit unit ) { mDefaultUnit = unit; }
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString userFriendlyString( const QVariant &value ) const override;
 
  private:
    Qgis::TemporalUnit mDefaultUnit = Qgis::TemporalUnit::Milliseconds;
};

class CORE_EXPORT QgsProcessingParameterScale : public QgsProcessingParameterNumber
{
  public:
    explicit QgsProcessingParameterScale( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"scale"_s; } // cppcheck-suppress duplInheritedMember
 
    QgsProcessingParameterScale *clone() const override SIP_FACTORY;
 
    QString type() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    static QgsProcessingParameterScale *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember
};

class CORE_EXPORT QgsProcessingParameterRange : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterRange(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingNumberParameterType type = Qgis::ProcessingNumberParameterType::Integer,
      const QVariant &defaultValue = QVariant(),
      bool optional = false
    );

    static QString typeName() { return u"range"_s; }
 
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    Qgis::ProcessingNumberParameterType dataType() const;

    void setDataType( Qgis::ProcessingNumberParameterType dataType );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    Qgis::ProcessingNumberParameterType mDataType = Qgis::ProcessingNumberParameterType::Integer;
};

class CORE_EXPORT QgsProcessingParameterRasterLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"raster"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString createFileFilter() const override;

    static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

    void setParameterCapabilities( Qgis::RasterProcessingParameterCapabilities capabilities );

    Qgis::RasterProcessingParameterCapabilities parameterCapabilities() const;
 
  private:
    Qgis::RasterProcessingParameterCapabilities mCapabilities;
};

class CORE_EXPORT QgsProcessingParameterEnum : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterEnum(
      const QString &name,
      const QString &description = QString(),
      const QStringList &options = QStringList(),
      bool allowMultiple = false,
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      bool usesStaticStrings = false
    );
 
    QString userFriendlyString( const QVariant &value ) const override;

    static QString typeName() { return u"enum"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QStringList options() const;

    void setOptions( const QStringList &options );

    bool allowMultiple() const;

    void setAllowMultiple( bool allowMultiple );

    bool usesStaticStrings() const;

    void setUsesStaticStrings( bool usesStaticStrings );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QStringList mOptions;
    bool mAllowMultiple = false;
    bool mUsesStaticStrings = false;
};

class CORE_EXPORT QgsProcessingParameterString : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool multiLine = false, bool optional = false );

    static QString typeName() { return u"string"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    bool multiLine() const;

    void setMultiLine( bool multiLine );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    bool mMultiLine = false;
};
 

class CORE_EXPORT QgsProcessingParameterAuthConfig : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterAuthConfig( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"authcfg"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;

    static QgsProcessingParameterAuthConfig *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterExpression : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterExpression(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentLayerParameterName = QString(),
      bool optional = false,
      Qgis::ExpressionType type = Qgis::ExpressionType::Qgis
    );

    static QString typeName() { return u"expression"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QStringList dependsOnOtherParameters() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QString parentLayerParameterName() const;

    void setParentLayerParameterName( const QString &parentLayerParameterName );

    Qgis::ExpressionType expressionType() const;

    void setExpressionType( Qgis::ExpressionType type );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QString mParentLayerParameterName;
    Qgis::ExpressionType mExpressionType = Qgis::ExpressionType::Qgis;
};
 

class CORE_EXPORT QgsProcessingParameterLimitedDataTypes
{
  public:
    QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );

    QList< int > dataTypes() const;

    void setDataTypes( const QList< int > &types );
 
  protected:
    QList< int > mDataTypes;
};

class CORE_EXPORT QgsProcessingParameterVectorLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterVectorLayer(
      const QString &name, const QString &description = QString(), const QList< int > &types = QList< int >(), const QVariant &defaultValue = QVariant(), bool optional = false
    );

    static QString typeName() { return u"vector"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterMeshLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterMeshLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"mesh"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString createFileFilter() const override;

    static QgsProcessingParameterMeshLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterMapLayer : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterMapLayer(
      const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, const QList< int > &types = QList< int >()
    );

    static QString typeName() { return u"layer"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterField : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterField(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentLayerParameterName = QString(),
      Qgis::ProcessingFieldParameterDataType type = Qgis::ProcessingFieldParameterDataType::Any,
      bool allowMultiple = false,
      bool optional = false,
      bool defaultToAllFields = false
    );

    static QString typeName() { return u"field"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QStringList dependsOnOtherParameters() const override;

    QString parentLayerParameterName() const;

    void setParentLayerParameterName( const QString &parentLayerParameterName );

    Qgis::ProcessingFieldParameterDataType dataType() const;

    void setDataType( Qgis::ProcessingFieldParameterDataType type );

    bool allowMultiple() const;

    void setAllowMultiple( bool allowMultiple );

    bool defaultToAllFields() const;

    void setDefaultToAllFields( bool enabled );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QString mParentLayerParameterName;
    Qgis::ProcessingFieldParameterDataType mDataType = Qgis::ProcessingFieldParameterDataType::Any;
    bool mAllowMultiple = false;
    bool mDefaultToAllFields = false;
};
 

class CORE_EXPORT QgsProcessingParameterFeatureSource : public QgsProcessingParameterDefinition, public QgsProcessingParameterLimitedDataTypes, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterFeatureSource(
      const QString &name, const QString &description = QString(), const QList< int > &types = QList< int >(), const QVariant &defaultValue = QVariant(), bool optional = false
    );

    static QString typeName() { return u"source"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingDestinationParameter : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true );
 
    bool isDestination() const override { return true; }
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 SIP_FACTORY;

    bool supportsNonFileBasedOutput() const { return mSupportsNonFileBasedOutputs; }

    void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput ) { mSupportsNonFileBasedOutputs = supportsNonFileBasedOutput; }

    virtual QString defaultFileExtension() const = 0;

    virtual QString generateTemporaryDestination( const QgsProcessingContext *context = nullptr ) const;

    virtual bool isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error SIP_OUT ) const;

    bool createByDefault() const;

    void setCreateByDefault( bool createByDefault );
 
  protected:
    QgsProcessingProvider *originalProvider() const { return mOriginalProvider; }
 
  private:
    QgsProcessingProvider *mOriginalProvider = nullptr;
 
    bool mSupportsNonFileBasedOutputs = true;
    bool mCreateByDefault = true;
 
    friend class QgsProcessingModelAlgorithm;
    friend class TestQgsProcessing;
    friend class TestQgsProcessingModelAlgorithm;
};
 

class CORE_EXPORT QgsProcessingParameterFeatureSink : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterFeatureSink(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingSourceType type = Qgis::ProcessingSourceType::VectorAnyGeometry,
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      bool createByDefault = true,
      bool supportsAppend = false
    );

    static QString typeName() { return u"sink"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    virtual QStringList supportedOutputVectorLayerExtensions() const;

    Qgis::ProcessingSourceType dataType() const;

    bool hasGeometry() const;

    void setDataType( Qgis::ProcessingSourceType type );

    bool supportsAppend() const;

    void setSupportsAppend( bool supportsAppend );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString generateTemporaryDestination( const QgsProcessingContext *context = nullptr ) const override;

    static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    Qgis::ProcessingSourceType mDataType = Qgis::ProcessingSourceType::VectorAnyGeometry;
    bool mSupportsAppend = false;
};
 

class CORE_EXPORT QgsProcessingParameterVectorDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterVectorDestination(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingSourceType type = Qgis::ProcessingSourceType::VectorAnyGeometry,
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      bool createByDefault = true
    );

    static QString typeName() { return u"vectorDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    virtual QStringList supportedOutputVectorLayerExtensions() const;

    Qgis::ProcessingSourceType dataType() const;

    bool hasGeometry() const;

    void setDataType( Qgis::ProcessingSourceType type );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
 
  private:
    Qgis::ProcessingSourceType mDataType = Qgis::ProcessingSourceType::VectorAnyGeometry;
};

class CORE_EXPORT QgsProcessingParameterRasterDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true );

    static QString typeName() { return u"rasterDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;

    QString defaultFileFormat() const;
 
    QString createFileFilter() const override;

    Q_DECL_DEPRECATED virtual QStringList supportedOutputRasterLayerExtensions() const SIP_DEPRECATED;

    virtual QList<QPair<QString, QString>> supportedOutputRasterLayerFormatAndExtensions() const;

    static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterFileDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterFileDestination(
      const QString &name, const QString &description = QString(), const QString &fileFilter = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true
    );

    static QString typeName() { return u"fileDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QString createFileFilter() const override;

    QString fileFilter() const;

    void setFileFilter( const QString &filter );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
 
  private:
    QString mFileFilter;
};

class CORE_EXPORT QgsProcessingParameterFolderDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true );

    static QString typeName() { return u"folderDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;

    static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterBand : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterBand(
      const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), const QString &parentLayerParameterName = QString(), bool optional = false, bool allowMultiple = false
    );

    static QString typeName() { return u"band"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QStringList dependsOnOtherParameters() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QString parentLayerParameterName() const;

    void setParentLayerParameterName( const QString &parentLayerParameterName );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

    bool allowMultiple() const;

    void setAllowMultiple( bool allowMultiple );
 
  private:
    QString mParentLayerParameterName;
    bool mAllowMultiple = false;
};

class CORE_EXPORT QgsProcessingParameterLayout : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterLayout( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"layout"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    static QgsProcessingParameterLayout *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterLayoutItem : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterLayoutItem(
      const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), const QString &parentLayoutParameterName = QString(), int itemType = -1, bool optional = false
    );

    static QString typeName() { return u"layoutitem"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QStringList dependsOnOtherParameters() const override;

    static QgsProcessingParameterLayoutItem *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

    QString parentLayoutParameterName() const;

    void setParentLayoutParameterName( const QString &name );

    int itemType() const;

    void setItemType( int type );
 
  private:
    QString mParentLayoutParameterName;
    int mItemType = -1;
};

class CORE_EXPORT QgsProcessingParameterColor : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterColor( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool opacityEnabled = true, bool optional = false );

    static QString typeName() { return u"color"_s; }
 
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    bool opacityEnabled() const;

    void setOpacityEnabled( bool enabled );

    static QgsProcessingParameterColor *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    bool mAllowOpacity = true;
};
 

class CORE_EXPORT QgsProcessingParameterCoordinateOperation : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterCoordinateOperation(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &sourceCrsParameterName = QString(),
      const QString &destinationCrsParameterName = QString(),
      const QVariant &staticSourceCrs = QVariant(),
      const QVariant &staticDestinationCrs = QVariant(),
      bool optional = false
    );

    static QString typeName() { return u"coordinateoperation"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QStringList dependsOnOtherParameters() const override;
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterCoordinateOperation *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

    QString sourceCrsParameterName() const { return mSourceParameterName; }

    void setSourceCrsParameterName( const QString &name ) { mSourceParameterName = name; }

    QString destinationCrsParameterName() const { return mDestParameterName; }

    void setDestinationCrsParameterName( const QString &name ) { mDestParameterName = name; }

    QVariant sourceCrs() const { return mSourceCrs; }

    void setSourceCrs( const QVariant &crs ) { mSourceCrs = crs; }

    QVariant destinationCrs() const { return mDestCrs; }

    void setDestinationCrs( const QVariant &crs ) { mDestCrs = crs; }
 
  private:
    QString valueAsPythonStringPrivate( const QVariant &value, QgsProcessingContext &context, bool allowNonStringValues ) const;
 
    QString mSourceParameterName;
    QString mDestParameterName;
    QVariant mSourceCrs;
    QVariant mDestCrs;
};
 

class CORE_EXPORT QgsProcessingParameterMapTheme : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterMapTheme( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"maptheme"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterMapTheme *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
};
 

class CORE_EXPORT QgsProcessingParameterDateTime : public QgsProcessingParameterDefinition
{
  public:
    explicit QgsProcessingParameterDateTime(
      const QString &name,
      const QString &description = QString(),
      Qgis::ProcessingDateTimeParameterDataType type = Qgis::ProcessingDateTimeParameterDataType::DateTime,
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      const QDateTime &minValue = QDateTime(),
      const QDateTime &maxValue = QDateTime()
    );

    static QString typeName() { return u"datetime"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString toolTip() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;

    QDateTime minimum() const;

    void setMinimum( const QDateTime &minimum );

    QDateTime maximum() const;

    void setMaximum( const QDateTime &maximum );

    Qgis::ProcessingDateTimeParameterDataType dataType() const;

    void setDataType( Qgis::ProcessingDateTimeParameterDataType type );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QString userFriendlyString( const QVariant &value ) const override;

    static QgsProcessingParameterDateTime *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QDateTime mMin;
    QDateTime mMax;
    Qgis::ProcessingDateTimeParameterDataType mDataType = Qgis::ProcessingDateTimeParameterDataType::DateTime;
};
 

class CORE_EXPORT QgsProcessingParameterProviderConnection : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"providerconnection"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    QString providerId() const { return mProviderId; }

    void setProviderId( const QString &provider ) { mProviderId = provider; }

    static QgsProcessingParameterProviderConnection *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QString mProviderId;
};
 

class CORE_EXPORT QgsProcessingParameterDatabaseSchema : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterDatabaseSchema(
      const QString &name, const QString &description, const QString &connectionParameterName = QString(), const QVariant &defaultValue = QVariant(), bool optional = false
    );

    static QString typeName() { return u"databaseschema"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QStringList dependsOnOtherParameters() const override;

    QString parentConnectionParameterName() const;

    void setParentConnectionParameterName( const QString &name );

    static QgsProcessingParameterDatabaseSchema *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QString mParentConnectionParameterName;
};
 

class CORE_EXPORT QgsProcessingParameterDatabaseTable : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterDatabaseTable(
      const QString &name,
      const QString &description,
      const QString &connectionParameterName = QString(),
      const QString &schemaParameterName = QString(),
      const QVariant &defaultValue = QVariant(),
      bool optional = false,
      bool allowNewTableNames = false
    );

    static QString typeName() { return u"databasetable"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;
    QStringList dependsOnOtherParameters() const override;

    QString parentConnectionParameterName() const;

    void setParentConnectionParameterName( const QString &name );

    QString parentSchemaParameterName() const;

    void setParentSchemaParameterName( const QString &name );

    static QgsProcessingParameterDatabaseTable *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;

    bool allowNewTableNames() const;

    void setAllowNewTableNames( bool allowed );
 
  private:
    QString mParentConnectionParameterName;
    QString mParentSchemaParameterName;
    bool mAllowNewTableNames = false;
};
 

class CORE_EXPORT QgsProcessingParameterPointCloudLayer : public QgsProcessingParameterDefinition, public QgsFileFilterGenerator
{
  public:
    QgsProcessingParameterPointCloudLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"pointcloud"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;
    QString createFileFilter() const override;

    static QgsProcessingParameterPointCloudLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};
 

class CORE_EXPORT QgsProcessingParameterAnnotationLayer : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterAnnotationLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false );

    static QString typeName() { return u"annotation"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok SIP_OUT ) const override;
    QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const override;

    static QgsProcessingParameterAnnotationLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterPointCloudDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterPointCloudDestination( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true );

    static QString typeName() { return u"pointCloudDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;
    QString createFileFilter() const override;

    virtual QStringList supportedOutputPointCloudLayerExtensions() const;

    static QgsProcessingParameterPointCloudDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};

class CORE_EXPORT QgsProcessingParameterPointCloudAttribute : public QgsProcessingParameterDefinition
{
  public:
    QgsProcessingParameterPointCloudAttribute(
      const QString &name,
      const QString &description = QString(),
      const QVariant &defaultValue = QVariant(),
      const QString &parentLayerParameterName = QString(),
      bool allowMultiple = false,
      bool optional = false,
      bool defaultToAllAttributes = false
    );

    static QString typeName() { return u"attribute"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QString asScriptCode() const override;
    QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const override;
    QStringList dependsOnOtherParameters() const override;

    QString parentLayerParameterName() const;

    void setParentLayerParameterName( const QString &parentLayerParameterName );

    bool allowMultiple() const;

    void setAllowMultiple( bool allowMultiple );

    bool defaultToAllAttributes() const;

    void setDefaultToAllAttributes( bool enabled );
 
    QVariantMap toVariantMap() const override;
    bool fromVariantMap( const QVariantMap &map ) override;

    static QgsProcessingParameterPointCloudAttribute *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
 
  private:
    QString mParentLayerParameterName;
    bool mAllowMultiple = false;
    bool mDefaultToAllAttributes = false;
};

class CORE_EXPORT QgsProcessingParameterVectorTileDestination : public QgsProcessingDestinationParameter
{
  public:
    QgsProcessingParameterVectorTileDestination( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(), bool optional = false, bool createByDefault = true );

    static QString typeName() { return u"vectorTileDestination"_s; }
    QgsProcessingParameterDefinition *clone() const override SIP_FACTORY;
    QString type() const override { return typeName(); }
    bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = nullptr ) const override;
    QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const override;
    QgsProcessingOutputDefinition *toOutputDefinition() const override SIP_FACTORY;
    QString defaultFileExtension() const override;
    QString createFileFilter() const override;

    virtual QStringList supportedOutputVectorTileLayerExtensions() const;

    static QgsProcessingParameterVectorTileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) SIP_FACTORY;
};
 
// clazy:excludeall=qstring-allocations
 
#endif // QGSPROCESSINGPARAMETERS_H