@arcgis/core/layers/support/rasterFunctionUtils.d.ts

ArcGIS Maps SDK for JavaScript: A complete 2D and 3D mapping and data visualization API

/**
 * Various utility functions that create [RasterFunction](https://developers.arcgis.com/javascript/latest/references/core/layers/support/RasterFunction/) for imagery processing.
 * Utility methods in this module makes the raster function generations easier when applying raster functions to
 * [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) and [ImageryTileLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryTileLayer/).
 *
 * @since 4.28
 */
import type RasterFunction from "./RasterFunction.js";
import type { Base2RasterFunctionParameters, BaseNRasterFunctionParameters, BaseRasterFunctionParameters, SlopeParameters, HillshadeParameters, ShadedReliefWithColormapParameters, ShadedReliefWithColorRampNameParameters, ShadedReliefWithColorRampParameters, CurvatureParameters, BAIBandParameters, CIgBandParameters, CIreBandParameters, ClayMineralsBandParameters, CustomBandParameters, EVIBandParameters, FerrousMineralsBandParameters, GDNVIBandParameters, GEMIBandParameters, IronOxideBandParameters, LandsatBandParameters, MNDWIBandParameters, MSAVIBandParameters, MTVI2BandParameters, NBRBandParameters, NDBIBandParameters, NDMIBandParameters, NDSIBandParameters, NDVIBandParameters, NDVIreBandParameters, NDWIBandParameters, PVIBandParameters, RTVICoreBandParameters, SAVIBandParameters, SRBandParameters, SRreBandParameters, SultanParameters, TSAVIBandParameters, VARIBandParameters, WNDWIBandParameters, ComputeChangeParameters, GrayscaleParameters, ColorspaceConversionParameters, SpectralConversionParameters, ClipParameters, ColorCompositeByIdParameters, ColorCompositeByNameParameters, ColormapByNameParameters, ColormapByRampParameters, ColormapParameters, ExtractBandByIdParameters, ExtractBandByNameParameters, ExtractBandByWavelengthParameters, MaskParameters, RemapParameters, StatisticsHistogramParameters, TableParameters, TransposeBitsParameters, SetNullParameters, ConditionalParameters, CalculatorParameters, WeightedOverlayParameters, WeightedSumParameters, ArgStatisticsDurationParameters, ArgStatisticsParameters, StatisticsParameters, BaseStretchParameters, ContrastBrightnessParameters, ConvolutionFunctionCustomParameters, ConvolutionFunctionParameters, MinMaxStretchParameters, PercentClipStretchParameters, StddevStretchParameters, CellStatisticsParameters } from "../raster/functions/types.js";

/**
 * Creates a Contrast And Brightness function that enhances the appearance of raster data by modifying the brightness and contrast within the image.
 * See [Contrast And Brightness function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/contrast-and-brightness-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.contrastBrightness({
 *   contrastOffset: 10,
 *   brightnessOffset: 8
 * });
 */
export function contrastBrightness(parameters: ContrastBrightnessParameters): RasterFunction;

/**
 * Creates a Stretch function using min-max stretch type. Pixel values inside [min, max] defined in the band's statistics are
 * stretched to [outputMin, outputMax], those fall outside are clamped to [outputMin, outputMax].
 * See [Stretch function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/stretch-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // stretch NDVI values from -1 to 1 to 0 to 255.
 * layer.rasterFunction = rasterFunctionUtils.stretchMinMax({
 *   statistics: [{min: -1, max: 1, avg: 0, stddev: 0.1}],
 *   outputPixelType: "u8"
 * });
 */
export function stretchMinMax(parameters: MinMaxStretchParameters): RasterFunction;

/**
 * Creates a Stretch function using standard-deviation stretch type. Pixel values inside the defined number of standard deviations are
 * stretched to [outputMin, outputMax], those fall outside are clamped to [outputMin, outputMax].
 * See [Stretch function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/stretch-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Stretch elevation values with in 2 standard deviations to 0 to 255.
 * layer.rasterFunction = rasterFunctionUtils.stretchStandardDeviation({
 *   numberOfStandardDeviations: 2,
 *   statistics: [{min: 20, max: 1200, avg: 600, stddev: 100}],
 *   outputPixelType: "u8"
 * });
 */
export function stretchStandardDeviation(parameters: StddevStretchParameters): RasterFunction;

/**
 * Creates a Stretch function using percent-clip stretch type. The input data must have histograms for it to work properly.
 * See [Stretch function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/stretch-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Stretch Landsat imagery using percent clip, pixels values within both lower 2% and
 * // upper 2% are clamped to output min (0) and output max (255).
 * layer.rasterFunction = rasterFunctionUtils.stretchPercentClip({
 *   minPercent: 2,
 *   maxPercent: 2,
 *   outputPixelType: "u8"
 * });
 */
