File: qgsprocessingparameters.sip.in

package info (click to toggle)
qgis 3.40.11%2Bdfsg-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 1,183,800 kB
sloc: cpp: 1,595,841; python: 372,637; xml: 23,474; sh: 3,761; perl: 3,664; ansic: 2,257; sql: 2,137; yacc: 1,068; lex: 577; javascript: 540; lisp: 411; makefile: 154
file content (5353 lines) | stat: -rw-r--r-- 180,933 bytes
parent folder | download | duplicates (14)
/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/processing/qgsprocessingparameters.h                        *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/






class QgsProcessingFeatureSourceDefinition
{
%Docstring(signature="appended")
Encapsulates settings relating to a feature source input to a processing
algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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() );
%Docstring
Constructor for QgsProcessingFeatureSourceDefinition, accepting a static
string ``source``.

If ``selectedFeaturesOnly`` is ``True``, then only selected features
from the source will be used.

The optional ``featureLimit`` can be set to a value > 0 to place a hard
limit on the maximum number of features which will be read from the
source.

Since QGIS 3.32, the optional ``filterExpression`` argument can be used
to specify a expression to use to filter the features read from the
source.

The ``flags`` argument can be used to specify flags which dictate the
source behavior.

If the
:py:class:`Qgis`.ProcessingFeatureSourceDefinitionFlag.OverrideDefaultGeometryCheck
is set in ``flags``, then the value of ``geometryCheck`` will override
the default geometry check method (as dictated by
:py:class:`QgsProcessingContext`) for this source.
%End

    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() );
%Docstring
Constructor for QgsProcessingFeatureSourceDefinition, accepting a
QgsProperty source.

If ``selectedFeaturesOnly`` is ``True``, then only selected features
from the source will be used.

The optional ``featureLimit`` can be set to a value > 0 to place a hard
limit on the maximum number of features which will be read from the
source.

Since QGIS 3.32, the optional ``filterExpression`` argument can be used
to specify a expression to use to filter the features read from the
source.

The ``flags`` argument can be used to specify flags which dictate the
source behavior.

If the
:py:class:`Qgis`.ProcessingFeatureSourceDefinitionFlag.OverrideDefaultGeometryCheck
is set in ``flags``, then the value of ``geometryCheck`` will override
the default geometry check method (as dictated by
:py:class:`QgsProcessingContext`) for this source.
%End

    QgsProperty source;

    bool selectedFeaturesOnly;

    long long featureLimit;

    QString filterExpression;

    Qgis::ProcessingFeatureSourceDefinitionFlags flags;

    Qgis::InvalidGeometryCheck geometryCheck;

    QVariant toVariant() const;
%Docstring
Saves this source definition to a QVariantMap, wrapped in a QVariant.
You can use :py:class:`QgsXmlUtils`.writeVariant to save it to an XML
document.

.. seealso:: :py:func:`loadVariant`

.. versionadded:: 3.14
%End

    bool loadVariant( const QVariantMap &map );
%Docstring
Loads this source definition from a QVariantMap, wrapped in a QVariant.
You can use :py:class:`QgsXmlUtils`.readVariant to load it from an XML
document.

.. seealso:: :py:func:`toVariant`

.. versionadded:: 3.14
%End

    bool operator==( const QgsProcessingFeatureSourceDefinition &other ) const;

    bool operator!=( const QgsProcessingFeatureSourceDefinition &other ) const;

    operator QVariant() const;

};



class QgsProcessingOutputLayerDefinition
{
%Docstring(signature="appended")
Encapsulates settings relating to a feature sink or output raster layer
for a processing algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingOutputLayerDefinition( const QString &sink = QString(), QgsProject *destinationProject = 0 );
%Docstring
Constructor for QgsProcessingOutputLayerDefinition, accepting a static
sink/layer string. The ``destinationProject`` parameter can be set to a
:py:class:`QgsProject` instance in which to automatically load the
resulting sink/layer after completing processing.
%End

    QgsProcessingOutputLayerDefinition( const QgsProperty &sink, QgsProject *destinationProject = 0 );
%Docstring
Constructor for QgsProcessingOutputLayerDefinition, accepting a
QgsProperty sink/layer. The ``destinationProject`` parameter can be set
to a :py:class:`QgsProject` instance in which to automatically load the
resulting sink/layer after completing processing.
%End

    QgsProperty sink;

    QgsProject *destinationProject;

    QString destinationName;

    QVariantMap createOptions;

    bool useRemapping() const;
%Docstring
Returns ``True`` if the output uses a remapping definition.

.. seealso:: :py:func:`remappingDefinition`

.. versionadded:: 3.14
%End

    QgsRemappingSinkDefinition remappingDefinition() const;
%Docstring
Returns the output remapping definition, if
:py:func:`~QgsProcessingOutputLayerDefinition.useRemapping` is ``True``.

.. seealso:: :py:func:`useRemapping`

.. seealso:: :py:func:`setRemappingDefinition`

.. versionadded:: 3.14
%End

    void setRemappingDefinition( const QgsRemappingSinkDefinition &definition );
%Docstring
Sets the remapping ``definition`` to use when adding features to the
output layer.

Calling this method will set
:py:func:`~QgsProcessingOutputLayerDefinition.useRemapping` to ``True``.

.. seealso:: :py:func:`remappingDefinition`

.. seealso:: :py:func:`useRemapping`

.. versionadded:: 3.14
%End

    QVariant toVariant() const;
%Docstring
Saves this output layer definition to a QVariantMap, wrapped in a
QVariant. You can use :py:class:`QgsXmlUtils`.writeVariant to save it to
an XML document.

.. seealso:: :py:func:`loadVariant`

.. versionadded:: 3.2
%End

    bool loadVariant( const QVariantMap &map );
%Docstring
Loads this output layer definition from a QVariantMap, wrapped in a
QVariant. You can use :py:class:`QgsXmlUtils`.readVariant to load it
from an XML document.

.. seealso:: :py:func:`toVariant`

.. versionadded:: 3.2
%End

    operator QVariant() const;

    bool operator==( const QgsProcessingOutputLayerDefinition &other ) const;
    bool operator!=( const QgsProcessingOutputLayerDefinition &other ) const;

};







class QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
Base class for the definition of processing parameters.

Parameter definitions encapsulate properties regarding the behavior of
parameters, their acceptable ranges, defaults, etc.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
%TypeHeaderCode
#include "qgsprocessingparameteraggregate.h"
#include "qgsprocessingparameterdxflayers.h"
#include "qgsprocessingparameterfieldmap.h"
#include "qgsprocessingparametertininputlayers.h"
#include "qgsprocessingparametervectortilewriterlayers.h"
#include "qgsprocessingparametermeshdataset.h"
%End
%ConvertToSubClassCode
    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
      sipType = nullptr;
%End
  public:

    QgsProcessingParameterDefinition( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                      bool optional = false, const QString &help = QString() );
%Docstring
Constructor for QgsProcessingParameterDefinition.
%End

    virtual ~QgsProcessingParameterDefinition();

    virtual QgsProcessingParameterDefinition *clone() const = 0 /Factory/;
%Docstring
Creates a clone of the parameter definition.
%End

    virtual QString type() const = 0;
%Docstring
Unique parameter type name.
%End

    virtual bool isDestination() const;
%Docstring
Returns ``True`` if this parameter represents a file or layer
destination, e.g. parameters which are used for the destination for
layers output by an algorithm will return ``True``.
%End

    QString name() const;
%Docstring
Returns the name of the parameter. This is the internal identifier by
which algorithms access this parameter.

.. seealso:: :py:func:`setName`
%End

    void setName( const QString &name );
%Docstring
Sets the ``name`` of the parameter. This is the internal identifier by
which algorithms access this parameter.

.. seealso:: :py:func:`name`
%End

    QString description() const;
%Docstring
Returns the description for the parameter. This is the user-visible
string used to identify this parameter.

.. seealso:: :py:func:`setDescription`
%End

    void setDescription( const QString &description );
%Docstring
Sets the ``description`` for the parameter. This is the user-visible
string used to identify this parameter.

.. seealso:: :py:func:`description`
%End

    QString help() const;
%Docstring
Returns the help for the parameter.

This is a descriptive (possibly lengthy), translated string explaining
the parameter's behavior and use in depth.

.. seealso:: :py:func:`setHelp`

.. versionadded:: 3.16
%End

    void setHelp( const QString &help );
%Docstring
Sets the ``help`` for the parameter.

The ``help`` string should be a descriptive, translated string
explaining the parameter's behavior and use in depth.

.. seealso:: :py:func:`help`

.. versionadded:: 3.16
%End

    QVariant defaultValue() const;
%Docstring
Returns the default value for the parameter.

.. seealso:: :py:func:`setDefaultValue`

.. seealso:: :py:func:`defaultValueForGui`

.. seealso:: :py:func:`guiDefaultValueOverride`
%End

    void setDefaultValue( const QVariant &value );
%Docstring
Sets the default ``value`` for the parameter. Caller takes
responsibility to ensure that ``value`` is a valid input for the
parameter subclass.

.. seealso:: :py:func:`defaultValue`

.. seealso:: :py:func:`setGuiDefaultValueOverride`
%End

    QVariant guiDefaultValueOverride() const;
%Docstring
Returns the default value to use in the GUI for the parameter.

Usually this will return an invalid variant, which indicates that the
standard :py:func:`~QgsProcessingParameterDefinition.defaultValue` will
be used in the GUI.

.. seealso:: :py:func:`defaultValue`

.. seealso:: :py:func:`setGuiDefaultValueOverride`

.. seealso:: :py:func:`defaultValueForGui`

.. versionadded:: 3.18
%End

    void setGuiDefaultValueOverride( const QVariant &value );
%Docstring
Sets the default ``value`` to use for the parameter in GUI widgets.
Caller takes responsibility to ensure that ``value`` is a valid input
for the parameter subclass.

Usually the
:py:func:`~QgsProcessingParameterDefinition.guiDefaultValueOverride` is
a invalid variant, which indicates that the standard
:py:func:`~QgsProcessingParameterDefinition.defaultValue` should be used
in the GUI. In cases where it is decided that a previous default value
was inappropriate, setting a non-invalid default GUI value can be used
to change the default value for the parameter shown to users when
running algorithms without changing the actual
:py:func:`~QgsProcessingParameterDefinition.defaultValue` and
potentially breaking third party scripts.

.. seealso:: :py:func:`guiDefaultValueOverride`

.. seealso:: :py:func:`setDefaultValue`

.. versionadded:: 3.18
%End

    QVariant defaultValueForGui() const;
%Docstring
Returns the default value to use for the parameter in a GUI.

This will be the parameter's
:py:func:`~QgsProcessingParameterDefinition.defaultValue`, unless a
:py:func:`~QgsProcessingParameterDefinition.guiDefaultValueOverride` is
set to override that.

.. versionadded:: 3.18
%End

    Qgis::ProcessingParameterFlags flags() const;
%Docstring
Returns any flags associated with the parameter.

.. seealso:: :py:func:`setFlags`
%End

    void setFlags( Qgis::ProcessingParameterFlags flags );
%Docstring
Sets the ``flags`` associated with the parameter.

.. seealso:: :py:func:`flags`
%End

    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;
%Docstring
Checks whether the specified ``input`` value is acceptable for the
parameter. Returns ``True`` if the value can be accepted. The optional
``context`` parameter can be specified to allow a more stringent check
to be performed, capable of checking for the presence of required layers
and other factors within the context.
%End

    virtual QString valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const;
