/**
 * Various utility functions that create [RasterFunction](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-support-RasterFunction.html) 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/api-reference/esri-layers-ImageryLayer.html) and [ImageryTileLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryTileLayer.html).
 *
 * @since 4.28
 */
import type RasterFunction from "./RasterFunction.js";
import type { Base2RasterFunctionParameters, BaseNRasterFunctionParameters, BaseRasterFunctionParameters, RasterArgument } from "../raster/functions/types.js";
import type { BaseStretchParameters, ContrastBrightnessParameters, ConvolutionFunctionCustomParameters, ConvolutionFunctionParameters, MinMaxStretchParameters, PercentClipStretchParameters, StddevStretchParameters } from "../raster/functions/creators/createAppearenceFunctions.js";
import type { BAIBandArguments, CIgBandArguments, CIreBandArguments, ClayMineralsBandArguments, CustomBandParameters, EVIBandArguments, FerrousMineralsBandArguments, GDNVIBandArguments, GEMIBandArguments, IronOxideBandArguments, LandsatBandArguments, MNDWIBandArguments, MSAVIBandArguments, MTVI2BandArguments, NBRBandArguments, NDBIBandArguments, NDMIBandArguments, NDSIBandArguments, NDVIBandArguments, NDVIreBandArguments, NDWIBandArguments, PVIBandArguments, RTVICoreBandArguments, SAVIBandArguments, SRBandArguments, SRreBandArguments, SultanArguments, TSAVIBandArguments, VARIBandArguments, WNDWIBandArguments } from "../raster/functions/creators/createBandIndexFunctions.js";
import type { ComputeChangeParameters } from "../raster/functions/creators/createChangeFunctions.js";
import type { GrayscaleParameters, ColorspaceConversionParameters, SpectralConversionParameters } from "../raster/functions/creators/createConversionFunctions.js";
import type { ClipParameters, ColorCompositeByIdParameters, ColorCompositeByNameParameters, ColormapByNameParameters, ColormapByRampParameters, ColormapParameters, ExtractBandByIdParameters, ExtractBandByNameParameters, ExtractBandByWavelengthParameters, MaskParameters, RemapParameters, StatisticsHistogramParameters, TableParameters, TransposeBitsParameters } from "../raster/functions/creators/createDataManagementFunctions.js";
import type { SetNullParameters, ConditionalParameters, CalculatorParameters, StatType } from "../raster/functions/creators/createLocalFunctions.js";
import type { WeightedOverlayParameters, WeightedSumParameters } from "../raster/functions/creators/createMultiRasterAnalysisFunctions.js";
import type { ArgStatisticsDurationParameters, ArgStatisticsParameters, StatisticsParameters } from "../raster/functions/creators/createStatisticsFunctions.js";
import type { SlopeParameters, HillshadeParameters, ShadedReliefWithColormapParameters, ShadedReliefWithColorRampNameParameters, ShadedReliefWithColorRampParameters, CurvatureParameters } from "../raster/functions/creators/createSurfaceFunctions.js";
import type { RasterPixelType } from "./RasterTypes.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: NDVIBandArguments): 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: SAVIBandArguments): 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: TSAVIBandArguments): 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: MSAVIBandArguments): 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: GEMIBandArguments): 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: PVIBandArguments): 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: LandsatBandArguments): 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: SultanArguments): 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: VARIBandArguments): 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: GDNVIBandArguments): 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: SRBandArguments): 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: NDVIreBandArguments): 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: SRreBandArguments): 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: MTVI2BandArguments): 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: RTVICoreBandArguments): 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: CIreBandArguments): 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: CIgBandArguments): 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: NDWIBandArguments): 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: EVIBandArguments): 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: IronOxideBandArguments): 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: FerrousMineralsBandArguments): 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: ClayMineralsBandArguments): 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: WNDWIBandArguments): 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: BAIBandArguments): 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: NBRBandArguments): 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: NDBIBandArguments): 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: NDMIBandArguments): 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: NDSIBandArguments): 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: MNDWIBandArguments): 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/api-reference/esri-layers-ImageryLayer.html) 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/api-reference/esri-layers-ImageryLayer.html) 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/api-reference/esri-layers-ImageryLayer.html) 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).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html) only.
 *
 * @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/api-reference/esri-layers-ImageryLayer.html) 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/api-reference/esri-layers-ImageryLayer.html) 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/api-reference/esri-layers-ImageryLayer.html) 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/api-reference/esri-geometry-Extent.html) or a [Polygon](https://developers.arcgis.com/javascript/latest/api-reference/esri-geometry-Polygon.html) 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) the values of two rasters on a pixel-by-pixel basis.
 * See [Plus function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/plus-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.plus({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 100,
 *   outputPixelType: "u16"
 * });
 */
export function plus(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that subtracts the value of the second input raster from the value of the first input raster on a pixel-by-pixel basis.
 * See [Minus function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/minus.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.minus({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1,
 *   outputPixelType: "s16"
 * });
 */
export function minus(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that multiplies the values of two rasters on a pixel-by-pixel basis.
 * See [Times function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/times-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.times({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function times(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the square root of the pixel values in a raster.
 * See [Suqare Root function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/square-root-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.sqrt({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function sqrt(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that raises the pixel values in a raster to the power of the values found in another raster.
 * See [Power function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/power-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.power({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function power(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse cosine of the pixels in a raster.
 * See [ACos function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/acos-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.acos({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function acos(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse sine of the pixels in a raster.
 * See [ASin function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/asin-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.asin({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function asin(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse tangent of the pixels in a raster.
 * See [Atan function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/atan-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.atan({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function atan(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse hyperbolic tangent of the pixels in a raster.
 * See [Atanh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/atanh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.atanh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function atanh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the absolute value of the pixels in a raster.
 * See [Abs function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/abs-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.abs({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function abs(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise And operation on the binary values of two input rasters.
 * See [Bitwise And function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-and-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseAnd({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function bitwiseAnd(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise Left Shift operation on the binary values of two input rasters.
 * See [Bitwise Left Shift function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-left-shift-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseLeftShift({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function bitwiseLeftShift(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise Not (complement) operation on the binary value of an input raster.
 * See [Bitwise Not function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-not-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseNot({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "s16"
 * });
 */
export function bitwiseNot(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise Or operation on the binary values of two input rasters.
 * See [Bitwise Or function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-or-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseOr(
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function bitwiseOr(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise Right Shift operation on the binary values of two input rasters.
 * See [Bitwise Right Shift function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-right-shift-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseRightShift({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function bitwiseRightShift(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Bitwise Xor operation on the binary values of two input rasters.
 * See [Bitwise Xor function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/bitwise-xor-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.bitwiseXor({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function bitwiseXor(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Boolean And operation on the pixel values of two input rasters
 * See [Boolean And function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/boolean-and-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.booleanAnd({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function booleanAnd(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Boolean Not (complement) operation on the pixel values of the input raster.
 * See [Boolean Not function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/boolean-not-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.booleanNot({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "u8"
 * });
 */
export function booleanNot(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Boolean Or operation on the pixel values of two input rasters
 * See [Boolean Or function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/boolean-or-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.booleanOr({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function booleanOr(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a Boolean Xor operation on the pixel values of two input rasters
 * See [Boolean Xor function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/boolean-xor-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.booleanXor({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function booleanXor(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the cosine of the pixels in a raster.
 * See [Cos function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/cos-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.cos({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function cos(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the hyperbolic cosine of the pixels in a raster.
 * See [Cosh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/cosh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.cosh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function cosh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that divides the values of two rasters on a pixel-by-pixel basis.
 * See [Divide function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/divide-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.divide({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function divide(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs an equal-to operation on two rasters on a pixel-by-pixel basis.
 * See [Equal To function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/equal-to-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.equalTo({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function equalTo(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the base e exponential of the pixels in a raster.
 * See [Exp function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/exp-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.exp({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function exp(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the base 10 exponential of the pixels in a raster.
 * See [Exp10 function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/exp10-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.exp10({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function exp10(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the base 2 exponential of the pixels in a raster.
 * See [Exp2 function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/exp2-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.exp2({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function exp2(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a relational greater-than operation on two rasters on a pixel-by-pixel basis.
 * See [Greater Than function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/greater-than-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.greaterThan({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function greaterThan(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a relational greater-than-or-equal-to operation on two rasters on a pixel-by-pixel basis.
 * See [Greater Than Equal function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/greater-than-equal-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.greaterThanEqual({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function greaterThanEqual(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that converts each pixel value of a raster to an integer by truncation.
 * See [Int function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/int-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.int({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "u32"
 * });
 */
export function int(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that determines which values from the input raster are NoData on a pixel-by-pixel basis.
 * See [Is Null function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/is-null-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.isNull({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "u8"
 * });
 */
export function isNull(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that converts each pixel value of a raster into a floating-point representation.
 * See [Float function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/float-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.float({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function float(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a relational less-than operation on two rasters on a pixel-by-pixel basis.
 * See [Less Than function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/less-than-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.lessThan({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function lessThan(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a relational less-than-or-equal-to operation on two rasters on a pixel-by-pixel basis.
 * See [Less Than Equal function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/less-than-equal-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.lessThanEqual({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function lessThanEqual(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the natural logarithm (base e) of each pixel in a raster.
 * See [Ln function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/ln-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.log({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function log(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the base 10 logarithm of each pixel in a raster.
 * See [Log10 function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/log10-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.log10({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function log10(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the base 2 logarithm of each pixel in a raster.
 * See [Log2 function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/log2-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.log2({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function log2(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that finds the remainder (modulo) of the first raster when divided by the second raster on a pixel-by-pixel basis.
 * See [Mod function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/mod-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.mod({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function mod(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that finds the changes the sign (multiplies by -1) of the pixel values of the input raster on a pixel-by-pixel basis.
 * See [Negate function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/negate-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.negate({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function negate(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that performs a relational not-equal-to operation on two rasters on a pixel-by-pixel basis.
 * See [Not Equal function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/not-equal-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.notEqual({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function notEqual(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that returns the next lower integer, as a floating-point value, for each pixel in a raster.
 * See [Round Down function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/round-down-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.roundDown({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "s16"
 * });
 */
export function roundDown(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that returns the next higher integer, as a floating-point value, for each pixel in a raster.
 * See [Round Up function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/round-up-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.roundUp({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "s16"
 * });
 */
export function roundUp(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the sine of the pixels in a raster.
 * See [Sin function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/sin-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.sin({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function sin(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the hyperbolic sine of the pixels in a raster.
 * See [Sinh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/sinh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.sinh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function sinh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the square of the pixel values in a raster.
 * See [Square function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/square-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.square({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function square(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the tangent of the pixels in a raster.
 * See [Tan function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/tan-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.tan({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function tan(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the hyperbolic tangent of the pixels in a raster.
 * See [Tanh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/tanh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.tanh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function tanh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse hyperbolic cosine of the pixels in a raster.
 * See [Acosh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/acosh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.acosh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   outputPixelType: "f32"
 * });
 */
export function acosh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse hyperbolic sine of the pixels in a raster.
 * See [Asinh function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/asinh-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on an input raster.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.asinh({
 *   raster: rasterFunctionUtils.defaultRaster,
 *    outputPixelType: "f32"
 * });
 */
export function asinh(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that calculates the inverse tangent (based on x,y) of the pixels in a raster.
 * See [Atan2 function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/atan2-function.htm).
 *
 * @param parameters - Input parameters for performing math operations on two input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.atan2({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   raster2: 1
 * });
 */
export function atan2(parameters: Base2RasterFunctionParameters): RasterFunction;

/**
 * Creates a raster function that sets the truthy pixels (value is not 0) to NoData, and falsy pixels (value is 0) to the pixel value of the false raster.
 * See [Set Null function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/set-null-function.htm).
 *
 * @param parameters - The set null parameters object.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.setNull({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   falseRaster: 1,
 *   outputPixelType: "u8"
 * });
 */
export function setNull(parameters: SetNullParameters): RasterFunction;

/**
 * Creates a raster function that sets the truthy pixels (value is not 0) to the pixel value from a true raster, and falsy pixels (value is 0) to the pixel value of the false raster.
 * See [Con function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/con-function.htm).
 *
 * @param parameters - The  conditional parameters object.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.conditional({
 *   raster: rasterFunctionUtils.defaultRaster,
 *   trueRaster: 100,
 *   falseRaster: 10,
 *   outputPixelType: "u8"
 * });
 */
export function conditional(parameters: ConditionalParameters): RasterFunction;

/**
 * Creates a raster function that calculates a statistic from multiple rasters, on a pixel-by-pixel basis. The available statistics are majority, maximum, mean, median, minimum, minority, percentile, range, standard deviation, sum, and variety.
 * See [Cell Statistics function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/cell-statistics-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * layer.rasterFunction = rasterFunctionUtils.conditional({
 *   rasters: [rasterFunctionUtils.defaultRaster],
 *   statisticsType: "majority",
 *   processAsMultiband: true
 * });
 */
export function cellStatistics(parameters: CellStatisticsParameters): RasterFunction;

export interface CellStatisticsParameters {
  /** The output pixel type. Default is unknown (determined by input data). */
  outputPixelType?: RasterPixelType;
  /** When true, process the single input raster as multiple bands. Default is true. */
  processAsMultiband?: boolean;
  /** The input rasters. */
  rasters: RasterArgument[];
  /** The true raster, if the first input is a raster. */
  statisticsType: StatType;
}

/**
 * Creates a Raster Calculator function that performs mathematical operations using a custom expression on a set of inputs.
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Calculator function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/calculator-function.htm)
 * @example
 * // Calculate the difference between two images.
 * layer.rasterFunction = rasterFunctionUtils.calculate({
 *     inputNames: ["raster1", "raster2"],
 *     expression: "raster1 - raster2",
 *     raster: ["$1", "$2"], // the selected images from a dynamic image service
 *    });
 * });
 */
export function calculate(parameters: CalculatorParameters): RasterFunction;

/**
 * Creates a Weighted Sum function that adds up several rasters weighted by their importance.
 * See [Weighted Sum function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/weighted-sum-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Weighted Sum function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/weighted-sum-function.htm)
 * @example
 * // Perform weighted sum of three single band images.
 * layer.rasterFunction = rasterFunctionUtils.weightedSum({
 *     weights: [0.5, 0.3, 0.2],
 *     raster: ["$1", "$2", "$3"], // the selected images from a dynamic image service
 *     fields: ["Value", "Value", "Value"]
 *    });
 * });
 */
export function weightedSum(parameters: WeightedSumParameters): RasterFunction;

/**
 * Creates a Weighted Overlay function that overlays several rasters using a common measurement scale and weights each according to its importance.
 * See [Weighted Overlay function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/weighted-overlay-function.htm).
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html) only.
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @see [Weighted Overlay function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/weighted-overlay-function.htm)
 * @example
 * // Perform weighted overlay of three single band images.
 * layer.rasterFunction = rasterFunctionUtils.weightedOverlay({
 *     weights: [0.5, 0.3, 0.2],
 *     minScale: 0,
 *     maxScale: 10,
 *     raster: ["$1", "$2", "$3"], // the selected images from a dynamic image service
 *    });
 * });
 */
export function weightedOverlay(parameters: WeightedOverlayParameters): RasterFunction;

/**
 * Creates a Aspect function to identify the downslope direction of the maximum rate of change in value from each cell to its neighbors.
 * Aspect can be thought of as the slope direction. The values of the output raster are the compass direction of the aspect.
 * See [Aspect function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/aspect-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Create aspect from elevation data.
 * const aspect = rasterFunctionUtils.aspect({});
 */
export function aspect(parameters: BaseRasterFunctionParameters): RasterFunction;

/**
 * Creates a Slope function that calculates the rate of change of elevation for each digital elevation model (DEM) cell.
 * It's the first derivative of a DEM.
 * See [Slope function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/slope-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Create a slope from elevation data.
 * const slope = rasterFunctionUtils.slope({
 *   slopeType: "degree",
 *   zFactor: 1
 * });
 */
export function slope(parameters: SlopeParameters): RasterFunction;

/**
 * Creates a hillshade function. The hillshade function produces a grayscale 3D representation of the terrain surface, with the sun's relative position taken into
 * account for shading the image. For more information, see [Hillshade function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/hillshade-function.htm)
 * and [How Hillshade works](https://pro.arcgis.com/en/pro-app/latest/tool-reference/3d-analyst/how-hillshade-works.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.31
 * @example
 * // Create hillshade.
 * const hillshade = rasterFunctionUtils.hillshade({
 *   aAzimuth: 215.0,
 *   altitude: 75.0,
 *   zFactor: 0.3
 * });
 */
export function hillshade(parameters: HillshadeParameters): RasterFunction;

/**
 * The ShadedRelief function creates a color 3D model of the terrain by merging the images from the elevation-coded and hillshade methods.
 * For more information, see [Shaded Relief function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/shaded-relief-function.htm).
 * You can specify a colormap or colorramp value to render the shaded relief results.
 *
 * @param parameters - The parameters used to generate the shaded relief raster function.
 * @returns Returns a RasterFunction.
 * @since 4.31
 * @example
 * // Create shaded relief.
 * const shadedRelief = rasterFunctionUtils.shadedRelief({
 *   azimuth: 215.0,
 *   altitude": 75.0,
 *   zFactor": 0.3,
 *   colorMap": [
 *     [1, 255, 0, 0],
 *     [2, 0, 255, 0],
 *     [3, 125, 25, 255]
 *   ]
 * });
 */
export function shadedRelief(parameters: ShadedReliefWithColorRampParameters | ShadedReliefWithColormapParameters | ShadedReliefWithColorRampNameParameters): RasterFunction;

/**
 * Creates a Curvature function that calculates the shape or curvature of the slope. A part of a surface can be concave or convex;
 * you can tell that by looking at the curvature value. The curvature is calculated by computing the second derivative of the surface.
 * See [Curvature function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/curvature-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Create curvature from elevation data.
 * const slope = rasterFunctionUtils.curvature({
 *   curvatureType: "standard",
 *   zFactor: 1
 * });
 */
export function curvature(parameters: CurvatureParameters): RasterFunction;

/**
 * Creates a Statistics function that calculates focal statistics for each pixel of an image based on a defined focal neighborhood.
 * See [Statistics function](https://pro.arcgis.com/en/pro-app/latest/help/analysis/raster-functions/statistics-function.htm).
 *
 * @param parameters - The parameters object has the following properties.
 * @returns Returns a RasterFunction.
 * @since 4.28
 * @example
 * // Create majority statistics function to get rid of noises in the image.
 * const slope = rasterFunctionUtils.statistics({
 *   statisticsType: "majority",
 *   rows: 3,
 *   cols: 3
 * });
 */
export function statistics(parameters: StatisticsParameters): RasterFunction;

/**
 * Creates a raster function that calculates a statistical metric from all bands of input rasters.
 *
 * All raster bands from input rasters are stacked together according to their input order and assigned a 0-based incremental band index,
 * so the second raster will start from the first raster's band count, and the last band index of the last raster is `totalBandCount - 1`.
 *
 * The "min", "max", and "median" [statisticsType](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-raster-functions-creators-createStatisticsFunctions.html#ArgStatisticsParameters) returns the band index for which the given pixel attains its min, max or median value from all bands.
 * The "duration" [statisticsType](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-raster-functions-creators-createStatisticsFunctions.html#ArgStatisticsDurationParameters) finds the longest consecutive elements in the array, where each element has a value between the specified [minValue](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-raster-functions-creators-createStatisticsFunctions.html#ArgStatisticsDurationParameters) and [maxValue](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-raster-functions-creators-createStatisticsFunctions.html#ArgStatisticsDurationParameters), inclusive, and returns its length.
 *
 * > [!WARNING]
 * >
 * > Note: This function is supported on server side by [ImageryLayer](https://developers.arcgis.com/javascript/latest/api-reference/esri-layers-ImageryLayer.html) only.
 *
 * @param parameters - Input parameters for calculating arguments of the statistics on input rasters.
 * @returns Returns a RasterFunction.
 * @since 4.32
 * @example
 * layer.rasterFunction = rasterFunctionUtils.argStatistics({
 *   rasters: [rasterFunctionUtils.defaultRaster],
 *   statisticsType: "min",
 *   undefinedClass: 0
 * });
 */
export function argStatistics(parameters: ArgStatisticsParameters | ArgStatisticsDurationParameters): RasterFunction;

/**
 * A token representing the image service raster.
 *
 * @default "$$"
 * @since 4.28
 */
export const defaultRaster: "$$";