export function stretchPercentClip(parameters: PercentClipStretchParameters): RasterFunction;

/**
 * Creates a Stretch function without a specific stretch method. Since output range can differ from pixel type's range, pixel values are projected to
 * the output range linearly based on pixel type. For aerial or satellite imagery, it simply adjusts radiometric resolution and preserves DN values
 * relatively. This is a no-op for all unsigned 8 bit images.
 * See [Stretch function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/stretch-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Apply no additional stretch, pixel values are simply fitted into 0 to 255 range.
 * layer.rasterFunction = rasterFunctionUtils.stretchNone({
 *   outputPixelType: "u8"
 * });
 */
export function stretchNone(parameters: BaseStretchParameters): RasterFunction;

/**
 * Creates a Convolution function that performs filtering using the given kernel to enhance the image, e.g.
 * sharpening an image, blurring an image, and detecting edges et al.
 * See [Convolution function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/convolution-function.htm).
 *
 * @param parameters - The parameters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Sharpen the image
 * layer.rasterFunction = rasterFunctionUtils.convolution({
 *   convolutionType: "sharpen"
 * });
 */
export function convolution(parameters: ConvolutionFunctionParameters | ConvolutionFunctionCustomParameters): RasterFunction;

/**
 * Creates a NDVI function. The Normalized Difference Vegetation Index (NDVI) method is a standardized index allowing you
 * to generate an image displaying greenness (relative biomass). This index takes advantage of the contrast of the characteristics
 * of two bands from a multispectral raster dataset—the chlorophyll pigment absorptions in the red band and the high reflectivity
 * of plant materials in the NIR band.
 *
 * Equation: NDVI = ((NIR - Red)/(NIR + Red))
 *
 * See [NDVI function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/ndvi-function.htm) and
 * [NDVI](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndvi.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NDVI from a 4-band image whose bands are arranged in BGRI order.
 * const ndvi = rasterFunctionUtils.bandArithmeticNDVI({
 *   nirBandId: 3,
 *   redBandId: 2
 * });
 * const colormap = rasterFunctionUtils.colormap({
 *   colorRampName: "NDVI3",
 *   raster: ndvi
 * });
 * layer.rasterFunction = colormap;
 */