%Docstring
Returns a string version of the parameter input ``value``, which is
suitable for use as an input parameter value when running an algorithm
directly from a Python command.

.. seealso:: :py:func:`valueAsJsonObject`

.. seealso:: :py:func:`valueAsString`
%End

    virtual QVariant valueAsJsonObject( const QVariant &value, QgsProcessingContext &context ) const;
%Docstring
Returns a version of the parameter input ``value``, which is suitable
for use in a JSON object.

This method must return only simple values which can be losslessly
encapsulated in a serialized JSON map. For instance, any QGIS class
values (such as :py:class:`QgsCoordinateReferenceSystem`) must be
converted to a simple string or numeric value equivalent.

.. seealso:: :py:func:`valueAsPythonString`

.. seealso:: :py:func:`valueAsString`

.. versionadded:: 3.24
%End

    virtual QString valueAsString( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
%Docstring
Returns a string version of the parameter input ``value`` (if possible).

:param value: value to convert
:param context: processing context

:return: - value converted to string
         - ok: ``True`` if value could be represented as a string.

.. seealso:: :py:func:`valueAsStringList`

.. seealso:: :py:func:`valueAsJsonObject`

.. seealso:: :py:func:`valueAsPythonString`

.. versionadded:: 3.24
%End

    virtual QStringList valueAsStringList( const QVariant &value, QgsProcessingContext &context, bool &ok /Out/ ) const;
%Docstring
Returns a string list version of the parameter input ``value`` (if
possible).

:param value: value to convert
:param context: processing context

:return: - value converted to string list
         - ok: ``True`` if value could be represented as a string list

.. seealso:: :py:func:`valueAsString`

.. seealso:: :py:func:`valueAsJsonObject`

.. seealso:: :py:func:`valueAsPythonString`

.. versionadded:: 3.24
%End

    virtual QString valueAsPythonComment( const QVariant &value, QgsProcessingContext &context ) const;
%Docstring
Returns a Python comment explaining a parameter ``value``, or an empty
string if no comment is required.

.. versionadded:: 3.20
%End

    virtual QString asScriptCode() const;
%Docstring
Returns the parameter definition encoded in a string which can be used
within a Processing script.
%End

    virtual QString asPythonString( QgsProcessing::PythonOutputType outputType = QgsProcessing::PythonOutputType::PythonQgsProcessingAlgorithmSubclass ) const;
%Docstring
Returns the parameter definition as a Python command which can be used
within a Python Processing script.

The ``outputType`` argument specifies the desired output format for the
Python string, i.e. the intended end use of the generated Python code.

.. versionadded:: 3.6
%End

    virtual QVariantMap toVariantMap() const;
%Docstring
Saves this parameter to a QVariantMap. Subclasses should ensure that
they call the base class method and then extend the result with
additional properties.

.. seealso:: :py:func:`fromVariantMap`
%End

    virtual bool fromVariantMap( const QVariantMap &map );
%Docstring
Restores this parameter to a QVariantMap. Subclasses should ensure that
they call the base class method.

.. seealso:: :py:func:`toVariantMap`
%End


    QVariantMap &metadata();
%Docstring
Returns the parameter's freeform metadata. This is mostly used by
parameter widget wrappers in order to customize their appearance and
behavior.

.. seealso:: :py:func:`setMetadata`
%End

    void setMetadata( const QVariantMap &metadata );
%Docstring
Sets the parameter's freeform ``metadata``. This is mostly used by
parameter widget wrappers in order to customize their appearance and
behavior.

.. seealso:: :py:func:`metadata`
%End

    virtual QStringList dependsOnOtherParameters() const;
%Docstring
Returns a list of other parameter names on which this parameter is
dependent (e.g. field parameters which depend on a parent layer
parameter).
%End

    QgsProcessingAlgorithm *algorithm() const;
%Docstring
Returns a pointer to the algorithm which owns this parameter. May be
``None`` for non-owned parameters.

.. seealso:: :py:func:`provider`
%End

    QgsProcessingProvider *provider() const;
%Docstring
Returns a pointer to the provider for the algorithm which owns this
parameter. May be ``None`` for non-owned parameters or algorithms.

.. seealso:: :py:func:`algorithm`
%End

    virtual QString toolTip() const;
%Docstring
Returns a formatted tooltip for use with the parameter, which gives
helpful information like parameter description, ID, and extra content
like default values (depending on parameter type).
%End

    bool isDynamic() const;
%Docstring
Returns ``True`` if the parameter supports is dynamic, and can support
data-defined values (i.e. :py:class:`QgsProperty` based values).

.. seealso:: :py:func:`setIsDynamic`

.. seealso:: :py:func:`dynamicPropertyDefinition`

.. seealso:: :py:func:`dynamicLayerParameterName`
%End

    void setIsDynamic( bool dynamic );
%Docstring
Sets whether the parameter is ``dynamic``, and can support data-defined
values (i.e. :py:class:`QgsProperty` based values).

.. seealso:: :py:func:`isDynamic`

.. seealso:: :py:func:`setDynamicPropertyDefinition`

.. seealso:: :py:func:`setDynamicLayerParameterName`
%End

    QgsPropertyDefinition dynamicPropertyDefinition() const;
%Docstring
Returns the property definition for dynamic properties.

.. seealso:: :py:func:`isDynamic`

.. seealso:: :py:func:`setDynamicPropertyDefinition`

.. seealso:: :py:func:`dynamicLayerParameterName`
%End

    void setDynamicPropertyDefinition( const QgsPropertyDefinition &definition );
%Docstring
Sets the property ``definition`` for dynamic properties.

.. seealso:: :py:func:`isDynamic`

.. seealso:: :py:func:`dynamicPropertyDefinition`

.. seealso:: :py:func:`setDynamicLayerParameterName`
%End

    QString dynamicLayerParameterName() const;
%Docstring
Returns the name of the parameter for a layer linked to a dynamic
parameter, or an empty string if this is not set.

Dynamic parameters (see
:py:func:`~QgsProcessingParameterDefinition.isDynamic`) can have an
optional vector layer parameter linked to them, which indicates which
layer the fields and values will be available from when evaluating the
dynamic parameter.

.. seealso:: :py:func:`setDynamicLayerParameterName`

.. seealso:: :py:func:`isDynamic`

.. seealso:: :py:func:`dynamicPropertyDefinition`
%End

    void setDynamicLayerParameterName( const QString &name );
%Docstring
Sets the ``name`` for the parameter for a layer linked to a dynamic
parameter, or an empty string if this is not set.

Dynamic parameters (see
:py:func:`~QgsProcessingParameterDefinition.isDynamic`) can have an
optional vector layer parameter linked to them, which indicates which
layer the fields and values will be available from when evaluating the
dynamic parameter.

.. seealso:: :py:func:`dynamicLayerParameterName`

.. seealso:: :py:func:`isDynamic`

.. seealso:: :py:func:`setDynamicPropertyDefinition`
%End

    QStringList additionalExpressionContextVariables() const;
%Docstring
Returns a list of additional expression context variables which are
available for use when evaluating this parameter.

The additional variables will be added to the variables exposed from the
usual expression context available to the parameter. They can be used to
expose variables which are ONLY available to this parameter.

The returned list should contain the variable names only, without the
usual "@" prefix.

.. seealso:: :py:func:`setAdditionalExpressionContextVariables`

.. versionadded:: 3.8
%End

    void setAdditionalExpressionContextVariables( const QStringList &variables );
%Docstring
Sets a list of additional expression context ``variables`` which are
available for use when evaluating this parameter.

The additional variables will be added to the variables exposed from the
usual expression context available to the parameter. They can be used to
expose variables which are ONLY available to this parameter.

The ``variables`` list should contain the variable names only, without
the usual "@" prefix.

.. note::

   Specifying variables via this method is for metadata purposes only. It is the algorithm's responsibility
   to correctly set the value of these additional variables in all expression context used when evaluating the parameter,
   in whichever way is appropriate for that particular variable.

.. seealso:: :py:func:`additionalExpressionContextVariables`

.. versionadded:: 3.8
%End


  protected:


    QVariant defaultGuiValueFromSetting() const;
%Docstring
Default gui value for an algorithm parameter from settings

:return: default value from settings or invalid QVariant if there is no
         default value defined in the settings

.. versionadded:: 3.34
%End














};


typedef QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions;


class QgsProcessingParameters
{
%Docstring(signature="appended")
A collection of utilities for working with parameters when running a
processing algorithm.

Parameters are stored in a QVariantMap and referenced by a unique string
key. The QVariants in parameters are not usually accessed directly, and
instead the high level API provided through
:py:class:`QgsProcessingParameters` :py:func:`~parameterAsString`,
:py:func:`~parameterAsDouble` are used instead.

Parameters are evaluated using a provided
:py:class:`QgsProcessingContext`, allowing the evaluation to understand
available map layers and expression contexts (for expression based
parameters).
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    static bool isDynamic( const QVariantMap &parameters, const QString &name );
%Docstring
Returns ``True`` if the parameter with matching ``name`` is a dynamic
parameter, and must be evaluated once for every input feature processed.
%End

    static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static string
value.
%End

    static QString parameterAsString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static string value.

.. versionadded:: 3.4
%End

    static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to an expression.
%End