export function bandArithmeticNDVI(parameters: NDVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate SAVI. The Soil-Adjusted Vegetation Index (SAVI) method is a vegetation index that attempts to
 * minimize soil brightness influences using a soil-brightness correction factor. This is often used in arid regions where vegetative
 * cover is low, and it outputs values between -1.0 and 1.0.
 *
 * Equation: SAVI = ((NIR - Red) / (NIR + Red + L)) x (1 + L)
 *
 * L = The amount of green vegetation cover
 *
 * See [SAVI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/savi.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates SAVI from a 4-band image whose bands are arranged in BGRI order.
 * const index = rasterFunctionUtils.bandArithmeticSAVI({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   factor: 0.33
 * });
 */
export function bandArithmeticSAVI(parameters: SAVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate TSAVI. The Transformed Soil Adjusted Vegetation Index (TSAVI) method is a vegetation index that minimizes
 * soil brightness influences by assuming the soil line has an arbitrary slope and intercept.
 * See [TSAVI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/tsavi.htm).
 *
 * Equation: TSAVI = (s * (NIR - s * Red - a)) / (a * NIR + Red - a * s + X * (1 + s * s))
 * s = the soil line slope
 * a = the soil line intercept
 * X = an adjustment factor that is set to minimize soil noise
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates TSAVI from a 4-band image whose bands are arranged in BGRI order.
 * const tsavi = rasterFunctionUtils.bandArithmeticTSAVI({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   slope: 0.33,
 *   intercept: 0.5,
 *   factor: 1.5
 * });
 */
export function bandArithmeticTSAVI(parameters: TSAVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate MSAVI. The Modified Soil Adjusted Vegetation Index (MSAVI) method minimizes the effect of bare soil on the SAVI.
 * See [MSAVI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/msavi.htm).
 *
 * Equation: MSAVI2 = 0.5 * ((2*NIR+1)-sqrt((2*NIR+1)*(2*NIR+1)-8(NIR-Red)))
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates MSAVI from a 4-band image whose bands are arranged in BGRI order.
 * const msavi = rasterFunctionUtils.bandArithmeticMSAVI({
 *   nirBandId: 3,
 *   redBandId: 2
 * });
 */
export function bandArithmeticMSAVI(parameters: MSAVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate GEMI. The Global Environmental Monitoring Index (GEMI) method is a nonlinear vegetation index for global environmental monitoring from satellite imagery.
 * It's similar to NDVI, but it's less sensitive to atmospheric effects. It is affected by bare soil; therefore, it's not recommended for use in areas
 * of sparse or moderately dense vegetation. See [GEMI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/gemi.htm).
 *
 * Equation: GEMI = eta * (1 - 0.25 * eta)-((Red - 0.125)/(1 - Red))
 * eta = (2 * (NIR * NIR - Red * Red) + 1.5 * NIR + 0.5 * Red)/(NIR + Red + 0.5)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates GEMI from a 4-band image whose bands are arranged in BGRI order.
 * const gemi = rasterFunctionUtils.bandArithmeticGEMI({
 *   nirBandId: 3,
 *   redBandId: 2
 * });
 */
export function bandArithmeticGEMI(parameters: GEMIBandParameters): RasterFunction;

/**
 * CCreates a Band Arithmetic function to calculate PVI. The Transformed Soil Adjusted Vegetation Index (TSAVI) method is a vegetation index that minimizes soil brightness
 * influences by assuming the soil line has an arbitrary slope and intercept. See [PVI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/pvi.htm).
 *
 * Equation: PVI = (NIR - a * Red - b) / (sqrt(1 + a*a))
 * a = slope of the soil line
 * b = gradient of the soil line
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates PVI from a 4-band image whose bands are arranged in BGRI order.
 * const pvi = rasterFunctionUtils.bandArithmeticPVI({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   slope: 0.3,
 *   gradient: 0.5
 * });
 */
export function bandArithmeticPVI(parameters: PVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate GVITM. The Green Vegetation Index (GVI) method was originally designed from Landsat MSS imagery and has been modified for
 * Landsat TM imagery. It's also known as the Landsat TM Tasseled Cap green vegetation index. It can be used with imagery whose bands share the same
 * spectral characteristics. See [GVITM raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/gvitm.htm).
 *
 * Equation: GVI = -0.2848 * Band1 - 0.2435 * Band2 - 0.5436 * Band3 + 0.7243 * Band4 + 0.0840 * Band5 - 0.1800 * Band7
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates GVITM from a Landsat TM multispectral scene.
 * const gvitm = rasterFunctionUtils.bandArithmeticGVITM({
 *   bandIds: [0, 1, 2, 3, 4, 5]
 * });
 */
export function bandArithmeticGVITM(parameters: LandsatBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate Sultan index. Creates a BandArithmetic function. The Sultan's process takes a six-band 8-bit image
 * and uses the Sultan's Formula method to produce a three-band 8-bit image. The resulting image highlights rock formations called ophiolites on coastlines.
 * This formula was designed based on the TM or ETM bands of a Landsat 5 or 7 scene.
 *
 * See [Sultan raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/sultan.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates Sultan 3 band output from a 6-band Landsat TM multispectral scene.
 * const sultan = rasterFunctionUtils.bandArithmeticSultan({
 *   bandIds: [0, 2, 3, 4, 5]
 * });
 */
export function bandArithmeticSultan(parameters: SultanParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate VARI. The Visible Atmospherically Resistant Index (VARI) method is a vegetation index for estimating vegetation
 * fraction quantitatively with only the visible range of the spectrum. See [VARI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/vari.htm).
 *
 * Equation: VARI = (Green - Red) / (Green + Red – Blue)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates VARI from a typical drone image.
 * const index = rasterFunctionUtils.bandArithmeticVARI({
 *   redBandId: 0,
 *   greenBandId: 1,
 *   blueBandId: 2
 * });
 */
export function bandArithmeticVARI(parameters: VARIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate GNDVI. The Green Normalized Difference Vegetation Index (GNDVI)
 * method is a vegetation index for estimating photo synthetic activity and is a commonly used
 * vegetation index to determine water and nitrogen uptake into the plant canopy.
 * See [GNDVI raster function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/band-arithmetic-function.htm#ESRI_SECTION2_5067FA1ACA5F4C18AB9D44EEFC0542A1).
 *
 * Equation: GNDVI = (NIR-Green)/(NIR+Green)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates GNDVI from a 4-band image whose bands are arranged in BGRI order.
 * const gndvi = rasterFunctionUtils.bandArithmeticGNDVI({
 *   nirBandId: 3,
 *   greenBandId: 1
 * });
 */
export function bandArithmeticGNDVI(parameters: GDNVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate SR. The Simple Ratio (SR) method is a common vegetation index
 * for estimating the amount of vegetation. It is the ratio of light scattered in the NIR and
 * absorbed in red bands, which reduces the effects of atmosphere and topography.
 * See [SR raster function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/band-arithmetic-function.htm#ESRI_SECTION2_D4AC401078E5407CA3F970B80A054CE8).
 *
 * Equation: SR = NIR / Red
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates SR from a 4-band image whose bands are arranged in BGRI order.
 * const sr = rasterFunctionUtils.bandArithmeticSR({
 *   nirBandId: 3,
 *   redBandId: 2
 * });
 */
export function bandArithmeticSR(parameters: SRBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NDVIre. The Red-Edge NDVI (NDVIre) method is a vegetation index for estimating vegetation health using the red-edge band.
 * It is especially useful for estimating crop health in the mid to late stages of growth, when the chlorophyll concentration is relatively higher.
 * Also, NDVIre can be used to map the within-field variability of nitrogen foliage to understand the fertilizer requirements of crops.
 * See [NDVIre raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndvire.htm).
 *
 * Equation: NDVIre = (NIR - RedEdge)/(NIR + RedEdge)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NDVI (rededge).
 * const ndvire = rasterFunctionUtils.bandArithmeticNDVIre({
 *   nirBandId: 3,
 *   reBandId: 4
 * });
 */
export function bandArithmeticNDVIre(parameters: NDVIreBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate SRre. The Red-Edge Simple Ratio (SRre) method is a vegetation index for estimating the amount of healthy and stressed vegetation.
 * It is the ratio of light scattered in the NIR and red-edge bands, which reduces the effects of atmosphere and topography.
 * See [SRre raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/srre.htm).
 *
 * Equation: SRre = NIR / RedEdge
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates SR (rededge).
 * const srre = rasterFunctionUtils.bandArithmeticSRre({
 *   nirBandId: 3,
 *   reBandId: 4
 * });
 */
export function bandArithmeticSRre(parameters: SRreBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate MTVI2. The Modified Triangular Vegetation Index (MTVI2) method is a vegetation index for detecting leaf chlorophyll content at
 * the canopy scale while being relatively insensitive to leaf area index. It uses reflectance in the green, red, and NIR bands.
 * See [MTVI2 raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/mtvi2.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates MTVI2 from a 4-band image whose bands are arranged in BGRI order.
 * const mtvi2 = rasterFunctionUtils.bandArithmeticMTVI2({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   greenBandId: 1
 * });
 */
export function bandArithmeticMTVI2(parameters: MTVI2BandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate RTVICore. The Red-Edge Triangulated Vegetation Index (RTVICore) method is a vegetation index for estimating leaf area index
 * and biomass. This index uses reflectance in the NIR, red-edge, and green spectral bands. See [RTVICore raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/rtvicore.htm).
 *
 * Equation: RTVICore = 100 * (NIR - RedEdge) - 10 * (NIR - Green)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates RTVICore from a 4-band image whose bands are arranged in BGRI order.
 * const rtviCore = rasterFunctionUtils.bandArithmeticRTVICore({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   greenBandId: 1
 * });
 */
export function bandArithmeticRTVICore(parameters: RTVICoreBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate CIre. The Chlorophyll Index - Red-Edge (CIre) method is a vegetation index for estimating the chlorophyll content in leaves
 * using the ratio of reflectivity in the NIR and red-edge bands. See [CIre raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/cire.htm).
 *
 * Equation: CIre = (NIR / RedEdge)-1
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates CI (Red-Edge).
 * const cire = rasterFunctionUtils.bandArithmeticCIre({
 *   nirBandId: 3,
 *   reBandId: 4
 * });
 */
export function bandArithmeticCIre(parameters: CIreBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate CIg. Chlorophyll index - Green (CIG) method is a vegetation index for estimating the chlorophyll content in leaves using
 * the ratio of reflectivity in the NIR and green bands. See [CIg raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/cig.htm).
 *
 * Equation: CIg = (NIR / Green)-1
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates CI (green) from a 4-band image whose bands are arranged in BGRI order.
 * const cig = rasterFunctionUtils.bandArithmeticCIg({
 *   nirBandId: 3,
 *   greenBandId: 1
 * });
 */
export function bandArithmeticCIg(parameters: CIgBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NDWI. The Normalized Difference Water Index (NDWI) method is an index for delineating and monitoring content changes in
 * surface water. It is computed with the NIR and green bands. See [NDWI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndwi.htm).
 *
 * Equation: NDWI = (Green - NIR) / (Green + NIR)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NDWI from a 4-band image whose bands are arranged in BGRI order.
 * const ndwi = rasterFunctionUtils.bandArithmeticNDWI({
 *   nirBandId: 3,
 *   greenBandId: 1
 * });
 */
export function bandArithmeticNDWI(parameters: NDWIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate EVI. The Enhanced Vegetation Index (EVI) method is an optimized vegetation index that accounts for atmospheric influences
 * and vegetation background signal. It's similar to NDVI but is less sensitive to background and atmospheric noise, and it does not become as saturated
 * as NDVI when viewing areas with very dense green vegetation.  See [EVI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/evi.htm).
 *
 * Equation: EVI = 2.5 * (NIR - Red) / (NIR + 6 * Red - 7.5 * Blue + 1)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates EVI from a 4-band image whose bands are arranged in BGRI order.
 * const evi = rasterFunctionUtils.bandArithmeticEVI({
 *   nirBandId: 3,
 *   redBandId: 2,
 *   blueBandId: 0
 * });
 */
export function bandArithmeticEVI(parameters: EVIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate IronOxide. The Iron Oxide (ironOxide) ratio method is a geological index for identifying rock features that have experienced
 * oxidation of iron-bearing sulfides using the red and blue bands. It is useful in identifying iron oxide features below vegetation canopies and is
 * used in mineral composite mapping. See [IronOxide raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ironoxide.htm).
 *
 * Equation: IronOxide = Red / Blue
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * //Creates IronOxide from a 4-band image whose bands are arranged in BGRI order.
 * const ironOxide = rasterFunctionUtils.bandArithmeticIronOxide({
 *   redBandId: 2,
 *   blueBandId: 0
 * });
 */
export function bandArithmeticIronOxide(parameters: IronOxideBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate FerrousMinerals. The Ferrous Minerals (ferrousMinerals) ratio method is a geological index for identifying rock features containing
 * some quantity of iron-bearing minerals using the SWIR and NIR bands. It is used in mineral composite mapping.
 * See [FerrousMinerals raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ferrousminerals.htm).
 *
 * Equation: FM = SWIR / NIR
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates FerrousMinerals index.
 * const ferrousMinerals = rasterFunctionUtils.bandArithmeticFerrousMinerals({
 *   swir1BandId: 6,
 *   nirBandId: 3
 * });
 */
export function bandArithmeticFerrousMinerals(parameters: FerrousMineralsBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate ClayMinerals. The Clay Minerals (clayMinerals) ratio method is a geological index for identifying mineral features containing
 * clay and alunite using two shortwave infrared (SWIR) bands. It is used in mineral composite mapping.
 * See [ClayMinerals raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/clayminerals.htm).
 *
 * Equation: CM = SWIR1 / SWIR2
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * //Creates ClayMinerals index.
 * const clayMinerals = rasterFunctionUtils.bandArithmeticClayMinerals({
 *   swir1BandId: 6,
 *   swir2BandId: 7
 * });
 */
export function bandArithmeticClayMinerals(parameters: ClayMineralsBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate WNDWI. The Weighted Normalized Difference Water Index (WNDWI) method is a water index developed to reduce errors typically
 * encountered in other water indices, including water turbidity, small water bodies, or shadow in remote sensing scenes.
 *
 * Equation: WNDWI = [Green – α * NIR – (1 – α) * SWIR ] / [Green + α * NIR + (1 – α) * SWIR]
 *
 * where `a` is weighted coefficient ranging from 0 to 1.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates WNDWI.
 * const wndwi = rasterFunctionUtils.bandArithmeticWNDWI({
 *   greenBandId: 1,
 *   nirBandId: 3,
 *   swirBandId: 6
 * });
 */
export function bandArithmeticWNDWI(parameters: WNDWIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate BAI. The Burn Area Index (BAI) uses the reflectance values in the red and NIR portion of the spectrum to identify
 * the areas of the terrain affected by fire. See [BAI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/bai.htm).
 *
 * Equation: BAI = 1/((0.1 -RED) * (0.1 -RED) + (0.06 - NIR) * (0.06 - NIR))
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * //Creates BAI from a 4-band image whose bands are arranged in BGRI order.
 * const bai = rasterFunctionUtils.bandArithmeticBAI({
 *   redBandId: 1,
 *   nirBandId: 3
 * });
 */
export function bandArithmeticBAI(parameters: BAIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NBR.  The Normalized Burn Ratio Index (NBRI) uses the NIR and SWIR bands to emphasize burned areas, while mitigating
 * illumination and atmospheric effects. Your images should be corrected to reflectance values before using this index.
 * See [NBR raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/nbr.htm).
 *
 * Equation: NBR = (NIR - SWIR) / (NIR+ SWIR)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NBR index.
 * const nbr = rasterFunctionUtils.bandArithmeticNBR({
 *   nirBandId: 3,
 *   swirBandId: 5
 * });
 */
export function bandArithmeticNBR(parameters: NBRBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NDBI.  The Normalized Difference Built-up Index (NDBI) uses the NIR and SWIR bands to emphasize manufactured built-up
 * areas. It is ratio based to mitigate the effects of terrain illumination differences as well as atmospheric effects.
 * See [NDBI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndbi.htm).
 *
 * Equation: NDBI = (SWIR - NIR) / (SWIR + NIR)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NDBI index.
 * const ndbi = rasterFunctionUtils.bandArithmeticNDBI({
 *   nirBandId: 3,
 *   swirBandId: 5
 * });
 */
export function bandArithmeticNDBI(parameters: NDBIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NDMI.  The Normalized Difference Moisture Index (NDMI) is sensitive to the moisture levels in vegetation. It is used
 * to monitor droughts and fuel levels in fire-prone areas. It uses NIR and SWIR bands to create a ratio designed to mitigate illumination and
 * atmospheric effects. See [NDMI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndmi.htm).
 *
 * Equation: NDMI = (NIR - SWIR1)/(NIR + SWIR1)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates NDMI index.
 * const ndmi = rasterFunctionUtils.bandArithmeticNDMI({
 *   nirBandId: 3,
 *   swirBandId: 5
 * });
 */
export function bandArithmeticNDMI(parameters: NDMIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate NDSI.  The Normalized Difference Snow Index (NDSI) is designed to use MODIS (band 4 and band 6) and Landsat TM
 * (band 2 and band 5) for identification of snow cover while ignoring cloud cover. Since it is ratio based, it also mitigates atmospheric effects.
 * See [NDSI raster function](https://pro.arcgis.com/en/pro-app/latest/arcpy/spatial-analyst/ndsi.htm).
 *
 * Equation:  NDSI = (Green - SWIR) / (Green + SWIR)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Calculates NDSI using Landsat 8.
 * const ndsi = rasterFunctionUtils.bandArithmeticNDSI({
 *   greenBandId: 2,
 *   swirBandId: 5
 * });
 */
export function bandArithmeticNDSI(parameters: NDSIBandParameters): RasterFunction;

/**
 * Creates a Band Arithmetic function to calculate MNDWI. The Modified Normalized Difference Water Index (MNDWI) uses green and SWIR bands for the enhancement of open water
 * features. It also diminishes built-up area features that are often correlated with open water in other indices.
 *
 * Equation: MNDWI = (Green - SWIR) / (Green + SWIR)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates MNDWI.
 * const mndwi = rasterFunctionUtils.bandArithmeticMNDWI({
 *   greenBandId: 1,
 *   swirBandId: 6
 * });
 */
export function bandArithmeticMNDWI(parameters: MNDWIBandParameters): RasterFunction;

/**
 * Creates a custom Band Arithmetic function. ser defined method. When using the user defined method to define your band arithmetic algorithm, you can enter
 * a single-line algebraic formula to create a single-band output. The supported operators are -,+,/,*, and unary -. To identify the bands, add B or b
 * to the beginning of the band number. See [Band Arithmetic function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/band-arithmetic-function.htm).
 *
 * equation: (b1 - b0) / (b1 + b0)
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * //Creates a custom band arithmetic index that creates a normalized differential band ratio.
 * const ndvi = rasterFunctionUtils.bandArithmeticCustom({
 *   bandIndexes: "(b1 - b0) / (b1 + b0)"
 * });
 */
export function bandArithmeticCustom(parameters: CustomBandParameters): RasterFunction;

/**
 * Creates a Compute Change function that analyzes changes between two rasters.
 * [Compute Change function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/compute-change-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Compute Change function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/compute-change-function.htm)
 * @example
 * // Compute the change between the two images.
 * layer.rasterFunction = rasterFunctionUtils.computeChange({
 *     method: "difference",
 *     raster: "$1",
 *     raster2: "$2"
 *    });
 * });
 */
export function computeChange(parameters: ComputeChangeParameters): RasterFunction;

/**
 * Creates a Threshold function that creates a binary output, with 1 representing high pixel values.
 * It uses the Otsu method and the input image is assumed to have a bimodal histogram.
 * See [Binary Thresholding function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/binary-thresholding-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Binary Thresholding function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/binary-thresholding-function.htm)
 * @example
 * // Create threshold function from a raster with bimodal histogram distribution.
 * layer.rasterFunction = rasterFunctionUtils.threshold({});
 */
export function threshold(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Converts a multiband image into a single-band grayscale image. Specified weights are applied to each of the input bands, and normalization is applied to the output image.
 * The weights are often applied because some bands have variable importance depending on the application. For example, the blue band often contains more noise than other bands.
 *
 * @param parameters - The grayscale parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.29
 * @example
 * // Clips image using user specifed extent and keeps the image that is inside the extent.
 * layer.rasterFunction = rasterFunctionUtils.grayscale({
 *   weights: [3, 2, 5]
 * });
 */
export function grayscale(parameters: GrayscaleParameters): RasterFunction;

/**
 * Creates a Color Space Conversion function that converts the color model between the hue, saturation, and value (HSV) color space and red, green, and blue (RGB).
 * [Color Model Conversion function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/color-model-conversion-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Color Model Conversion function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/color-model-conversion-function.htm)
 * @example
 * // Converts the image to hsv color space.
 * layer.rasterFunction = rasterFunctionUtils.colorspaceConversion({
 *   conversionType: "rgb-to-hsv"
 * });
 */
export function colorspaceConversion(parameters: ColorspaceConversionParameters): RasterFunction;

/**
 * Creates a Spectral Conversion function that applies a matrix to a multiband image to affect the color values of the output.
 * Each pixel of the output is the dot product of the conversion matrix and the raster pixel value vector.
 * See [Spectral Conversion function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/spectral-conversion-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Spectral Conversion function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/spectral-conversion-function.htm)
 * @example
 * // Creates a spectral conversion function from a raster with 3 bands.
 * layer.rasterFunction = rasterFunctionUtils.spectralConversion({
 *   conversionMatrix: [0.5, 0.3, 0.2, 0.1, 0.8, 0.1, 0.1, 0.1, 0.8]
 * });
 */
export function spectralConversion(parameters: SpectralConversionParameters): RasterFunction;

/**
 * Creates a Tasseled Cap (Kauth-Thomas) transformation function to analyze and map vegetation phenomenology and urban development changes detected by various satellite sensor systems.
 * See [Tasseled Cap function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/tasseled-cap-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Tasseled Cap function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/tasseled-cap-function.htm)
 * @example layer.rasterFunction = rasterFunctionUtils.tasseledCap({});
 */
export function tasseledCap(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a Colormap function to define a colormap for a raster by specifying a corresponding color for each pixel value.
 * See [Colormap function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/colormap-function.htm).
 *
 * @param parameters - The parameters object.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates a colormap to map pixel value 0 to red and 10 to green.
 * const colormap = rasterFunctionUtils.colormap({
 *   colormap: [
 *     [0, 255, 0, 0],
 *     [10, 0, 255, 0]
 *   ]
 * });
 * @example
 * // Creates a colormap to map pixel value 0 to red and 10 to green.
 * const colormap = rasterFunctionUtils.colormap({
 *   colormap: [
 *     {value: 0, color: "red"},
 *     {value: 10, color: "green"}
 *   ]
 * });
 * @example
 * // Creates a colormap to map pixel value 0 to red and 10 to green.
 * const colormap = rasterFunctionUtils.colormap({
 *   colormap: [
 *     {value: 0, color: "#ff0000"},
 *     {value: 10, color: "#00ff00"}
 *   ]
 * });
 * @example
 * // Creates a colormap to map pixel value using a named colorramp
 * const colormap = rasterFunctionUtils.colormap({
 *   colorRampName: "red-to-green"
 * });
 */
export function colormap(parameters: ColormapParameters | ColormapByNameParameters | ColormapByRampParameters): RasterFunction;

/**
 * Works with a single band image service that has an internal color map. It converts the image to a three-band 8-bit RGB raster.
 * For more information, see [Colormap To RGB function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/colormap-to-rgb-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.31
 */
export function colormapToRGB(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a Statistics And Histogram function to define the statistics and histogram of a raster.
 * See [Statistics And Histogram function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/statistics-and-histogram-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // attach statistics and histograms to the input imagery.
 * const statsHistFunction = rasterFunctionUtils.statisticsHistogram({
 *   statistics: [{ min: 1, max: 5, mean: 3, standardDeviation: 1 }],
 *   histograms: [{ min: 1, max: 5, counts: [100, 200, 100, 200, 100] }]
 * });
 */
export function statisticsHistogram(parameters: StatisticsHistogramParameters): RasterFunction;

/**
 * Creates an Attribute Table function to specify an attribute table for the input categorical raster.
 * See [Attribute Table function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/attribute-table-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Attach a classification table to the categorical imagery data.
 *
 * const attributeTable = FeatureSet.fromJSON({
 *  displayFieldName: "",
 *  fields: [
 *    {
 *      name: "ObjectID",
 *      type: "esriFieldTypeOID",
 *      alias: "OID"
 *    },
 *    {
 *      name: "Value",
 *      type: "esriFieldTypeInteger",
 *      alias: "Value"
 *    },
 *    {
 *      name: "ClassName",
 *      type: "esriFieldTypeString",
 *      alias: "ClassName",
 *      length: 256
 *    },
 *    {
 *      name: "Red",
 *      type: "esriFieldTypeInteger",
 *      alias: "Red"
 *    },
 *    {
 *      name: "Green",
 *      type: "esriFieldTypeInteger",
 *      alias: "Green"
 *    },
 *    {
 *      name: "Blue",
 *      type: "esriFieldTypeInteger",
 *      alias: "Blue"
 *    },
 *    {
 *      name: "Alpha",
 *      type: "esriFieldTypeInteger",
 *      alias: "Alpha"
 *     }
 *   ],
 *   features: [
 *     {
 *       attributes: {
 *         ObjectID: 1,
 *         Value: 10,
 *         ClassName: "c0",
 *         Red: 255,
 *         Green: 190,
 *         Blue: 190,
 *         Alpha: 255
 *       }
 *     },
 *     {
 *       attributes: {
 *         ObjectID: 2,
 *         Value: 11,
 *         ClassName: "c1",
 *         Red: 255,
 *         Green: 127,
 *         Blue: 127,
 *         Alpha: 255
 *       }
 *     }
 *   ]
 * });
 * const tableFunction = rasterFunctionUtils.table({ attributeTable });
 */
export function table(parameters: TableParameters): RasterFunction;

/**
 * Creates an Extract Band function to extract one or more bands from a multiband raster. To use bandNames or bandWavelengths, the
 * data source must have corresponding key properties information.
 * See [Extract Band function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/extract-bands-function.htm).
 *
 * @param parameters - The parameters object.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Creates a false color composite from a Landsat TM multispectral image.
 * const nrg = rasterFunctionUtils.extractBand({
 *   bandIds: [3, 2, 1]
 * });
 *
 * const nrg = rasterFunctionUtils.extractBand({
 *   bandNames: ["NearInfrared_1", "Red", "Green"]
 * });
 *
 * const nrg = rasterFunctionUtils.extractBand({
 *   bandWavelengths: [800, 650, 550]
 * });
 */
export function extractBand(parameters: ExtractBandByIdParameters | ExtractBandByNameParameters | ExtractBandByWavelengthParameters): RasterFunction;

/**
 * Creates a Color Composite function that produces a three-band raster from a multiband raster dataset in which each band can use an algebraic calculation based on band algebra.
 * [Create Color Composite function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/create-color-composite-function.htm)
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - Input parameters for creating a custom color composite from input raster..
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Create Color Composite function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/create-color-composite-function.htm)
 * @example
 * // Create a color composite using the first two bands.
 * const rasterFunction = rasterFunctionUtils.createColorComposite({
 *   method: "name",
 *   redBand: "B1",
 *   greenBand: "B2",
 *   blueBand: "B1-B2"
 * });
 */
export function createColorComposite(parameters: ColorCompositeByIdParameters | ColorCompositeByNameParameters): RasterFunction;

/**
 * Creates a Composite Bands function to combine multiple inputs into one multiband raster.
 * See [Composite Bands function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/composite-bands-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 */
export function compositeBand(parameters: BaseNRasterFunctionParameters): RasterFunction;

/**
 * Creates a Remap function to change or reclassify the pixel values of the raster.
 * See [Remap function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/remap-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Remap costal elevation values into flood risk categories.
 * const warmWater = rasterFunctionUtils.remap({
 *   rangeMaps: [
 *    { range: [-100, 10], output: 0 },
 *    { range: [10, 1000], output: 200 }
 *   ]
 * });
 */
export function remap(parameters: RemapParameters): RasterFunction;

/**
 * Creates a Transpose Bits function that unpacks the bits of the input pixel and maps them to specified bit locations in the output pixel.
 * Use this function to manipulate multiple bit sequences from an input, such as the Landsat 8 quality band.
 * See [Transpose Bits function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/transpose-bits-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/references/core/layers/ImageryLayer/) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Transpose Bits function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/transpose-bits-function.htm)
 * @example
 * layer.rasterFunction = rasterFunctionUtils.transposeBits({
 *     inputBitPositions: [4, 5],
 *     outputBitPositions: [0, 1],
 *     raster: "$2", // the image whose objectId is 2 in a dynamic image service
 *    });
 * });
 */
export function transposeBits(parameters: TransposeBitsParameters): RasterFunction;

/**
 * Creates a Mask function to specify one or more NoData values, or a range of valid pixel values, to be removed from an output raster.
 * See [Mask function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/mask-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Only show sea surface temperature above 10 degrees.
 * const warmWater = rasterFunctionUtils.mask({
 *   includedRanges: [[10, 50]]
 * });
 */
export function mask(parameters: MaskParameters): RasterFunction;

/**
 * Extracts a portion of an image based on an [Extent](https://developers.arcgis.com/javascript/latest/references/core/geometry/Extent/) or a [Polygon](https://developers.arcgis.com/javascript/latest/references/core/geometry/Polygon/) geometry.
 * The clip output includes any pixels that intersect the clip geometry.
 *
 * @param parameters - The clip parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.29
 * @example
 * // Clips image using user specifed extent and keeps the image that is inside the extent.
 * layer.rasterFunction = rasterFunctionUtils.clip({
 *   geometry: extent,
 *   keepOutside: false
 * });
 */
export function clip(parameters: ClipParameters): RasterFunction;

/**
 * Creates a raster function that adds (sums