    static QString parameterAsExpression( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definitionand`` ``value`` to an
expression.

.. versionadded:: 3.4
%End

    static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static double
value.
%End

    static double parameterAsDouble( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static double value.

.. versionadded:: 3.4
%End

    static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static integer
value.
%End

    static int parameterAsInt( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static integer value.

.. versionadded:: 3.4
%End

    static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a list of
integer values.

.. versionadded:: 3.4
%End

    static QList<int> parameterAsInts( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
list of integer values.

.. versionadded:: 3.4
%End

    static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static
datetime value.

.. seealso:: :py:func:`parameterAsDate`

.. seealso:: :py:func:`parameterAsTime`

.. versionadded:: 3.14
%End

    static QDateTime parameterAsDateTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static datetime value.

.. seealso:: :py:func:`parameterAsDate`

.. seealso:: :py:func:`parameterAsTime`

.. versionadded:: 3.14
%End

    static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static date
value.

.. seealso:: :py:func:`parameterAsDateTime`

.. seealso:: :py:func:`parameterAsTime`

.. versionadded:: 3.14
%End

    static QDate parameterAsDate( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static date value.

.. seealso:: :py:func:`parameterAsDateTime`

.. seealso:: :py:func:`parameterAsTime`

.. versionadded:: 3.14
%End

    static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static time
value.

.. seealso:: :py:func:`parameterAsDateTime`

.. seealso:: :py:func:`parameterAsDate`

.. versionadded:: 3.14
%End

    static QTime parameterAsTime( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static time value.

.. seealso:: :py:func:`parameterAsDateTime`

.. seealso:: :py:func:`parameterAsDate`

.. versionadded:: 3.14
%End

    static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a enum value.
%End

    static int parameterAsEnum( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
enum value.

.. versionadded:: 3.4
%End

    static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to list of enum
values.
%End

    static QList<int> parameterAsEnums( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to
list of enum values.

.. versionadded:: 3.4
%End

    static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static enum
string.

.. versionadded:: 3.18
%End

    static QString parameterAsEnumString( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static enum string.

.. versionadded:: 3.18
%End

    static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to list of static
enum strings.

.. versionadded:: 3.18
%End

    static QStringList parameterAsEnumStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to
list of static enum strings.

.. versionadded:: 3.18
%End

    static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static boolean
value.
%End

    static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a static boolean
value.

.. versionadded:: 3.8
%End

    static bool parameterAsBool( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static boolean value.

.. versionadded:: 3.4
%End

    static bool parameterAsBoolean( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
static boolean value.

.. versionadded:: 3.8
%End

    static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters,
                                            const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs,
                                            QgsProcessingContext &context, QString &destinationIdentifier /Out/, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) /Factory/;
%Docstring
Evaluates the parameter with matching ``definition`` to a feature sink.

The ``fields``, ``geometryType`` and ``crs`` parameters dictate the
properties of the resulting feature sink.

Sinks will either be taken from ``context``'s active project, or created
from external providers and stored temporarily in the ``context``. The
``destinationIdentifier`` argument will be set to a string which can be
used to retrieve the layer corresponding to the sink, e.g. via calling
:py:func:`QgsProcessingUtils.mapLayerFromString()`.

The ``createOptions`` argument is used to pass on creation options such
as layer name.

The ``datasourceOptions`` and ``layerOptions`` arguments is used to pass
on GDAL-specific format driver options.

This function creates a new object and the caller takes responsibility
for deleting the returned object.
%End

    static QgsFeatureSink *parameterAsSink( const QgsProcessingParameterDefinition *definition, const QVariant &value,
                                            const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs,
                                            QgsProcessingContext &context, QString &destinationIdentifier /Out/, QgsFeatureSink::SinkFlags sinkFlags = QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions = QVariantMap(), const QStringList &datasourceOptions = QStringList(), const QStringList &layerOptions = QStringList() ) throw( QgsProcessingException ) /Factory/;
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
feature sink.

The ``fields``, ``geometryType`` and ``crs`` parameters dictate the
properties of the resulting feature sink.

Sinks will either be taken from ``context``'s active project, or created
from external providers and stored temporarily in the ``context``. The
``destinationIdentifier`` argument will be set to a string which can be
used to retrieve the layer corresponding to the sink, e.g. via calling
:py:func:`QgsProcessingUtils.mapLayerFromString()`.

The ``createOptions`` argument is used to pass on creation options such
as layer name.

The ``datasourceOptions`` and ``layerOptions`` arguments is used to pass
on GDAL-specific format driver options.

This function creates a new object and the caller takes responsibility
for deleting the returned object.

:raises QgsProcessingException: 

.. versionadded:: 3.4
%End

    static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) /Factory/;
%Docstring
Evaluates the parameter with matching ``definition`` to a feature
source.

Sources will either be taken from ``context``'s active project, or
loaded from external sources and stored temporarily in the ``context``.

This function creates a new object and the caller takes responsibility
for deleting the returned object.
%End

    static QgsProcessingFeatureSource *parameterAsSource( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) /Factory/;
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
feature source.

Sources will either be taken from ``context``'s active project, or
loaded from external sources and stored temporarily in the ``context``.

This function creates a new object and the caller takes responsibility
for deleting the returned object.

.. versionadded:: 3.4
%End

    static QString parameterAsCompatibleSourceLayerPath( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters,
        QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = 0 );
%Docstring
Evaluates the parameter with matching ``definition`` to a source vector
layer file path of compatible format.

If the parameter is evaluated to an existing layer, and that layer is
not of the format listed in the ``compatibleFormats`` argument, then the
layer will first be exported to a compatible format in a temporary
location. The function will then return the path to that temporary file.

``compatibleFormats`` should consist entirely of lowercase file
extensions, e.g. 'shp'.

The ``preferredFormat`` argument is used to specify to desired file
extension to use when a temporary layer export is required. This
defaults to shapefiles, because shapefiles are the future (don't believe
the geopackage hype!).

When an algorithm is capable of handling multi-layer input files (such
as Geopackage), it is preferable to use
:py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPathAndLayerName`
which may avoid conversion in more situations.
%End

    static QString parameterAsCompatibleSourceLayerPathAndLayerName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters,
        QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat = QString( "shp" ), QgsProcessingFeedback *feedback = 0, QString *layerName /Out/ = 0 );
%Docstring
Evaluates the parameter with matching ``definition`` to a source vector
layer file path and layer name of compatible format.

If the parameter is evaluated to an existing layer, and that layer is
not of the format listed in the ``compatibleFormats`` argument, then the
layer will first be exported to a compatible format in a temporary
location. The function will then return the path to that temporary file.

``compatibleFormats`` should consist entirely of lowercase file
extensions, e.g. 'shp'.

The ``preferredFormat`` argument is used to specify to desired file
extension to use when a temporary layer export is required. This
defaults to shapefiles, because shapefiles are the future (don't believe
the geopackage hype!).

This method should be preferred over
:py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPath`
when an algorithm is able to correctly handle files with multiple
layers. Unlike
:py:func:`~QgsProcessingParameters.parameterAsCompatibleSourceLayerPath`,
it will not force a conversion in this case and will return the target
layer name in the ``layerName`` argument.

:param definition: associated parameter definition
:param parameters: input parameter value map
:param context: processing context
:param compatibleFormats: a list of lowercase file extensions compatible
                          with the algorithm
:param preferredFormat: preferred format extension to use if conversion
                        if required
:param feedback: feedback object

:return: - path to source layer, or nearly converted compatible layer
         - layerName: the target layer name for multi-layer sources
           (e.g. Geopackage)

.. seealso:: :py:func:`parameterAsCompatibleSourceLayerPath`

.. versionadded:: 3.10
%End

    static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` to a map layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.
%End

    static QgsMapLayer *parameterAsLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint = QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
map layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.4
%End

    static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a raster layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.
%End

    static QgsRasterLayer *parameterAsRasterLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
raster layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.4
%End

    static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a output layer
destination.
%End

    static QString parameterAsOutputLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, bool testOnly = false );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
output layer destination.

Since QGIS 3.38 the ``testOnly`` argument can be set to ``True`` to
evaluate the parameter to an output layer destination for advance
testing only. This prevents default behavior such as output
post-processing which would otherwise occur.

.. versionadded:: 3.4
%End

    static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a file based
output destination.
%End

    static QString parameterAsFileOutput( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
file based output destination.

.. versionadded:: 3.4
%End

    static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a vector layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.
%End

    static QgsVectorLayer *parameterAsVectorLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
vector layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.4
%End

    static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
mesh layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.6
%End

    static QgsMeshLayer *parameterAsMeshLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
mesh layer.

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.6
%End

    static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a coordinate
reference system.
%End

    static QgsCoordinateReferenceSystem parameterAsCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
coordinate reference system.

.. versionadded:: 3.4
%End

    static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
                                           const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` to a rectangular
extent.

If ``crs`` is set, and the original coordinate reference system of the
parameter can be determined, then the extent will be automatically
reprojected so that it is in the specified ``crs``. In this case the
extent of the reproject rectangle will be returned.

.. seealso:: :py:func:`parameterAsExtentGeometry`

.. seealso:: :py:func:`parameterAsExtentCrs`
%End

    static QgsRectangle parameterAsExtent( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
                                           const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
rectangular extent.

If ``crs`` is set, and the original coordinate reference system of the
parameter can be determined, then the extent will be automatically
reprojected so that it is in the specified ``crs``. In this case the
extent of the reproject rectangle will be returned.

.. seealso:: :py:func:`parameterAsExtentGeometry`

.. seealso:: :py:func:`parameterAsExtentCrs`

.. versionadded:: 3.4
%End

    static QgsGeometry parameterAsExtentGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
        const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` to a rectangular
extent, and returns a geometry covering this extent.

If ``crs`` is set, and the original coordinate reference system of the
parameter can be determined, then the extent will be automatically
reprojected so that it is in the specified ``crs``. Unlike
:py:func:`~QgsProcessingParameters.parameterAsExtent`, the reprojected
rectangle returned by this function will no longer be a rectangle itself
(i.e. this method returns the geometry of the actual reprojected
rectangle, while :py:func:`~QgsProcessingParameters.parameterAsExtent`
returns just the extent of the reprojected rectangle).

.. seealso:: :py:func:`parameterAsExtent`

.. seealso:: :py:func:`parameterAsExtentCrs`
%End

    static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with an extent
parameter value.

.. seealso:: :py:func:`parameterAsExtent`
%End

    static QgsCoordinateReferenceSystem parameterAsExtentCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with an extent
parameter value.

.. seealso:: :py:func:`parameterAsExtent`
%End


    static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context,
                                        const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` to a point.

If ``crs`` is set then the point will be automatically reprojected so
that it is in the specified ``crs``.

.. seealso:: :py:func:`parameterAsPointCrs`
%End

    static QgsPointXY parameterAsPoint( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context,
                                        const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
point.

If ``crs`` is set then the point will be automatically reprojected so
that it is in the specified ``crs``.

.. seealso:: :py:func:`parameterAsPointCrs`

.. versionadded:: 3.4
%End

    static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with an point
parameter value.

.. seealso:: :py:func:`parameterAsPoint`
%End

    static QgsCoordinateReferenceSystem parameterAsPointCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with an point
parameter value.

.. seealso:: :py:func:`parameterAsPoint`

.. versionadded:: 3.8
%End

    static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` to a geometry.

.. versionadded:: 3.16
%End

    static QgsGeometry parameterAsGeometry( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs = QgsCoordinateReferenceSystem() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
geometry.

.. versionadded:: 3.16
%End

    static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with a geometry
parameter value.

.. seealso:: :py:func:`parameterAsGeometry`

.. versionadded:: 3.16
%End

    static QgsCoordinateReferenceSystem parameterAsGeometryCrs( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Returns the coordinate reference system associated with an point
parameter value.

.. seealso:: :py:func:`parameterAsGeometry`

.. versionadded:: 3.16
%End

    static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a file/folder
name.
%End

    static QString parameterAsFile( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
file/folder name.

.. versionadded:: 3.4
%End

    static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a matrix/table
of values. Tables are collapsed to a 1 dimensional list.
%End

    static QVariantList parameterAsMatrix( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
matrix/table of values. Tables are collapsed to a 1 dimensional list.

.. versionadded:: 3.4
%End

    static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` to a list of map
layers. The ``flags`` are used to set options for loading layers (e.g.
skip index generation).
%End

    static QList< QgsMapLayer *> parameterAsLayerList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
list of map layers. The ``flags`` are used to set options for loading
layers (e.g. skip index generation).

.. versionadded:: 3.4
%End

    static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a list of files
(for :py:class:`QgsProcessingParameterMultipleLayers` in
:py:class:`QgsProcessing`:TypeFile mode).

.. versionadded:: 3.10
%End

    static QStringList parameterAsFileList( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a list of files
(for :py:class:`QgsProcessingParameterMultipleLayers` in
:py:class:`QgsProcessing`:TypeFile mode).

.. versionadded:: 3.10
%End

    static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a range of
values.
%End

    static QList<double> parameterAsRange( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
range of values.

.. versionadded:: 3.4
%End

 static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context ) /Deprecated/;
%Docstring
Evaluates the parameter with matching ``definition`` to a list of
fields.

.. deprecated:: 3.40

   Use :py:func:`~QgsProcessingParameters.parameterAsStrings` instead.
%End

 static QStringList parameterAsFields( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context ) /Deprecated/;
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
list of fields.

.. versionadded:: 3.4

.. deprecated:: 3.40

   Use :py:func:`~QgsProcessingParameters.parameterAsStrings` instead.
%End

    static QStringList parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a list of
strings (e.g. field names or point cloud attributes).

.. versionadded:: 3.32
%End

    static QStringList parameterAsStrings( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
list of strings (e.g. field names or point cloud attributes).

.. versionadded:: 3.32
%End

    static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a print layout.

.. warning::

   This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
   implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.

.. versionadded:: 3.8
%End

    static QgsPrintLayout *parameterAsLayout( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
print layout.

.. warning::

   This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
   implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.

.. versionadded:: 3.8
%End

    static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsPrintLayout *layout );
%Docstring
Evaluates the parameter with matching ``definition`` to a print layout
item, taken from the specified ``layout``.

.. warning::

   This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
   implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.

.. versionadded:: 3.8
%End

    static QgsLayoutItem *parameterAsLayoutItem( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsPrintLayout *layout );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
print layout, taken from the specified ``layout``.

.. warning::

   This method is not safe to run in a background thread, so it must either be used within a prepareAlgorithm
   implementation (which runs in the main thread), or the algorithm must return the FlagNoThreading flag.

.. versionadded:: 3.8
%End

    static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Returns the color associated with an point parameter value, or an
invalid color if the parameter was not set.

.. versionadded:: 3.10
%End

    static QColor parameterAsColor( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Returns the color associated with an color parameter value, or an
invalid color if the parameter was not set.

.. versionadded:: 3.10
%End

    static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a connection
name string.

.. versionadded:: 3.14
%End

    static QString parameterAsConnectionName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
connection name string.

.. versionadded:: 3.14
%End

    static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a database
schema name.

.. versionadded:: 3.14
%End

    static QString parameterAsSchema( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
database schema name.

.. versionadded:: 3.14
%End

    static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to a database table
name.

.. versionadded:: 3.14
%End

    static QString parameterAsDatabaseTableName( const QgsProcessingParameterDefinition *definition, const QVariant &value, const QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
database table name.

.. versionadded:: 3.14
%End

    static QgsPointCloudLayer *parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` to a point cloud
layer. The ``flags`` are used to set options for loading layer (e.g.
skip index generation).

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.22
%End

    static QgsPointCloudLayer *parameterAsPointCloudLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context, QgsProcessing::LayerOptionsFlags flags = QgsProcessing::LayerOptionsFlags() );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to a
point cloud layer. The ``flags`` are used to set options for loading
layer (e.g. skip index generation).

Layers will either be taken from ``context``'s active project, or loaded
from external sources and stored temporarily in the ``context``. In
either case, callers do not need to handle deletion of the returned
layer.

.. versionadded:: 3.22
%End

    static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` to an annotation
layer.

Layers will be taken from ``context``'s active project. Callers do not
need to handle deletion of the returned layer.

.. warning::

   Working with annotation layers is generally not thread safe (unless the layers are from
   a :py:class:`QgsProject` loaded directly in a background thread). Ensure your algorithm returns the
   :py:class:`QgsProcessingAlgorithm`.FlagNoThreading flag or only accesses annotation layers from a :py:func:`~QgsProcessingParameters.prepareAlgorithm`
   or :py:func:`~QgsProcessingParameters.postProcessAlgorithm` step.

.. versionadded:: 3.22
%End

    static QgsAnnotationLayer *parameterAsAnnotationLayer( const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context );
%Docstring
Evaluates the parameter with matching ``definition`` and ``value`` to an
annotation layer.

Layers will be taken from ``context``'s active project. Callers do not
need to handle deletion of the returned layer.

.. warning::

   Working with annotation layers is generally not thread safe (unless the layers are from
   a :py:class:`QgsProject` loaded directly in a background thread). Ensure your algorithm returns the
   :py:class:`QgsProcessingAlgorithm`.FlagNoThreading flag or only accesses annotation layers from a :py:func:`~QgsProcessingParameters.prepareAlgorithm`
   or :py:func:`~QgsProcessingParameters.postProcessAlgorithm` step.

.. versionadded:: 3.22
%End

    static QgsProcessingParameterDefinition *parameterFromVariantMap( const QVariantMap &map ) /Factory/;
%Docstring
Creates a new :py:class:`QgsProcessingParameterDefinition` using the
configuration from a supplied variant ``map``. The caller takes
responsibility for deleting the returned object.
%End

    static QString descriptionFromName( const QString &name );
%Docstring
Creates an autogenerated parameter description from a parameter
``name``.
%End

    static QgsProcessingParameterDefinition *parameterFromScriptCode( const QString &code ) /Factory/;
%Docstring
Creates a new :py:class:`QgsProcessingParameterDefinition` using the
configuration from a supplied script ``code`` string. The caller takes
responsibility for deleting the returned object.
%End

};



class QgsProcessingParameterBoolean : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A boolean parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterBoolean( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                   bool optional = false );
%Docstring
Constructor for QgsProcessingParameterBoolean.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;


    static QgsProcessingParameterBoolean *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};

class QgsProcessingParameterCrs : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A coordinate reference system parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterCrs( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                               bool optional = false );
%Docstring
Constructor for QgsProcessingParameterCrs.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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


    static QgsProcessingParameterCrs *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterExtent : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A rectangular map extent parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterExtent( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                  bool optional = false );
%Docstring
Constructor for QgsProcessingParameterExtent.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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


    static QgsProcessingParameterExtent *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterPoint : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A point parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterPoint( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                 bool optional = false );
%Docstring
Constructor for QgsProcessingParameterPoint.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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


    static QgsProcessingParameterPoint *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterGeometry : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A geometry parameter for processing algorithms.

.. versionadded:: 3.16
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterGeometry.

The ``geometryTypes`` argument allows for specifying a list of geometry
types (see :py:class:`Qgis`.GeometryType) acceptable for this parameter.
Passing a empty list will allow for any type of geometry. The
``allowMultiPart`` argument allows specifying a multi part geometry
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString valueAsPythonString( 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 );


    QList<int>  geometryTypes() const;
%Docstring
Returns the parameter allowed geometries, as a list of
:py:class:`Qgis`.GeometryType values.

.. seealso:: :py:func:`setGeometryTypes`
%End

    void setGeometryTypes( const QList<int> &geometryTypes );
%Docstring
Sets the allowed ``geometryTypes``, as a list of
:py:class:`Qgis`.GeometryType values.

.. seealso:: :py:func:`geometryTypes`
%End

    bool  allowMultipart() const;
%Docstring
Returns the parameter allow multipart geometries.

.. seealso:: :py:func:`setAllowMultipart`
%End

    void setAllowMultipart( bool allowMultipart );
%Docstring
Sets the allow multipart geometries

.. seealso:: :py:func:`allowMultipart`
%End



    static QgsProcessingParameterGeometry *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterFile : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
An input file or folder parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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() );
%Docstring
Constructor for QgsProcessingParameterFile.

The ``extension`` argument allows for specifying a file extension
associated with the parameter (e.g. "html"). Use ``fileFilter`` for a
more flexible approach which allows for multiple file extensions. Only
one of ``extension`` or ``fileFilter`` should be specified, if both are
specified then ``fileFilter`` takes precedence.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString asScriptCode() const;

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

    virtual QString createFileFilter() const;


    Qgis::ProcessingFileParameterBehavior behavior() const;
%Docstring
Returns the parameter behavior (e.g. File or Folder).

.. seealso:: :py:func:`setBehavior`
%End

    void setBehavior( Qgis::ProcessingFileParameterBehavior behavior );
%Docstring
Sets the parameter ``behavior`` (e.g. File or Folder).

.. seealso:: :py:func:`behavior`
%End

    QString extension() const;
%Docstring
Returns any specified file extension for the parameter.

.. note::

   See :py:func:`~QgsProcessingParameterFile.fileFilter` for a more flexible approach.

.. seealso:: :py:func:`setExtension`
%End

    void setExtension( const QString &extension );
%Docstring
Sets a file ``extension`` for the parameter.

Calling this method resets any existing
:py:func:`~QgsProcessingParameterFile.fileFilter`.

.. note::

   See :py:func:`~QgsProcessingParameterFile.setFileFilter` for a more flexible approach.

.. seealso:: :py:func:`extension`
%End

    QString fileFilter() const;
%Docstring
Returns the file filter string for file destinations compatible with
this parameter.

.. seealso:: :py:func:`setFileFilter`

.. seealso:: :py:func:`extension`

.. versionadded:: 3.10
%End

    void setFileFilter( const QString &filter );
%Docstring
Sets the file ``filter`` string for file destinations compatible with
this parameter.

Calling this method resets any existing
:py:func:`~QgsProcessingParameterFile.extension` setting.

.. seealso:: :py:func:`fileFilter`

.. seealso:: :py:func:`setExtension`

.. versionadded:: 3.10
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterFile *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition, Qgis::ProcessingFileParameterBehavior behavior = Qgis::ProcessingFileParameterBehavior::File ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterMatrix : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A table (matrix) parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterMatrix.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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


    QStringList headers() const;
%Docstring
Returns a list of column headers (if set).

.. seealso:: :py:func:`setHeaders`
%End

    void setHeaders( const QStringList &headers );
%Docstring
Sets the list of column ``headers``.

.. seealso:: :py:func:`headers`
%End

    int numberRows() const;
%Docstring
Returns the fixed number of rows in the table. This parameter only has
an effect if :py:func:`~QgsProcessingParameterMatrix.hasFixedNumberRows`
is ``True``.

.. seealso:: :py:func:`setNumberRows`

.. seealso:: :py:func:`setHasFixedNumberRows`
%End

    void setNumberRows( int rows );
%Docstring
Sets the fixed number of ``rows`` in the table. This parameter only has
an effect if :py:func:`~QgsProcessingParameterMatrix.hasFixedNumberRows`
is ``True``.

.. seealso:: :py:func:`numberRows`

.. seealso:: :py:func:`setHasFixedNumberRows`
%End

    bool hasFixedNumberRows() const;
%Docstring
Returns whether the table has a fixed number of rows.

.. seealso:: :py:func:`numberRows`

.. seealso:: :py:func:`setHasFixedNumberRows`
%End

    void setHasFixedNumberRows( bool hasFixedNumberRows );
%Docstring
Sets whether the table has a fixed number of rows.

.. seealso:: :py:func:`setNumberRows`

.. seealso:: :py:func:`hasFixedNumberRows`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterMatrix *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterMultipleLayers : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A parameter for processing algorithms which accepts multiple map layers.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterMultipleLayers( const QString &name, const QString &description = QString(), Qgis::ProcessingSourceType layerType = Qgis::ProcessingSourceType::VectorAnyGeometry,
                                          const QVariant &defaultValue = QVariant(),
                                          bool optional = false );
%Docstring
Constructor for QgsProcessingParameterMultipleLayers.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString asScriptCode() const;

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

    virtual QString createFileFilter() const;


    Qgis::ProcessingSourceType layerType() const;
%Docstring
Returns the layer type for layers acceptable by the parameter.

.. seealso:: :py:func:`setLayerType`
%End

    void setLayerType( Qgis::ProcessingSourceType type );
%Docstring
Sets the layer ``type`` for layers acceptable by the parameter.

.. seealso:: :py:func:`layerType`
%End

    int minimumNumberInputs() const;
%Docstring
Returns the minimum number of layers required for the parameter. If the
return value is < 1 then the parameter accepts any number of layers.

.. seealso:: :py:func:`setMinimumNumberInputs`
%End

    void setMinimumNumberInputs( int minimum );
%Docstring
Sets the ``minimum`` number of layers required for the parameter. The
minimum must be >= 1 if the parameter is not optional.

.. seealso:: :py:func:`minimumNumberInputs`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterMultipleLayers *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterNumber : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A numeric parameter for processing algorithms.

For numeric parameters with a :py:func:`~dataType` of Double, the number
of decimals places shown in the parameter's widget can be specified by
setting the parameter's metadata. For example:

.. code-block:: python

       param = QgsProcessingParameterNumber( 'VAL', 'Threshold', type=QgsProcessingParameterNumber.Double)
       # only show two decimal places in parameter's widgets, not 6:
       param.setMetadata( {'widget_wrapper':
         { 'decimals': 2 }
       })
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 = -DBL_MAX + 1,
                                           double maxValue = DBL_MAX
                                         );
%Docstring
Constructor for QgsProcessingParameterNumber.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString toolTip() const;

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


    double minimum() const;
%Docstring
Returns the minimum value acceptable by the parameter.

.. seealso:: :py:func:`setMinimum`
%End

    void setMinimum( double minimum );
%Docstring
Sets the ``minimum`` value acceptable by the parameter.

.. seealso:: :py:func:`minimum`
%End

    double maximum() const;
%Docstring
Returns the maximum value acceptable by the parameter.

.. seealso:: :py:func:`setMaximum`
%End

    void setMaximum( double maximum );
%Docstring
Sets the ``maximum`` value acceptable by the parameter.

.. seealso:: :py:func:`maximum`
%End

    Qgis::ProcessingNumberParameterType dataType() const;
%Docstring
Returns the acceptable data type for the parameter.

.. seealso:: :py:func:`setDataType`
%End

    void setDataType( Qgis::ProcessingNumberParameterType type );
%Docstring
Sets the acceptable data ``type`` for the parameter.

.. seealso:: :py:func:`dataType`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterNumber *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterDistance : QgsProcessingParameterNumber
{
%Docstring(signature="appended")
A double numeric parameter for distance values. Linked to a source layer
or CRS parameter to determine what units the distance values are in.

The number of decimals places shown in a distance parameter's widget can
be specified by setting the parameter's metadata. For example:

.. code-block:: python

       param = QgsProcessingParameterDistance( 'VAL', 'Threshold')
       # only show two decimal places in parameter's widgets, not 6:
       param.setMetadata( {'widget_wrapper':
         { 'decimals': 2 }
       })

.. versionadded:: 3.2
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    explicit QgsProcessingParameterDistance( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        const QString &parentParameterName = QString(),
        bool optional = false,
        double minValue = -DBL_MAX + 1,
        double maxValue = DBL_MAX );
%Docstring
Constructor for QgsProcessingParameterDistance.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End

    virtual QgsProcessingParameterDistance *clone() const /Factory/;


    virtual QString type() const;

    virtual QStringList dependsOnOtherParameters() const;

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


    QString parentParameterName() const;
%Docstring
Returns the name of the parent parameter, or an empty string if this is
not set.

.. seealso:: :py:func:`setParentParameterName`
%End

    void setParentParameterName( const QString &parentParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentParameterName`
%End

    Qgis::DistanceUnit defaultUnit() const;
%Docstring
Returns the default distance unit for the parameter.

.. seealso:: :py:func:`setDefaultUnit`

.. versionadded:: 3.4.3
%End

    void setDefaultUnit( Qgis::DistanceUnit unit );
%Docstring
Sets the default distance ``unit`` for the parameter.

.. seealso:: :py:func:`defaultUnit`

.. versionadded:: 3.4.3
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


};


class QgsProcessingParameterArea : QgsProcessingParameterNumber
{
%Docstring(signature="appended")
A double numeric parameter for area values. Linked to a source layer or
CRS parameter to determine what units the area values are in.

The number of decimals places shown in a area parameter's widget can be
specified by setting the parameter's metadata. For example:

.. code-block:: python

       param = QgsProcessingParameterArea( 'VAL', 'Threshold')
       # only show two decimal places in parameter's widgets, not 6:
       param.setMetadata( {'widget_wrapper':
         { 'decimals': 2 }
       })

.. versionadded:: 3.40
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 = DBL_MAX );
%Docstring
Constructor for QgsProcessingParameterArea.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End

    virtual QgsProcessingParameterArea *clone() const /Factory/;


    virtual QString type() const;

    virtual QStringList dependsOnOtherParameters() const;

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


    QString parentParameterName() const;
%Docstring
Returns the name of the parent parameter, or an empty string if this is
not set.

.. seealso:: :py:func:`setParentParameterName`
%End

    void setParentParameterName( const QString &parentParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentParameterName`
%End

    Qgis::AreaUnit defaultUnit() const;
%Docstring
Returns the default area unit for the parameter.

.. seealso:: :py:func:`setDefaultUnit`
%End

    void setDefaultUnit( Qgis::AreaUnit unit );
%Docstring
Sets the default area ``unit`` for the parameter.

.. seealso:: :py:func:`defaultUnit`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


};


class QgsProcessingParameterVolume : QgsProcessingParameterNumber
{
%Docstring(signature="appended")
A double numeric parameter for volume values. Linked to a source layer
or CRS parameter to determine what units the volume values are in.

The number of decimals places shown in a volume parameter's widget can
be specified by setting the parameter's metadata. For example:

.. code-block:: python

       param = QgsProcessingParameterVolume( 'VAL', 'Threshold')
       # only show two decimal places in parameter's widgets, not 6:
       param.setMetadata( {'widget_wrapper':
         { 'decimals': 2 }
       })

.. versionadded:: 3.40
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 = DBL_MAX );
%Docstring
Constructor for QgsProcessingParameterVolume.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End

    virtual QgsProcessingParameterVolume *clone() const /Factory/;


    virtual QString type() const;

    virtual QStringList dependsOnOtherParameters() const;

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


    QString parentParameterName() const;
%Docstring
Returns the name of the parent parameter, or an empty string if this is
not set.

.. seealso:: :py:func:`setParentParameterName`
%End

    void setParentParameterName( const QString &parentParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentParameterName`
%End

    Qgis::VolumeUnit defaultUnit() const;
%Docstring
Returns the default volume unit for the parameter.

.. seealso:: :py:func:`setDefaultUnit`
%End

    void setDefaultUnit( Qgis::VolumeUnit unit );
%Docstring
Sets the default volume ``unit`` for the parameter.

.. seealso:: :py:func:`defaultUnit`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


};


class QgsProcessingParameterDuration : QgsProcessingParameterNumber
{
%Docstring(signature="appended")
A double numeric parameter for duration values. The returned value will
always be in milliseconds.

.. versionadded:: 3.22
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    explicit QgsProcessingParameterDuration( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        bool optional = false,
        double minValue = -DBL_MAX + 1,
        double maxValue = DBL_MAX );
%Docstring
Constructor for QgsProcessingParameterDuration.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End

    virtual QgsProcessingParameterDuration *clone() const /Factory/;


    virtual QString type() const;

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


    Qgis::TemporalUnit defaultUnit() const;
%Docstring
Returns the default duration unit for the parameter.

.. seealso:: :py:func:`setDefaultUnit`
%End

    void setDefaultUnit( Qgis::TemporalUnit unit );
%Docstring
Sets the default duration ``unit`` for the parameter.

.. seealso:: :py:func:`defaultUnit`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


};

class QgsProcessingParameterScale : QgsProcessingParameterNumber
{
%Docstring(signature="appended")
A double numeric parameter for map scale values.

:py:class:`QgsProcessingParameterScale` should be evaluated by calling
:py:func:`QgsProcessingAlgorithm.parameterAsDouble()`, which will return
a numeric value representing the scale denominator.

.. versionadded:: 3.8
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    explicit QgsProcessingParameterScale( const QString &name, const QString &description = QString(),
                                          const QVariant &defaultValue = QVariant(),
                                          bool optional = false );
%Docstring
Constructor for QgsProcessingParameterScale.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End

    virtual QgsProcessingParameterScale *clone() const /Factory/;


    virtual QString type() const;

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


    static QgsProcessingParameterScale *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterRange : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A numeric range parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterRange( const QString &name, const QString &description = QString(),
                                 Qgis::ProcessingNumberParameterType type = Qgis::ProcessingNumberParameterType::Integer,
                                 const QVariant &defaultValue = QVariant(),
                                 bool optional = false );
%Docstring
Constructor for QgsProcessingParameterRange.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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


    Qgis::ProcessingNumberParameterType dataType() const;
%Docstring
Returns the acceptable data type for the range.

.. seealso:: :py:func:`setDataType`
%End

    void setDataType( Qgis::ProcessingNumberParameterType dataType );
%Docstring
Sets the acceptable data ``type`` for the range.

.. seealso:: :py:func:`dataType`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterRange *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterRasterLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A raster layer parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterRasterLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                       bool optional = false );
%Docstring
Constructor for QgsProcessingParameterRasterLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString createFileFilter() const;


    static QgsProcessingParameterRasterLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterEnum : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
An enum based parameter for processing algorithms, allowing for
selection from predefined values.

Since QGIS 3.24 a list of icons corresponding to the enum values can be
specified by setting the widget wrapper metadata "icons" option, as
demonstrated below. The "icons" value should be set to a list of QIcon
values.

.. code-block:: python

       param = QgsProcessingParameterEnum( 'FIELD_TYPE', 'Field type', ['Integer', 'String'])
       param.setMetadata( {'widget_wrapper':
         { 'icons': [QIcon('integer.svg'), QIcon('string.svg')] }
       })
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterEnum.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

    virtual QString asScriptCode() const;

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


    QStringList options() const;
%Docstring
Returns the list of acceptable options for the parameter.

.. seealso:: :py:func:`setOptions`
%End

    void setOptions( const QStringList &options );
%Docstring
Sets the list of acceptable ``options`` for the parameter.

.. seealso:: :py:func:`options`
%End

    bool allowMultiple() const;
%Docstring
Returns ``True`` if the parameter allows multiple selected values.

.. seealso:: :py:func:`setAllowMultiple`
%End

    void setAllowMultiple( bool allowMultiple );
%Docstring
Sets whether the parameter allows multiple selected values.

.. seealso:: :py:func:`allowMultiple`
%End

    bool usesStaticStrings() const;
%Docstring
Returns ``True`` if the parameter uses static (non-translated) string
values for its enumeration choice list.

.. seealso:: :py:func:`setUsesStaticStrings`

.. versionadded:: 3.18
%End

    void setUsesStaticStrings( bool usesStaticStrings );
%Docstring
Sets whether the parameter uses static (non-translated) string values
for its enumeration choice list.

.. seealso:: :py:func:`usesStaticStrings`

.. versionadded:: 3.18
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterEnum *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterString : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A string parameter for processing algorithms.

A parameter type which allows users to enter any string value.

In some circumstances it is desirable to restrict the values available
when a user is asked to enter a string parameter to a list of
predetermined "valid" values. Since QGIS 3.22 this can be done by
setting the widget wrapper metadata "value_hints" option, as
demonstrated below. (While this provides a mechanism for guiding users
to select from valid string values when running a Processing algorithm
through the GUI, it does not place any limits on the string values
accepted via PyQGIS codes or when running the algorithm via other
non-gui means. Algorithms should gracefully handle other values
accordingly.)

.. code-block:: python

       param = QgsProcessingParameterString( 'PRINTER_NAME', 'Printer name')
       # show only printers which are available on the current system as options
       # for the string input.
       param.setMetadata( {'widget_wrapper':
         { 'value_hints': ['Inkjet printer', 'Laser printer'] }
       })
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterString( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                  bool multiLine = false,
                                  bool optional = false );
%Docstring
Constructor for QgsProcessingParameterString.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;

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


    bool multiLine() const;
%Docstring
Returns ``True`` if the parameter allows multiline strings.

.. seealso:: :py:func:`setMultiLine`
%End

    void setMultiLine( bool multiLine );
%Docstring
Sets whether the parameter allows multiline strings.

.. seealso:: :py:func:`multiLine`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterString *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterAuthConfig : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A string parameter for authentication configuration ID values.

This parameter allows for users to select from available authentication
configurations, or create new authentication configurations as required.

:py:class:`QgsProcessingParameterAuthConfig` should be evaluated by
calling :py:func:`QgsProcessingAlgorithm.parameterAsString()`.

.. versionadded:: 3.6
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterAuthConfig( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                      bool optional = false );
%Docstring
Constructor for QgsProcessingParameterAuthConfig.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;


    static QgsProcessingParameterAuthConfig *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterExpression : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
An expression parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterExpression.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QStringList dependsOnOtherParameters() const;

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


    QString parentLayerParameterName() const;
%Docstring
Returns the name of the parent layer parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentLayerParameterName`
%End

    void setParentLayerParameterName( const QString &parentLayerParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentLayerParameterName`
%End

    Qgis::ExpressionType expressionType() const;
%Docstring
Returns the parameter's expression type.

.. seealso:: :py:func:`setExpressionType`

.. versionadded:: 3.32
%End

    void setExpressionType( Qgis::ExpressionType type );
%Docstring
Sets the parameter's expression ``type``.

.. seealso:: :py:func:`expressionType`

.. versionadded:: 3.32
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterExpression *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterLimitedDataTypes
{
%Docstring(signature="appended")
Can be inherited by parameters which require limits to their acceptable
data types.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterLimitedDataTypes( const QList< int > &types = QList< int >() );
%Docstring
Constructor for QgsProcessingParameterLimitedDataTypes, with a list of
acceptable data ``types``.
%End

    QList< int > dataTypes() const;
%Docstring
Returns the geometry types for sources acceptable by the parameter.

.. seealso:: :py:func:`setDataTypes`
%End

    void setDataTypes( const QList< int > &types );
%Docstring
Sets the geometry ``types`` for sources acceptable by the parameter.

.. seealso:: :py:func:`dataTypes`
%End

  protected:

};

class QgsProcessingParameterVectorLayer : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A vector layer (with or without geometry) parameter for processing
algorithms. Consider using the more versatile
:py:class:`QgsProcessingParameterFeatureSource` wherever possible.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterVectorLayer( const QString &name,
                                       const QString &description = QString(),
                                       const QList< int > &types = QList< int >(),
                                       const QVariant &defaultValue = QVariant(),
                                       bool optional = false );
%Docstring
Constructor for QgsProcessingParameterVectorLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

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

    virtual QString createFileFilter() const;


    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterVectorLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterMeshLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A mesh layer parameter for processing algorithms.

.. versionadded:: 3.6
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterMeshLayer( const QString &name,
                                     const QString &description = QString(),
                                     const QVariant &defaultValue = QVariant(),
                                     bool optional = false );
%Docstring
Constructor for QgsProcessingParameterMeshLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString createFileFilter() const;


    static QgsProcessingParameterMeshLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};

class QgsProcessingParameterMapLayer : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A map layer parameter for processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterMapLayer( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                    bool optional = false,
                                    const QList< int > &types = QList< int >() );
%Docstring
Constructor for QgsProcessingParameterMapLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString asScriptCode() const;

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

    virtual QString createFileFilter() const;


    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterMapLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterField : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A vector layer or feature source field parameter for processing
algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterField.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString asScriptCode() const;

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

    virtual QStringList dependsOnOtherParameters() const;


    QString parentLayerParameterName() const;
%Docstring
Returns the name of the parent layer parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentLayerParameterName`
%End

    void setParentLayerParameterName( const QString &parentLayerParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentLayerParameterName`
%End

    Qgis::ProcessingFieldParameterDataType dataType() const;
%Docstring
Returns the acceptable data type for the field.

.. seealso:: :py:func:`setDataType`
%End

    void setDataType( Qgis::ProcessingFieldParameterDataType type );
%Docstring
Sets the acceptable data ``type`` for the field.

.. seealso:: :py:func:`dataType`
%End

    bool allowMultiple() const;
%Docstring
Returns whether multiple field selections are permitted.

.. seealso:: :py:func:`setAllowMultiple`
%End

    void setAllowMultiple( bool allowMultiple );
%Docstring
Sets whether multiple field selections are permitted.

.. seealso:: :py:func:`allowMultiple`
%End

    bool defaultToAllFields() const;
%Docstring
Returns whether a parameter which allows multiple selections (see
:py:func:`~QgsProcessingParameterField.allowMultiple`) should
automatically select all fields as the default value.

If ``True``, this will override any existing
:py:func:`~QgsProcessingParameterField.defaultValue` set on the
parameter.

.. seealso:: :py:func:`setDefaultToAllFields`

.. versionadded:: 3.12
%End

    void setDefaultToAllFields( bool enabled );
%Docstring
Sets whether a parameter which allows multiple selections (see
:py:func:`~QgsProcessingParameterField.allowMultiple`) should
automatically select all fields as the default value.

If ``True``, this will override any existing
:py:func:`~QgsProcessingParameterField.defaultValue` set on the
parameter.

.. seealso:: :py:func:`defaultToAllFields`

.. versionadded:: 3.12
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterField *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterFeatureSource : QgsProcessingParameterDefinition, QgsProcessingParameterLimitedDataTypes, QgsFileFilterGenerator
{
%Docstring(signature="appended")
An input feature source (such as vector layers) parameter for processing
algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterFeatureSource( const QString &name, const QString &description = QString(),
                                         const QList< int > &types = QList< int >(),
                                         const QVariant &defaultValue = QVariant(), bool optional = false );
%Docstring
Constructor for QgsProcessingParameterFeatureSource.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString asScriptCode() const;

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

    virtual QString createFileFilter() const;


    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterFeatureSource *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingDestinationParameter : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
Base class for all parameter definitions which represent file or layer
destinations, e.g. parameters which are used for the destination for
layers output by an algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingDestinationParameter( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                       bool optional = false, bool createByDefault = true );
%Docstring
Constructor for QgsProcessingDestinationParameter.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then the destination output will not be created by default.
%End

    virtual bool isDestination() const;
    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );

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

    virtual QString createFileFilter() const;


    virtual QgsProcessingOutputDefinition *toOutputDefinition() const = 0 /Factory/;
%Docstring
Returns a new :py:class:`QgsProcessingOutputDefinition` corresponding to
the definition of the destination parameter.
%End

    bool supportsNonFileBasedOutput() const;
%Docstring
Returns ``True`` if the destination parameter supports non filed-based
outputs, such as memory layers or direct database outputs.

.. seealso:: :py:func:`setSupportsNonFileBasedOutput`
%End

    void setSupportsNonFileBasedOutput( bool supportsNonFileBasedOutput );
%Docstring
Sets whether the destination parameter supports non filed-based outputs,
such as memory layers or direct database outputs.

.. seealso:: :py:func:`supportsNonFileBasedOutput`
%End

    virtual QString defaultFileExtension() const = 0;
%Docstring
Returns the default file extension for destination file paths associated
with this parameter.
%End

    virtual QString generateTemporaryDestination( const QgsProcessingContext *context = 0 ) const;
%Docstring
Generates a temporary destination value for this parameter. The returned
value will be a file path or QGIS data provider URI suitable for
temporary storage of created layers and files.
%End

    virtual bool isSupportedOutputValue( const QVariant &value, QgsProcessingContext &context, QString &error /Out/ ) const;
%Docstring
Tests whether a ``value`` is a supported value for this parameter.

Will return ``False`` when a ``value`` with an unsupported file
extension is specified. The default implementation calls
:py:func:`QgsProcessingProvider.isSupportedOutputValue()` to test
compatibility.

:param value: value to test
:param context: Processing context

:return: - ``True`` if ``value`` is supported.
         - error: a descriptive error string

.. versionadded:: 3.14
%End

    bool createByDefault() const;
%Docstring
Returns ``True`` if the destination should be created by default. For
optional parameters, a return value of ``False`` indicates that the
destination should not be created by default.

.. seealso:: :py:func:`setCreateByDefault`
%End

    void setCreateByDefault( bool createByDefault );
%Docstring
Sets whether the destination should be created by default. For optional
parameters, a value of ``False`` indicates that the destination should
not be created by default.

.. seealso:: :py:func:`createByDefault`
%End

  protected:

    QgsProcessingProvider *originalProvider() const;
%Docstring
Original (source) provider which this parameter has been derived from.
In the case of destination parameters which are part of model
algorithms, this will reflect the child algorithm's provider which
actually generates the parameter, as opposed to the provider which this
parameter belongs to (i.e. the model provider)

.. versionadded:: 3.2
%End

};


class QgsProcessingParameterFeatureSink : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A feature sink output for processing algorithms.

A parameter which represents the destination feature sink for features
created by an algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterFeatureSink.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString asScriptCode() const;

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

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

    virtual QString createFileFilter() const;


    virtual QStringList supportedOutputVectorLayerExtensions() const;
%Docstring
Returns a list of the vector format file extensions supported by this
parameter.

.. seealso:: :py:func:`defaultFileExtension`

.. versionadded:: 3.2
%End

    Qgis::ProcessingSourceType dataType() const;
%Docstring
Returns the layer type for sinks associated with the parameter.

.. seealso:: :py:func:`setDataType`
%End

    bool hasGeometry() const;
%Docstring
Returns ``True`` if sink is likely to include geometries. In cases were
presence of geometry cannot be reliably determined in advance, this
method will default to returning ``True``.
%End

    void setDataType( Qgis::ProcessingSourceType type );
%Docstring
Sets the layer ``type`` for the sinks associated with the parameter.

.. seealso:: :py:func:`dataType`
%End

    bool supportsAppend() const;
%Docstring
Returns ``True`` if the sink supports appending features to an existing
table.

A sink only supports appending if the algorithm implements
:py:class:`QgsProcessingAlgorithm`.sinkProperties for the sink
parameter.

.. seealso:: :py:func:`setSupportsAppend`

.. versionadded:: 3.14
%End

    void setSupportsAppend( bool supportsAppend );
%Docstring
Sets whether the sink supports appending features to an existing table.

.. warning::

   A sink only supports appending if the algorithm implements :py:class:`QgsProcessingAlgorithm`.sinkProperties for the sink parameter.

.. seealso:: :py:func:`supportsAppend`

.. versionadded:: 3.14
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );

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


    static QgsProcessingParameterFeatureSink *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterVectorDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A vector layer destination parameter, for specifying the destination
path for a vector layer created by the algorithm.

.. note::

   Consider using the more flexible :py:class:`QgsProcessingParameterFeatureSink` wherever
   possible.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterVectorDestination.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString asScriptCode() const;

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

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

    virtual QString createFileFilter() const;


    virtual QStringList supportedOutputVectorLayerExtensions() const;
%Docstring
Returns a list of the vector format file extensions supported by this
parameter.

.. seealso:: :py:func:`defaultFileExtension`

.. versionadded:: 3.2
%End

    Qgis::ProcessingSourceType dataType() const;
%Docstring
Returns the layer type for this created vector layer.

.. seealso:: :py:func:`setDataType`
%End

    bool hasGeometry() const;
%Docstring
Returns ``True`` if the created layer is likely to include geometries.
In cases were presence of geometry cannot be reliably determined in
advance, this method will default to returning ``True``.
%End

    void setDataType( Qgis::ProcessingSourceType type );
%Docstring
Sets the layer ``type`` for the created vector layer.

.. seealso:: :py:func:`dataType`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterVectorDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End


};

class QgsProcessingParameterRasterDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A raster layer destination parameter, for specifying the destination
path for a raster layer created by the algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterRasterDestination( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        bool optional = false,
        bool createByDefault = true );
%Docstring
Constructor for QgsProcessingParameterRasterDestination.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

    virtual QString createFileFilter() const;


    virtual QStringList supportedOutputRasterLayerExtensions() const;
%Docstring
Returns a list of the raster format file extensions supported for this
parameter.

.. seealso:: :py:func:`defaultFileExtension`

.. versionadded:: 3.2
%End

    static QgsProcessingParameterRasterDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};

class QgsProcessingParameterFileDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A generic file based destination parameter, for specifying the
destination path for a file (non-map layer) created by the algorithm.

In some circumstances it is desirable to avoid the usual file
overwriting confirmation prompt when users select an existing
destination file for this parameter type (e.g., for algorithms which
append to an existing destination file instead of overwriting them.).
This can be done by setting the widget wrapper metadata
"dontconfirmoverwrite" option:

.. code-block:: python

       param = QgsProcessingParameterFileDestination( 'OUTPUT', 'Destination file')
       # don't show the file overwrite warning when users select a destination file:
       param.setMetadata( {'widget_wrapper':
         { 'dontconfirmoverwrite': True }
       })
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterFileDestination( const QString &name, const QString &description = QString(),
                                           const QString &fileFilter = QString(),
                                           const QVariant &defaultValue = QVariant(),
                                           bool optional = false,
                                           bool createByDefault = true );
%Docstring
Constructor for QgsProcessingParameterFileDestination.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

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

    virtual QString createFileFilter() const;


    QString fileFilter() const;
%Docstring
Returns the file filter string for file destinations compatible with
this parameter.

.. seealso:: :py:func:`setFileFilter`
%End

    void setFileFilter( const QString &filter );
%Docstring
Sets the file ``filter`` string for file destinations compatible with
this parameter.

.. seealso:: :py:func:`fileFilter`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterFileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End


};

class QgsProcessingParameterFolderDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A folder destination parameter, for specifying the destination path for
a folder created by the algorithm or used for creating new files within
the algorithm.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterFolderDestination( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        bool optional = false,
        bool createByDefault = true );
%Docstring
Constructor for QgsProcessingParameterFolderDestination.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;


    static QgsProcessingParameterFolderDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterBand : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A raster band parameter for Processing algorithms.
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterBand( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                const QString &parentLayerParameterName = QString(),
                                bool optional = false,
                                bool allowMultiple = false );
%Docstring
Constructor for QgsProcessingParameterBand.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString asScriptCode() const;

    virtual QStringList dependsOnOtherParameters() const;

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


    QString parentLayerParameterName() const;
%Docstring
Returns the name of the parent layer parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentLayerParameterName`
%End

    void setParentLayerParameterName( const QString &parentLayerParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentLayerParameterName`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterBand *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

    bool allowMultiple() const;
%Docstring
Returns whether multiple band selections are permitted.

.. seealso:: :py:func:`setAllowMultiple`

.. versionadded:: 3.4
%End

    void setAllowMultiple( bool allowMultiple );
%Docstring
Sets whether multiple band selections are permitted.

.. seealso:: :py:func:`allowMultiple`

.. versionadded:: 3.4
%End

};

class QgsProcessingParameterLayout : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A print layout parameter, allowing users to select a print layout.

:py:class:`QgsProcessingParameterLayout` should be evaluated by calling
:py:func:`QgsProcessingAlgorithm.parameterAsLayout()`. This will return
the matching layout from the context's current project. Alternatively,
calling :py:func:`QgsProcessingAlgorithm.parameterAsString()` will
return the name of the target print layout.

.. versionadded:: 3.8
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterLayout( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                  bool optional = false );
%Docstring
Constructor for QgsProcessingParameterLayout.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;

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


    static QgsProcessingParameterLayout *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterLayoutItem : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A print layout item parameter, allowing users to select a particular
item from a print layout.

:py:class:`QgsProcessingParameterLayoutItem` should be evaluated by
calling :py:func:`QgsProcessingAlgorithm.parameterAsLayoutItem()`.
Internally, :py:class:`QgsProcessingParameterLayoutItems` are string
parameters, storing references to items either by their UUID
(:py:func:`QgsLayoutItem.uuid()`) or ID (:py:func:`QgsLayoutItem.id()`).

.. versionadded:: 3.8
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterLayoutItem( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                      const QString &parentLayoutParameterName = QString(),
                                      int itemType = -1,
                                      bool optional = false );
%Docstring
Constructor for QgsProcessingParameterLayoutItem.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual QString valueAsPythonString( 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 );

    virtual QStringList dependsOnOtherParameters() const;


    static QgsProcessingParameterLayoutItem *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

    QString parentLayoutParameterName() const;
%Docstring
Returns the name of the parent layout parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentLayoutParameterName`
%End

    void setParentLayoutParameterName( const QString &name );
%Docstring
Sets the ``name`` of the parent layout parameter. Use an empty string if
this is not required.

.. seealso:: :py:func:`parentLayoutParameterName`
%End

    int itemType() const;
%Docstring
Returns the acceptable item type, or -1 if any item type is allowed.

These values correspond to the registered item types from
:py:class:`QgsLayoutItemRegistry`.

.. seealso:: :py:func:`setItemType`
%End

    void setItemType( int type );
%Docstring
Sets the acceptable item ``type``, or -1 if any item type is allowed.

These values correspond to the registered item types from
:py:class:`QgsLayoutItemRegistry`.

.. seealso:: :py:func:`itemType`
%End

};

class QgsProcessingParameterColor : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A color parameter for processing algorithms.

:py:class:`QgsProcessingParameterColor` should be evaluated by calling
:py:func:`QgsProcessingAlgorithm.parameterAsColor()`.

.. versionadded:: 3.10
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterColor( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                 bool opacityEnabled = true,
                                 bool optional = false );
%Docstring
Constructor for QgsProcessingParameterColor.

If ``opacityEnabled`` is ``True``, then users will have the option of
varying color opacity.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;

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

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

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    bool opacityEnabled() const;
%Docstring
Returns ``True`` if the parameter allows opacity control.

The default behavior is to allow users to set opacity for the color.

.. seealso:: :py:func:`setOpacityEnabled`
%End

    void setOpacityEnabled( bool enabled );
%Docstring
Sets whether the parameter allows opacity control.

The default behavior is to allow users to set opacity for the color.

.. seealso:: :py:func:`opacityEnabled`
%End

    static QgsProcessingParameterColor *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterCoordinateOperation : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A coordinate operation parameter for processing algorithms, for
selection between available coordinate operations to use when projecting
between a source and destination coordinate reference system.

:py:class:`QgsProcessingParameterCoordinateOperation` should be
evaluated by calling
:py:func:`QgsProcessingAlgorithm.parameterAsString()`.

.. versionadded:: 3.12
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterCoordinateOperation.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

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

    virtual QString asScriptCode() const;

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

    virtual QStringList dependsOnOtherParameters() const;


    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterCoordinateOperation *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

    QString sourceCrsParameterName() const;
%Docstring
Returns the name of the source CRS parameter, or an empty string if this
is not set.

.. seealso:: :py:func:`setSourceCrsParameterName`

.. seealso:: :py:func:`destinationCrsParameterName`
%End

    void setSourceCrsParameterName( const QString &name );
%Docstring
Sets the ``name`` of the source CRS parameter. Use an empty string if
this is not required.

.. seealso:: :py:func:`sourceCrsParameterName`

.. seealso:: :py:func:`setDestinationCrsParameterName`
%End

    QString destinationCrsParameterName() const;
%Docstring
Returns the name of the destination CRS parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setDestinationCrsParameterName`

.. seealso:: :py:func:`sourceCrsParameterName`
%End

    void setDestinationCrsParameterName( const QString &name );
%Docstring
Sets the ``name`` of the destination CRS parameter. Use an empty string
if this is not required.

.. seealso:: :py:func:`destinationCrsParameterName`

.. seealso:: :py:func:`setSourceCrsParameterName`
%End

    QVariant sourceCrs() const;
%Docstring
Returns the static source CRS, or an invalid value if this is not set.

.. seealso:: :py:func:`setSourceCrs`

.. seealso:: :py:func:`destinationCrs`
%End

    void setSourceCrs( const QVariant &crs );
%Docstring
Sets the static source ``crs``.

.. seealso:: :py:func:`sourceCrs`

.. seealso:: :py:func:`setDestinationCrs`
%End

    QVariant destinationCrs() const;
%Docstring
Returns the static destination CRS, or an invalid value if this is not
set.

.. seealso:: :py:func:`setDestinationCrs`

.. seealso:: :py:func:`sourceCrs`
%End

    void setDestinationCrs( const QVariant &crs );
%Docstring
Sets the static destination ``crs``.

.. seealso:: :py:func:`destinationCrs`

.. seealso:: :py:func:`setSourceCrs`
%End

};


class QgsProcessingParameterMapTheme : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A map theme parameter for processing algorithms, allowing users to
select an existing map theme from a project.

:py:class:`QgsProcessingParameterMapTheme` should be evaluated by
calling :py:func:`QgsProcessingAlgorithm.parameterAsString()`.

.. versionadded:: 3.12
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterMapTheme( const QString &name, const QString &description = QString(), const QVariant &defaultValue = QVariant(),
                                    bool optional = false );
%Docstring
Constructor for QgsProcessingParameterMapTheme.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString valueAsPythonString( 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 );


    static QgsProcessingParameterMapTheme *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterDateTime : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A datetime (or pure date or time) parameter for processing algorithms.

:py:class:`QgsProcessingParameterDateTime` should be evaluated by
calling :py:func:`QgsProcessingAlgorithm.parameterAsDateTime()`, which
will return a date time value.

.. versionadded:: 3.14
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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()
                                           );
%Docstring
Constructor for QgsProcessingParameterDateTime.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString toolTip() const;

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


    QDateTime minimum() const;
%Docstring
Returns the minimum value acceptable by the parameter.

An invalid QDateTime value indicates no minimum value.

.. seealso:: :py:func:`setMinimum`
%End

    void setMinimum( const QDateTime &minimum );
%Docstring
Sets the ``minimum`` value acceptable by the parameter.

An invalid QDateTime value indicates no minimum value.

If the :py:func:`~QgsProcessingParameterDateTime.dataType` is
QgsProcessingParameterDateTime.Time, then the date component of
``minimum`` must be set to any valid date (but this date will not
actually be considered when comparing parameter values to the specified
minimum value, only the time component will be considered).

.. seealso:: :py:func:`minimum`
%End

    QDateTime maximum() const;
%Docstring
Returns the maximum value acceptable by the parameter.

An invalid QDateTime value indicates no maximum value.

.. seealso:: :py:func:`setMaximum`
%End

    void setMaximum( const QDateTime &maximum );
%Docstring
Sets the ``maximum`` value acceptable by the parameter.

An invalid QDateTime value indicates no maximum value.

If the :py:func:`~QgsProcessingParameterDateTime.dataType` is
QgsProcessingParameterDateTime.Time, then the date component of
``maximum`` must be set to any valid date (but this date will not
actually be considered when comparing parameter values to the specified
maximum value, only the time component will be considered).

.. seealso:: :py:func:`maximum`
%End

    Qgis::ProcessingDateTimeParameterDataType dataType() const;
%Docstring
Returns the acceptable data type for the parameter.

.. seealso:: :py:func:`setDataType`
%End

    void setDataType( Qgis::ProcessingDateTimeParameterDataType type );
%Docstring
Sets the acceptable data ``type`` for the parameter.

.. seealso:: :py:func:`dataType`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterDateTime *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterProviderConnection : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A data provider connection parameter for processing algorithms, allowing
users to select from available registered connections for a particular
data provider.

:py:class:`QgsProcessingParameterProviderConnection` should be evaluated
by calling
:py:func:`QgsProcessingAlgorithm.parameterAsConnectionName()`.

.. versionadded:: 3.14
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterProviderConnection( const QString &name, const QString &description, const QString &provider, const QVariant &defaultValue = QVariant(),
        bool optional = false );
%Docstring
Constructor for QgsProcessingParameterProviderConnection, for the
specified ``provider`` type.

.. warning::

   The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
   in order for the model to work correctly. This is only implemented for a subset of current data providers.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString valueAsPythonString( 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 );


    QString providerId() const;
%Docstring
Returns the ID of the provider associated with the connections.

.. seealso:: :py:func:`setProviderId`
%End

    void setProviderId( const QString &provider );
%Docstring
Sets the ID of the ``provider`` associated with the connections.

.. seealso:: :py:func:`providerId`
%End

    static QgsProcessingParameterProviderConnection *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterDatabaseSchema : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A database schema parameter for processing algorithms, allowing users to
select from existing schemas on a registered database connection.

:py:class:`QgsProcessingParameterDatabaseSchema` should be evaluated by
calling :py:func:`QgsProcessingAlgorithm.parameterAsSchema()`.

.. versionadded:: 3.14
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterDatabaseSchema( const QString &name, const QString &description, const QString &connectionParameterName = QString(), const QVariant &defaultValue = QVariant(),
                                          bool optional = false );
%Docstring
Constructor for QgsProcessingParameterDatabaseSchema.

The ``connectionParameterName`` specifies the name of the parent
:py:class:`QgsProcessingParameterProviderConnection` parameter.

.. warning::

   The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
   in order for the model to work correctly. This is only implemented for a subset of current data providers.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString valueAsPythonString( 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 );

    virtual QStringList dependsOnOtherParameters() const;


    QString parentConnectionParameterName() const;
%Docstring
Returns the name of the parent connection parameter, or an empty string
if this is not set.

.. seealso:: :py:func:`setParentConnectionParameterName`
%End

    void setParentConnectionParameterName( const QString &name );
%Docstring
Sets the ``name`` of the parent connection parameter. Use an empty
string if this is not required.

.. seealso:: :py:func:`parentConnectionParameterName`
%End

    static QgsProcessingParameterDatabaseSchema *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};


class QgsProcessingParameterDatabaseTable : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A database table name parameter for processing algorithms, allowing
users to select from existing database tables on a registered database
connection (or optionally to enter a new table name).

:py:class:`QgsProcessingParameterDatabaseTable` should be evaluated by
calling
:py:func:`QgsProcessingAlgorithm.parameterAsDatabaseTableName()`.

.. versionadded:: 3.14
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for QgsProcessingParameterDatabaseTable.

The ``connectionParameterName`` specifies the name of the parent
:py:class:`QgsProcessingParameterProviderConnection` parameter. The
``schemaParameterName`` specifies the name of the parent
:py:class:`QgsProcessingParameterDatabaseSchema` parameter.

.. warning::

   The provider must support the connection API methods in its :py:class:`QgsProviderMetadata` implementation
   in order for the model to work correctly. This is only implemented for a subset of current data providers.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

    virtual QString valueAsPythonString( 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 );

    virtual QStringList dependsOnOtherParameters() const;


    QString parentConnectionParameterName() const;
%Docstring
Returns the name of the parent connection parameter, or an empty string
if this is not set.

.. seealso:: :py:func:`setParentConnectionParameterName`
%End

    void setParentConnectionParameterName( const QString &name );
%Docstring
Sets the ``name`` of the parent connection parameter. Use an empty
string if this is not required.

.. seealso:: :py:func:`parentConnectionParameterName`
%End

    QString parentSchemaParameterName() const;
%Docstring
Returns the name of the parent schema parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentSchemaParameterName`
%End

    void setParentSchemaParameterName( const QString &name );
%Docstring
Sets the ``name`` of the parent schema parameter. Use an empty string if
this is not required.

.. seealso:: :py:func:`parentSchemaParameterName`
%End

    static QgsProcessingParameterDatabaseTable *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

    bool allowNewTableNames() const;
%Docstring
Returns ``True`` if the parameter allows users to enter names for a new
(non-existing) tables.

.. seealso:: :py:func:`setAllowNewTableNames`
%End

    void setAllowNewTableNames( bool allowed );
%Docstring
Sets whether the parameter allows users to enter names for a new
(non-existing) tables.

.. seealso:: :py:func:`allowNewTableNames`
%End

};


class QgsProcessingParameterPointCloudLayer : QgsProcessingParameterDefinition, QgsFileFilterGenerator
{
%Docstring(signature="appended")
A point cloud layer parameter for processing algorithms.

.. versionadded:: 3.22
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterPointCloudLayer( const QString &name, const QString &description = QString(),
                                           const QVariant &defaultValue = QVariant(), bool optional = false );
%Docstring
Constructor for QgsProcessingParameterPointCloudLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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

    virtual QString createFileFilter() const;


    static QgsProcessingParameterPointCloudLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};


class QgsProcessingParameterAnnotationLayer : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
An annotation layer parameter for processing algorithms.

.. versionadded:: 3.22
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterAnnotationLayer( const QString &name, const QString &description = QString(),
                                           const QVariant &defaultValue = QVariant(), bool optional = false );
%Docstring
Constructor for QgsProcessingParameterAnnotationLayer.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

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

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


    static QgsProcessingParameterAnnotationLayer *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};

class QgsProcessingParameterPointCloudDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A point cloud layer destination parameter, for specifying the
destination path for a point cloud layer created by the algorithm.

.. versionadded:: 3.24
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterPointCloudDestination( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        bool optional = false,
        bool createByDefault = true );
%Docstring
Constructor for QgsProcessingParameterPointCloudDestination.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

    virtual QString createFileFilter() const;


    virtual QStringList supportedOutputPointCloudLayerExtensions() const;
%Docstring
Returns a list of the point cloud format file extensions supported for
this parameter.

.. seealso:: :py:func:`defaultFileExtension`
%End

    static QgsProcessingParameterPointCloudDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};

class QgsProcessingParameterPointCloudAttribute : QgsProcessingParameterDefinition
{
%Docstring(signature="appended")
A point cloud layer attribute parameter for Processing algorithms.

.. versionadded:: 3.32
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  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 );
%Docstring
Constructor for :py:class:`QgsProcessingParameterField`.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QString asScriptCode() const;

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

    virtual QStringList dependsOnOtherParameters() const;


    QString parentLayerParameterName() const;
%Docstring
Returns the name of the parent layer parameter, or an empty string if
this is not set.

.. seealso:: :py:func:`setParentLayerParameterName`
%End

    void setParentLayerParameterName( const QString &parentLayerParameterName );
%Docstring
Sets the name of the parent layer parameter. Use an empty string if this
is not required.

.. seealso:: :py:func:`parentLayerParameterName`
%End

    bool allowMultiple() const;
%Docstring
Returns whether multiple field selections are permitted.

.. seealso:: :py:func:`setAllowMultiple`
%End

    void setAllowMultiple( bool allowMultiple );
%Docstring
Sets whether multiple field selections are permitted.

.. seealso:: :py:func:`allowMultiple`
%End

    bool defaultToAllAttributes() const;
%Docstring
Returns whether a parameter which allows multiple selections (see
:py:func:`~QgsProcessingParameterPointCloudAttribute.allowMultiple`)
should automatically select all attributes as the default value.

If ``True``, this will override any existing
:py:func:`~QgsProcessingParameterPointCloudAttribute.defaultValue` set
on the parameter.

.. seealso:: :py:func:`setDefaultToAllAttributes`
%End

    void setDefaultToAllAttributes( bool enabled );
%Docstring
Sets whether a parameter which allows multiple selections (see
:py:func:`~QgsProcessingParameterPointCloudAttribute.allowMultiple`)
should automatically select all attributes as the default value.

If ``True``, this will override any existing
:py:func:`~QgsProcessingParameterPointCloudAttribute.defaultValue` set
on the parameter.

.. seealso:: :py:func:`defaultToAllAttributes`
%End

    virtual QVariantMap toVariantMap() const;

    virtual bool fromVariantMap( const QVariantMap &map );


    static QgsProcessingParameterPointCloudAttribute *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End

};

class QgsProcessingParameterVectorTileDestination : QgsProcessingDestinationParameter
{
%Docstring(signature="appended")
A vector tile layer destination parameter, for specifying the
destination path for a vector tile layer created by the algorithm.

.. versionadded:: 3.32
%End

%TypeHeaderCode
#include "qgsprocessingparameters.h"
%End
  public:

    QgsProcessingParameterVectorTileDestination( const QString &name, const QString &description = QString(),
        const QVariant &defaultValue = QVariant(),
        bool optional = false,
        bool createByDefault = true );
%Docstring
Constructor for QgsProcessingParameterVectorTileDestination.

If ``createByDefault`` is ``False`` and the parameter is ``optional``,
then this destination output will not be created by default.
%End

    static QString typeName();
%Docstring
Returns the type name for the parameter class.
%End
    virtual QgsProcessingParameterDefinition *clone() const /Factory/;

    virtual QString type() const;
    virtual bool checkValueIsAcceptable( const QVariant &input, QgsProcessingContext *context = 0 ) const;

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

    virtual QgsProcessingOutputDefinition *toOutputDefinition() const /Factory/;

    virtual QString defaultFileExtension() const;

    virtual QString createFileFilter() const;


    virtual QStringList supportedOutputVectorTileLayerExtensions() const;
%Docstring
Returns a list of the point cloud format file extensions supported for
this parameter.

.. seealso:: :py:func:`defaultFileExtension`
%End

    static QgsProcessingParameterVectorTileDestination *fromScriptCode( const QString &name, const QString &description, bool isOptional, const QString &definition ) /Factory/;
%Docstring
Creates a new parameter using the definition from a script code.
%End
};




/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/processing/qgsprocessingparameters.h                        *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.py again   *
 ************************************************************************/